Язык BCPL из которого получился C

Готовясь к собеседованиям по Go я обратил внимание на то что среди его создателей Кен Томпсон - я смутно помнил что он также стоял у истоков языка C, но без подробностей. На самом деле было примерно так: Мартин Ричардс написал BCPL, Кен Томпсон переделал его в B повыкидывав "ненужное" и улучшив синтаксис, а Деннис Ритчи добавил разнообразие типов чтобы получился язык С который мы уже более-менее представляем.

И вот я решил заглянуть в BCPL - насколько он был похож и в чем отличался. Кратким обзором - сравнением с С я и хочу поделиться! Вы сможете и сами "пощупать" его при желании :)

Небольшая предыстория

"Высокоуровневые" языки программирования начались с FORTRAN-а в 1957, за которым вскоре последовали LISP и Algol в 1960. Языков похожих на Фортран с его частыми метками в строках, коммон-блоками и отсутствием рекурсии (изначально) вы сейчас уже пожалуй не найдёте (хотя Бейсик в 1963 году немало его напоминал). Лисп в разных диалектах встречается и до сих пор - в отличие от прочих он был интерпретируемым (и позволял самомодификацию кода и т.п.) - но его скобочный синтаксис всегда сперва удивляет. А вот Алгол - его очень легко перепутать с Паскалем - именно в нём появилась "блочная" структура кода, все эти begin-end (которые в С-подобных языках заменились на фигурные скобки). Фактически Алгол стал "дедушкой" всевозможных языков с "паскальным" и "сишным" синтаксисом.

В 1963 году был придуман CPL (combined programming language) - в котором begin-end попытались заменить более короткими символьными последовательностями. Этот язык однако имел необычную судьбу - он был задуман довольно сложным, для научных вычислений в том числе - и так получилось что полноценный компилятор появился лишь в 1970. Гораздо более простой язык BCPL созданный на основе CPL оказался готов раньше (1967)! Более того, был готов и язык B (1969) - упомянутое упрощение BCPL - а его "типизированная" версия под названием C появилась в 1972. Всё это привело к тому что сам CPL использовался мало и скоро практически исчез.

Мне кажется это добрым молодцам урок - придумывай проще, делай быстрее. Долгие проекты могут опоздать.

Название BCPL таким образом должно было означать что-то вроде "Basic CPL", в смысле простой или базовый - но поскольку про CPL уже начали забывать то неудивительно что Кен Томпсон для своей модификации повыкидывал не только ненужные фичи языка - но и ненужные буквы из названия.

Первый взгляд

get "LIBHDR"                // включаем заголовочный файл

let start() be $(           // вместо main - start, и скобки немного другие
    writes("Hi, People!")   // writes - Write String
$)

Программа "hello world" выглядит настолько похоже на привычную в С - мало что можно добавить. Точки с запятой в конце строки необязательны - только если нужно разделить пару стейтментов в одной строке. Скобки вокруг тела функции в данном примере можно было не ставить let start() be writes("...") - это сработает, ключевое слово "let" используется как для объявления переменных так и функций.

Посмотрим на программу вводящую и складывающую числа:

get "LIBHDR"

let start() be $(
    let a, b = 0, 0
    a := readn()
    b := readn()
    writen(a + b)
$)

Как было сказано let объявляет переменные - при этом инициализирующие значения обязательны, что не всегда удобно (в данном случае они все равно не нужны, но проинициализировать сразу чтением из readn() нельзя). Очевидно readn() считывает число а writen(...) печатает число в консоль. Обратите внимание на оператор присваивания (паскально-алгольный) в противовес знаку равенства при инициализации - напоминает ситуацию в Go...

Но главное - переменные не имеют типа! Это не потому что в языке динамические типы или duck typing - просто тип может быть только одним, хотя и в нескольких ипостасях:

• либо это целое число, равное по размеру слову процессора (скажем, 32 бита)

• либо это число - указатель, адрес памяти - на начало массива

• в массиве же могут лежать текстовые данные, строка - обычно упакованные

• и конечно указатель может указывать на функцию

Таким образом для всего этого используется один тип - вроде нашего int.

Вдогонку можно отметить что присваивание нескольких величин одним оператором возможно, например a, b := readn(), readn()- но это работает не так как в Питоне, а выполняется все равно по очереди - т.е. обменять две переменные так не получится.

Компилятор OBCPL

На случай (мало ли) если уже захотелось попробовать - в сети можно найти несколько реализаций BCPL и для современных машин - одна из по-видимому наиболее эффективных это OBCPL который может быть найден в нескольких чуть различающихся версиях, например https://github.com/SergeGris/BCPL-compiler - я взял отсюда, он легко компилируется под Linux / FreeBSD.

Онлайновых вариантов я не нашёл - поэтому добавил этот же компилятор на сайте CodeAbbey (мой сайт с задачками, теперь опенсорсный) - правда чтобы добраться до "запускалки" нужно залогиниться, но регистрация простая, не требует телефона или валидной почты.

Управляющие конструкции

При взгляде на набор всевозможных условий и циклов становится ясно почему Кен Томпсон решил это дело слегка упростить. Вот условные операторы, их три вместо одного:

• if A then B - условный оператор без альтернативы

• test A then B else C - условный оператор с альтернативой, использует другое ключевое слово (вместо if - test)

• unless A then C - условный оператор "если-не"

Здесь отметим - скобки вокруг выражений (условия) не требуются. Слово then почти всегда можно пропустить. Почему понадобился unless? Дело в том что И/ИЛИ/НЕ в языке есть, но они только битовые! Зато впоследствии он перекочевал например в Perl.

Конечно B и C могут быть блоками из нескольких стейтментов, в скобках $( ... $) - как и в привычных нам языках.

