| Предыдущая глава |
↓ Содержание ↓
↑ Свернуть ↑
| Следующая глава |
программные строки — нумеруются. И эти номера тоже служат как метками для
операторов передачи управления, так и используются командами, обслуживающими
саму программу. Например RUN запускающей её выполнение, LIST выдающей
пользователю, SAVE сохраняющей на некотором внешнем носителе, или удаляющей
ненужные уже строки DELETE...
Первое, что лично мне тогда бросилось в глаза: в Бейсике это именно что
"команды", отдельные от операторов языка, и допустимые только в "прямой"
строке. А вот в Фокале — это тоже операторы (Do, Write, Eraze), вполне
уместные и в "косвенных". Так что программа вполне может обслуживать самоё
себя. (Шаг к самомодификации!)
Впрочем, на предыдущем этапе компьютеризации этих команд в Бейсике еще
небыло: программа грузилась с перфокарт в точности так же, как и фортрановская.
(О чем, кстати, говорят до сих пор сохранившиеся перфокарточные "рудименты":
операторы DATA и READ.) А на следующем — уже небыло: Бейсик сделали в виде
"турбо-среды" — программа набиралась и обслуживалась с помощью встроенного в
турбо-среду редактора и системы меню.
А вот Фокал и изначально был диалоговым, и желает таковым оставаться впредь!
((Лирическое отступление.
Так называемый "интерфейс командной строки", который и использует Фокал,
это реально круто, что бы нынче о нём глупцы ни думали... Он на порядок мощнее
более "современных" и "продвинутых", и при том на два порядка дешевле и проще
в реализации. Позволяет "с помощью хилободов управлять гигабайтами" (Ц).
Но недостатки — продолжение достоинств: ненаглядно и трудоёмко (по
сравнению, например, с тыканьем в иконки мышкою, когда на экране всё наглядно
разрисовано): надо набирать командные строчки, знать командный язык, иметь
алгоритмическое мышление и держать в голове модель предметной области... Да,
сейчас это уровень крутых профессионалов. Хотя, казалось бы — чего же тут
особенного?!
Чтобы достоинства реализовались, что и позволит мириться с недостатками,
командный язык обязательно должен быть языком программирования, по-возможности
хорошо продуманным. Как например UNIX`овский sh. Фокалу есть на кого равняться!
Конец лирического отступления.))
Следующее принципиальное отличие: в Бейсике номера строк — целые числа,
а в Фокале — дробные. В результате бейсиковская программа — сплошной массив
строк, а фокаловская распадается на "группы". В каждой из которых удобно
разместить "подпрограмму", выполняющую одно законченное сложное действие.
Более того, в Фокале группа — это "естественная подпрограмма": получив
управление с помощью оператора вызова подпрограмм Do (а не Go или If, которые
просто передают управление строке с указанным в них номером) группа, по
достижении её конца, вернёт управление в точку вызова (следующему после Do
оператору) даже в том случае, если там в ней небыло оператора возврата из
подрограммы Ret.
Заметим, что "естественной подпрограммой" является так же и каждая
отдельная строка, и тело цикла — остаток строки после оператора For.
Чтобы вызвать подпрограмму-строку, адрес перехода в операторе Do должен
быть дробным числом, а чтобы всю группу — целым. Впрочем, так и во всех
остальных операторах, имеющих дело с программными строчками. Если же надо
указать всю программу целиком, это делается с помощью ключевого слова Ales
(что собственно и значит "всё".) И, кстати: везде, где по смыслу нужен номер
строки, может быть вовсе не константа (как в большинстве реализаций всё того
же Бейсика), а выражение произвольной сложности. (Впрочем, как и везде, где
по смыслу нужно число.) Получается в том числе "вычисляемый переход"...
(Поэтому, в отличии например от Бейсика, в Фокале нумерация строк — вещь
принципиально важная.)
Пользуясь тем, что каждая строка — тоже естественная подпрограмма, можно
при отладке запускать строчки поштучно и после каждой смотреть что она сделала.
Если же в ней есть передача управления, то чтобы это отслеживать, есть режим
"трассировки" — включается (и выключается) оператором ? (вопросительный знак).
При которой выполнение оператора сопровождается выдачей его на терминал.
Оператор цикла сконструирован так, чтобы помещался в одной (в том числе
"нулевой") строке. Но ежели остатка строки под тело цикла мало — его можно
продолжить в другой строке, передав туда управление оператором Go. После её
завершения, управление опять вернётся заголовку цикла. (Ну или выделить под это
целую группу, передав туда управление оператором Do.) А вот досрочно выйти из
цикла с помощью оператора Go, как в других языках — не получится. Для этого
надо присвоить параметру цикла значение больше конечного. Или сразу
конструировать цикл по-другому: из операторов условной и безусловной передачи
управления. (Ну или применить "структурный переход" — вещь из второй части...)
Специально для контуженных Бейсиком повторяю: номера строк в Фокале это
вовсе не ДВА целых числа разделенных точкой, а ОДНО число с плавающей запятой!
Так что строчки с номерами 1.1 и 1.10 это одна и та же строка. А строка с
номером 1.15 окажется между строками 1.1 и 1.2 а вовсе не где-то в конце
группы... Традиционно, в Фокаловской группе может быть не более 99 строк.
Потому как под номер строки (да и под номер группы) выделялся всего один байт.
(Экономия! Вспомним, на какой технике всё это должно было нормально работать.)
Но я сделал, чтобы номер строки — до четырёх десятичных цифр. А поелику (сильно
забегая вперёд) мы там собираемся хранить строчки, отнюдь не одни только
"программные", введена спецфункция FN сообщающая номер следующей строки для
указанной. И за одно факт, что указанная — последняя в своей группе (тогда 0),
или что её нетути (тогда -1). А если аргумент — целый, то номер самой первой
строки следующей группы. А если отрицательный — то самой первой...
Еще одно важное различие с Бейсиком: простая переменная и там и там
заводится одинаково: автоматически — при первом её упоминании. А вот
переменные с индексами (они же элементы массивов) — уже нет: в Бейсике массив
существует весь сразу целиком и для этого должен быть объявлен заранее
оператором DIM. При чем индексы в нём не как у всех нормальных людей — с нуля,
а почему-то с единицы! (Надо ли это так понимать, что рассчитано на обывателя?)
А вот в Фокале ничего и никогда заранее не объявляется. Переменная, что
простая, что с индексами одинаково заводится в индивидуальном порядке в момент
первого присваивания ей чего либо. Это не эффективно, за то удобно. И сам собою
отпадает вопрос о границах массива. Но это таки вызывает некоторые
дополнительные сложности: к одной и той же переменной можно обратиться с
помощью разного количества индексов, что еще и зависит от реализации. Впрочем
гарантируется, что нулевое значение индекса эквивалентно его отсутствию. Так
что и Y(0,0) и Y(0) это одна и та же переменная Y.
((Потому что сделано до ужаса просто: под имя и индекс — по два байта.
(Маловато? Потом побольше сделаем...) И как туда попали числа — нигде не
фиксируется! Так что индексы — не просто целые, а если число большое, оно еще
и обрезается... Была еще идея: сделать не только Y[i] или Y[i,j] но и Y.abcdef
чтобы первые две буковки тоже туда попадали, а остальные игнорировались. Но
вот пока не...
Да, это нам не Питон... (Или например Луа.) Где массив это набор пар:
ключ-значение. При чем и то и другое могут быть какого угодно типа:
полиморфизм, однако! Так что у них там даже переменных как таковых нет. Вместо
них — элементы массива: в качестве ключа — строка в роли имени, а значение
элемента — хоть число, хоть тоже строка, хоть другой массив, хоть выполняемый
код — подпрограмма получается... Но неэффективно. Так что настоящие массивы с
пронумерованными элементами у них там вроде бы тоже есть... Но Питон да и Луа
это языки третьего поколения, весьма сложные как грамматически, так и в
реализации. А Фокал — первого. И очень-очень-очень простой.))
Уничтожить переменные, освободив занятую под них память, можно только все
разом — оператором Eraze без аргументов. (Или им же с ключевым словом Ales, но
тогда уничтожается вообще всё...)
И наконец сами ключевые слова: в Фокале все они подобраны на разные буквы
алфавита. В результате чего их можно сокращать до одной только первой буквы.
(Остальные всё равно игнорируются.) Чем (вместе с отсутствием "шумовых" слов) и
достигается лаконичность Фокала: если в Бейсике в строке помещается максимум
три-четыре оператора, то в Фокале — пять-десять. ("Шумовые" слова нужны чтобы
операторы могли косить под фразы "естественного" языка. Впрочем, такого же
примитивного...)
Все буквы (и цифры) ключевого слова, кроме первой, игнорируются. Но оно
таки должно отделяться от того что дальше, каким ни будь символом-разделителем.
Например пробелом...
Если в операторе есть второе ключевое слово (вот это самое Ales например),
то к нему это тоже относится. А ежели в операторе может быть как ключевое
слово, так и число, вернее вычисляющее его выражение, которое тоже может
начинаться с этой буквы, то его всегда можно заключить в лишние скобки.
Имена переменных — какие угодно, но значимы только первые два символа.
Остальные — чисто для красоты, тоже игнорируются. Впрочем, калькулятору этого
более чем достаточно. И тоже приучает к лаконичности. Для сравнения: в Бейсике
изначально значащим был только один первый символ имени.
Имена встроенных функций опознаются по первым уникальным буквам и все
обязательно называются на букву Ф. А вот переменные на букву Ф называть нельзя,
увы. (Можно, но использовать её потом не получится.) То есть не sin, tg, sqrt,
а FSIn, FTG, FSQrt... А чтобы не запоминать, как правильно: например FTAN или
FTG — сделано чтобы и так и так.
Символы в Фокале делятся на три категории: буквы, цифры и разделители.
При чем буквой считается всё что не цифра и не разделитель, которых Фокал
знает "в лицо и по фамилии". В том числе буквами считаются: # $ ~_ @ & | :
Но ведь буквы еще бывают заглавные и строчные, а так же русские и
латинские. Не припомню как там было в других реализациях, а я сделал чтобы в
именах переменных все они различались, а в ключевых словах и именах функций
были эквивалентны.
А строку, начинающуюся вот с такой якобы-буквы, повелел считать
комментарием. Наряду с начинающейся с оператора Coment (вернее с буквы Ц).
Потому что в UNIX`е есть такая полезная традиция: распознавать тип файла не по
"расширению" (часть имени после точки), а по "сигнатуре". Каковая — первые два
(четыре, или нынче уже бог весть сколько) символов самого этого файла. В том
числе, в случае если файл — выполняемый, пользователю, какой на самом деле тип
этого файла и как его будет выполнять UNIX — без разницы. А вот для самого
UNIX`а... Если файл не в машинных кодах, а текстовый (а уж коли он выполняемый,
значит это текст программы на некотором алгоритмическом языке) то первая его
строка должна начинаться с символов # ! и содержать командную строку для
запуска евонного интерпретатора. А для самого этого интерпретатора — выглядеть
как комментарий. Вот и. А остальные такие символы — за компанию.
Пробелы, как и во всех других языках, между словами можно вставлять в
любых потребных количествах. В том числе и ни одного, если слова разделяются
какими-то другими символами-разделителями. Впрочем, в этом случае — если
границы слов Фокалу очевидны, то и запятые без надобности. (Что известно как
"синтаксический сахар".) Без запятых не обойтись только в случае, когда значим
и пропуск элемента. Ну и в выражениях правила более строгие...
((Выражения это как бы другой язык внутри вот этого. Правда очень и очень
простенький. В других языках, например в Си, он куда сложнее...)
* * *
Таким образом в памяти фокаловского интерпретатора (а значит и в
распоряжении пользователя) есть два вида ресурсов: программные строки и
переменные. Переменная хранит одно число, любое, а программная строка — тоже
любую строку, совсем не обязательно "программную": никто же этого не проверяет!
Только когда попытаются это выполнить...
Далее: программные строки различаются номерами, а это числа, с которыми
Фокал и работает. А вот переменные различаются по именам, а это строки (пусть
и всего из двух символов). Симметрия проглядывается? Да! Вот только со
строками Фокал работать не умеет. Или (пользуясь тем, что строка — это
последовательность символов, а символ обозначается коротеньким целым числом)
таки умеет, но очень-очень-очень ограниченно... (С помощью спецфункции
посимвольного ввода/вывода FCHR.)
Научить Фокал работать со строками было бы очень желательно: пригодилось бы
для множества практических целей... Вот только действия со строками совсем не
такие как с числами...
Первый подход к снаряду (а для Бейсика и единственный) — "полиморфизм".
(Оно же "динамическая типизация".) Вот те самые типы данных, от которых я выше
шарахнулся, как черт от ладана. Однако в Бейсике именно так и сделали,
сотворив из маленького и простого языка (хотя и малость аляповатого и не
больно то хорошо продуманного) сложного и громоздкого монстра...
Полиморфизм это когда одна и та же переменная может принимать значения
разных типов. И одни и те же операции применимы к ним ко всем. (Ну может быть
с некоторыми ограничениями?...)
В общем я тоже было решил хранить строки, с которыми собираемся работать,
в тех же самых переменных что и числа. Проигнорировав (или скорее просто не
сообразив), что строки-то у нас уже есть — программные. Впрочем, так делают
все и во всех алгоритмических языках... Ну вот и я туда же: придумал, как
доопределить пять фокаловских операций для работы со строками. С этого
собственно и начался проект модернизации языка "Фокал-3", числа в котором
должны были быть не простыми, а гиперкомплексными. Так до сих пор и не
реализованный. ("Три" потому что Фокал-2 уже был. И было там много чего,
включая "псевдонимы" — чтобы можно было давать подпрограммам "говорящие" имена,
подгружать код, не занимающий пространства номеров строк и доступный вот через
такое имя; переименовывать встроенные функции, сняв с имён переменных "табу"
на букву Ф, а так же передавать подпрограмме параметры "по ссылке" а не только
"по значению"... Вот только числа там были обычные — с плавающей запятой...)
Но перед этим, в качестве тренировки (да и кое-для каких практических
| Предыдущая глава |
↓ Содержание ↓
↑ Свернуть ↑
| Следующая глава |