А вот циклы. Их много:

• while E do C и также until E do C - циклы "пока" и "пока-не" с пред-условием

• C repeat - бесконечный цикл, как ни странно, ключевое слово после тела

• C repeatwhile E и конечно C repeatuntil E - циклы с пост-условием (Е - оно по-прежнему не требует скобок)

• for N = E1 to E2 by K do C - цикл "for" с локальной переменной N, причем "by K" - шаг цикла можно пропустить, он конечно равен 1 по умолчанию.

Как и с условиями, тело цикла С может быть написано в "долларовых" скобках, если в нём несколько действий - а слово DO опционально.

С циклами используются такжеbreak и loop - последний является аналогом continue.

Для досрочного возврата из функции используется знакомый return но если функция возвращает значение то он превращается в resultis - и сама функция в описании должна использовать знак равенства и ключевое слово valof вместо be - пример с факториалом выглядит вот так:

let fact(n) = valof $(
    resultis n = 0 -> 1, fact(n-1) * n
$)

Здесь использован тернарный оператор - он имеет слегка другую форму чем в Си A -> B, C - вычисляется B или C в зависимости от проверки A на равенство нулю. Вообще valof и resultis это конструкция которую можно использовать и просто как отдельный блок а не функцию - может быть довольно удобно!

Массивы и Указатели

get "LIBHDR"

let start() be $(
    let a = vec 9
    for i = 0 to 9 a!i := readn()
    for i = 9 to 0 by -1 $(
        writen(a!i)
        wrch('*N')
    $)
$)

Здесь мы объявляем массив с помощью ключевого слова vec - как видно, оно резервирует память на стеке среди прочих локальных переменных - под требуемое количество ячеек. Немного путает что указывается "последний индекс" а не общий размер (то есть, 9 вместо 10 для десяти ячеек).

Обращение к элементу массива - вместо квадратных скобок - с восклицательным знаком (не удивлюсь если многие клавиатуры тогда не имели ни фигурных ни квадратных скобок). То есть a!i - И-тый элемент массива А. Функцию wrch(...) мы ещё не видели - но она очевидно печатает символ (аналог putc) - специальные символы вместо привычного слеша обозначаются звёздочкой, в данном случае это перевод строки.

Указатели, как и в Си, близко перекликаются с массивами. Символ @ позволяет получить адрес переменной, а ! наоборот "дереференсит" указатель, например:

let a, b = 0, 0
a := 15
b := @a          // B теперь указывает на A
!b := 51         // по адресу лежащему в B запишем новое число
writen(a)        // конечно оно оказалось в A

У восклицательного знака таким образом две разновидности - если он "унарный" - перед именем переменной - то это "дереференс". А если он между двумя выражениями - как в случае с элементом массива - это на самом деле "синтаксический сахар":

a!i          берем из массива по индексу, как a[i] в C
!(a + i)     прибавляем индекс к указателю и дереференсим его, как *(a + i)

Эти две строчки идентичны - то же самое сделано и в си. И отсюда же следует что можно поменят их местами i!a - что сработает и в Си по крайней мере если предупреждения на этот счет выключены.

На этом же механизме реализованы и прототипы структур. Можно объявить константы и использовать их для дереференса:

let person.age, person.iq = 0, 1
let a = vec 10
a!person.age := 25
a!person.iq := 113

Заметьте что точка - это просто допустимый символ в идентификаторе, к созданию структуры он не относится. К сожалению в таком виде всё-таки нужно аккуратно следить чтобы поля одной структуры в массиве не пересеклись с полями следующей. Автор довольно подробно поясняет эту технику в своей книге.

Динамические массивы в базовый стандарт языка не входят, но присутствуют по словам автора почти в любой реализации. Например в OBCPL для них используются функции getvec и freevec (аналоги malloc и free).

Как вскользь упоминалось выше, указатели на функции используются легко и непринуждённо, в отличие от Си не приходится мудрить с декларацией типа:

    let blaha = 0
    blaha := writes
    blaha("muha")

Заключение

Мы много чего ещё не посмотрели - объявление констант, глобальных и статических переменных, работу со строками (которые записываются в массив "паскальным" способом, со счетчиком длины в начале), разнообразные функции для работы с потоками (файлами) - переключающие input и output по сути. Но мне кажется что для первого знакомства пока хватит :)

Язык оказался довольно удачным в том смысле что позволял писать и довольно низкоуровневые вещи, и обеспечивал хорошую переносимость высокоуровневых программ. В частности как я рассказывал ранее, на нём написан первый MUD - исходники можно найти на гитхабе (а поиграть - на british-legends.com)

Мы видим как много идей перешло в Си (и далее) с минимальными изменениями. В то же время впечатляет как много "возможностей для улучшения" оставил автор будущим разработчикам языков B и C.

Идея "одного типа" во времена 8 и 16-битных домашних компьютеров была неудобной - а сейчас например в программировании для ARM как будто опять звучит актуально.

Интересной и важной особенностью языка являлось то что он компилируется в три этапа (часто это три отдельных программы - в том числе в OBCPL):

• сначала текст разбивается на токены из которых формируется структурное дерево лексем, представляющих программу

• структурное дерево преобразуется в переносимый O-code - этакий мета-ассемблер из сравнительно небольшого числа операций

• а уже только O-код на самом деле компилируется в нативный код

Этот подход был впоследствии массово использован и в других языках - получалось что для портирования языка на другую платформу достаточно переписать только третью часть (компиляцию O-кода).

Это кстати подробно описано автором в отдельной главе его книги (BCPL, the language and its compiler) - которая поэтому может быть актуальна для любителей изобретать новые языки даже сейчас.