Добро пожаловать!

Я Дож, программирование — моё хобби. По мере того, как я осваиваю что-то новое, стараюсь об этом написать пост.
На текущий момент в блоге затронуты следующие темы: vim, free pascal, lisp, forth, m4
Занимаюсь разработкой своего языка под названием DEmbro, подбробней: wiki и svn
Для постов, не связанных с программированием, у меня есть отдельное жж.

июля 18, 2011

Бажные каты

Предыдущий пост на главной странице выглядит некорректно — каты сработали неправильно, рррррр. Тег table включает отображение текста, даже если сам тег вложен внутрь скрытого span'а. Странное поведение. Пришлось отключить кат.

Когда же наконец появится что-нибудь официальное для катов вместо этой глючной поделки?

[updated] Нашёл официальные каты.


Читать дальше......

Пара слов о том, как делался Maze Journey

Недавно участвовал в конкурсе IGDC, писал игру на DEmbro. Это был достаточно интересный опыт использования на практике своего языка.

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

Средства разработки

DEmbro и текстовый редактор Vim. Выглядит это как-то так:


Из средств отладки — печать значений на консоль, комментирование подозриетльных фрагментов кода, и возможность без запуска всей игры загрузить какой-то отдельный модуль в REPL режиме и быстро посмотреть как себя ведут команды.

Коротко о языке

Я использовал (за исключением нескольких незначительных мест) только три типа: целое число, указатель и строка. Хотя типов как таковых в DEmbro нет. Все операции производятся на стеке, для чисел и указателей один стек, для строк — отдельный. Круглые скобки используются для многострочных комментариев, а для однострочных — общепринятое «//».

Несколько примеров:


1 // положить на стек число 1
2 // положить на стек число 2
3 4 5 // положить на стек числа 3, 4 и 5. Теперь стек выглядит так: 1 2 3 4 5
+ // сложить два верхних числа. Теперь стек выглядит так: 1 2 3 9
* // умножить два верхних числа. Теперь стек выглядит так: 1 2 27
swap // поменять два верхних числа местами, 1 27 2
div // нацело поделить два верхних числа, 1 13
max // из двух верхних элементов оставить максимальный, 13
1+ // увеличить верхнее число на 1, получится 14
drop // скинуть верхний элемент со стека, теперь стек вернулся в начальное состояние


Можно писать свои команды при помощи конструкции

: name ..... ;


где name — имя команды.

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

Например, в программе всё измеряется в миллесекундах. Но иногда приходится задавать время в минутах. Чтобы задать пять минут, нужно 5 умножить на 60*1000, и получится соответствующее число миллисекунд. Чтобы делать это вычисление автоматически, можно написать команду

: mins 60000 * ;


Теперь можно просто записать

5 mins


и получить время в миллесекундах для пяти минут.

Команды можно выполнять косвенно. При помощи символа апостроф, за которым идёт название команды, можно положить указатель на эту команду. А при помощи команды execute выполнить указатель с вершины стека. Т.е.

5 ' mins execute


эквивалентно коду «5 mins».

Можно создавать анонимные команды при помощи команды «:noname»:

:noname ." Hello world" cr ;


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

:noname ." Hello world" cr ; execute



Пара примеров на работу с указателями и переменными:

variable x // создаёт область памяти под целое число или указатель
// теперь вызов команды x кладёт на стек указатель на эту область памяти
5 x ! // записать число 5 в переменную x
x @ // положить в стек значение переменной x
. // распечатать на консоль полученное число
x off // записать в переменную x ноль


Ещё есть условный оператор и циклы.

: printbool if ." TRUE" else ." FALSE" then cr ; // создаём команду printbool
// она снимает со стека верхний элемент, и если он ноль, то печатает FALSE
// иначе TRUE
false printbool // напечатает FALSE
true printbool // напечатает TRUE
100 10 > printbool // напечатает TRUE
100 10 < printbool // напечатает FALSE
100 0<> printbool // напечатает TRUE

// печатает числа от 0 до 10
:noname 0 begin dup 10 <= while dup . 1+ repeat drop ; execute


Условные операторы и циклы являются компилирующими командами, и потому их можно использовать только внутри описания команд.

Сказанного должно быть достаточно для понимания того, что будет ниже. Чтобы не затягивать вступление до бесконечности, дам напоследок несколько ссылок
  1. Пишущееся вики
  2. Файл с реализацией условного оператора и простых циклов
  3. Файл с реализацией оператора switch
  4. Файл с реализацией работы с пространствами имён
Практически никакого контроля нет ни на стадии компиляции, ни на стадии интерпретации. Что лежит на стеке или в памяти узнать нельзя. Можно написать на свой страх и риск почти любую фигню с непредсказуемым исходом.

Кратко об игре
Лучше один раз увидеть, чем сто раз услышать, так что отсылаю читателя самому сыграть в игру (в конкурсном архиве запускать надо Doj\mazejourney\release\run.bat). Я написал на DEmbro создание окна и инициализацию OpenGL достаточно давно. Т.к. числа с плавающей точкой в DEmbro немного сыроваты (в частности, нет нормального способа передать double в виде параметра в dll функцию), я решил для упрощения жизни их не использовать вообще. Кроме того, я не писал ни поддержки текстур, ни каких-то хитрых примитивов. Единственное, что я использовал при рендере — цветные квадраты. Игру я писал с девизом «каждый уровень имеет свой уникальный геймплей». Поэтому нужно было иметь удобные конструкции для описания уровней.

Как описывается уровень
Чтобы не томить любителей ковыряться самостоятельно, рекомендую посмотреть файл «game\levels\big.de» — он является очень простым примером того, как описывается уровень. Кстати, по-поводу этого уровня, в нём можно усмотреть букву O — это чит, позволяющий пройти в определённом месте сквозь стену и оказаться у выхода. Итак, первым делом я написал команду lab, которая позволяет в наглядном текстовом виде описывать уровни. Например, так:

lab
##########
#S       #
#        #
#        #
#        #
#        #
#       F#
##########
\lab

(Из-за бага в ядре дембро, после слова «lab» нужно ставить пробел.) Команда lab использует функцию ядра «source-next-line», которая читает следующую строку исходника. По первой строке определяется ширина уровня, а дальше создаёт двумерный массив, содержащий ascii коды символов. После выполнения этой конструкции можно при помощи команды last-lab-x получить ширину лабиринта, при помощи last-lab-y высоту лабиринта, а при помощи last-lab-maze указатель на двумерный массив. Далее я написал команду «level», которая создаёт уровень. Напрямую она практически не используется, но в файле «game\levels\list.de» определяется надстройка над ней — newlevel, которая внутри себя вызывает level, выполняет файл, имя которого следует после «newlevel», и связывает уровни в последовательность. В том же файле list.de можно обнаружить сам список уровней. Как только мы создали уровень (командой level) можно приступать к его наполнению. Команда «maze!» установит на текущем уровне последний лабиринт, созданный командой «lab». При помощи команд «cell-x!» и «cell-y!» можно установить размер в пикселях одной ячейки лабирнта текущего уровня, например так: 16 cell-x! 16 cell-y! При помощи команд «offset-x!» и «offset-y!» задаётся положение лабиринта на экране. Т.к. всегда мне нужно было центрировать лабирит, я написал команду «centrize», которая автоматически вызывает «offset-x!» и «offset-y!», вычисляя смещение при помощи размера лабиринта и размера ячейки. При помощи команд «player-x!» и «player-y!» можно установить координаты ячейки, в которой будет появляться игрок в начале уровня. Перейдём к более нетривиальным элементам уровня — событиям. Можно описать команды, которые будут выполняться при старте уровня — при помощи этого механизма запускается звук гонга перед началом уровня:

:noname pchar" data\sounds\newlevel.wav" sound ;init

Тут просто вызывается команда sound, которая принимает один параметр — указатель на pchar-строку, содержащую имя звукового файла. Менее тривиальный примеры — события, когда игрок входит на какую-то ячейку. Можно установить на каждый тип (т.е. ascii-символ) ячейки свой обработчик. Обработчику на стеке передаются x,y координаты ячейки, на которую пытается войти игрок. Если их скинуть со стека, то игрок не сможет зайти в ячейку, т.е. можно описать обработчик для стены:

:noname drop drop ;enter_ #

Есть команда passed, которая, наоборот, считывает x,y и смещает в них игрока. Можно написать

:noname passed ;enter_ O

Тогда игрок сможет заходить в букву O. Чтобы буква O выглядела как обычная стена, для неё нужно определить такой же обработчик рисования (который тоже принимает координаты x,y), как и для стены:

: draw_# COLOR 2dup PURPLES GEN[]2 ^ set-color draw-cell-rect ;
:noname  draw_# ;draw_ #
:noname  draw_# ;draw_ O

Есть ещё один тип обработчиков для каждой ячейки — обработчик инициализации. Обработчики инициализации нужно установить перед вызовом команды «lab». Тогда при считывании каждой ячейки внутри конструкции «lab .... \lab» будет вызван соответствующий заданному ascii-символу обработчик инициализации. Пример использования: всегда неудобно задавать положение игрока координатами при помощи «player-x!» и «player-y!». Гораздо удобнее пометить нужную ячейку буквой S. Для этого перед выполнением «lab» достаточно добавить обработчик инициализации ячейки S:

:noname  player-y! player-x! ;oninit_ S

При входе на букву F по умолчанию задан переход к следующему уровню командой «next». При желании аналогичной функциональностью можно наделить другие буквы, и сделать переходы на другие уровни. Таковы общие принципы создания уровней. Теперь я разберу особенности разработки некоторых уровней. Часто, из-за копипасты в описнии уровней можно увидеть много ненужного кода, — я не успел его удалить до дедлайна.  

Уровень в темноте (dark.de)
На этом уровне игрок видит только соседние с собой клетки. Нужно просто при рисовании стены посчитать расстояние игрока до стены, и если оно больше одного, то не рисовать стену:

:
  2dup player-y @ - abs swap player-x @ - abs max 1 > if drop drop exit then
  COLOR 2dup PURPLES GEN[]2 ^ set-color draw-cell-rect
;draw_ #


Уровень-цикл (loop.de)
Тоже уровень в темноте, в котором если ходить по часовой стрелке, то будешь бегать по кругу, а если пойти против часовой стрелки, то прийдёшь к выходу. Реализация простая: описываются при помощи команды «lab» три лабиринта — тот, который изначально, тот, который с циклом, и тот, который с выходом. Изначальный нужен, чтобы закрутить игрока идти по часовой стрелки, его мы устанавливаем в уровне командой «maze!». Остальные два сохраняем в переменные. Вот, например, цикличный лабиринт:

lab
     #######
     #1    #
###### ### #
#      # # #
# ###### # #
# #      # #
# #      # #
# ######## #
#     2    #
############
\lab
  last-lab-x value 1maze-x
  last-lab-y value 1maze-y
  last-lab-maze value 1maze-ptr

На карте есть ячейки 1 и 2. При наступании на 1 включается лабиринт с циклом, при наступании на 2 — лабиринт с выходом. Вот их обработчики:

:noname passed 1maze-x maze-x ! 1maze-y maze-y ! 1maze-ptr maze-ptr ! ;enter_ 1
:noname passed 2maze-x maze-x ! 2maze-y maze-y ! 2maze-ptr maze-ptr ! ;enter_ 2

Проверка видимости сделана так же, как и в dark.de, только расстояние берётся не 1, а 3 ячейки.  

Уровень с убегающим выходом (runningexit.de)
Алгоритм убегания выхода простой. Если игрок приблизился на близкое расстояние по обеим координатам, то выход смещается. Выбирается координата, по которой расстояние до игрока больше, после чего выход смещается от игрока по этому направлению. Если это не удаётся (стена), пытаемся сместить выход в перпендикулярном направлении. Поэтому, например, если игрок идёт на выход по узкому коридору, то выход будет убегать по этому коридору от игрока, и свернёт в бок, как только упрётся в стену. Там используется событие after-update для всех этих расчётов и рендера выхода (рендер сделан отдельный, потому что выход при смещении с ячейки на ячейку должен смещаться плавно). Когда выход смещается, в лабиринте перезаписывается его расположение, поэтому событие попадания в выход обрабатывается корректно обычным образом.

Уровень с двигающимися стенами (movingwalls.de)
Идея аналогична уровню-циклу. Я создал два лабиринта: главный прямоугольник с выходом, и лабиринт со штуковиной. И сохранил его в переменные (moving-x, moving-y, moving-ptr). Далее, я переопределил события рендера и входа для пробела:

: draw#brown COLOR 2dup BROWNS GEN[]2 ^ set-color draw-cell-rect ;
:noname  2dup moving-x * + player-y @ + cells moving-ptr + @
         35 = if draw#brown else 2drop then ;draw_
:noname  2dup moving-x * + player-y @ + cells moving-ptr + @
         35 = if 2drop else passed then ;enter_  

(Там в конце, каждого определения должно быть по два пробела.) Число 35 — это ascii код для символа решётки (который я получил при помощи команды «ga» в виме). Тут всё просто: чтобы определить нужно ли рисовать на пустом месте что-то, берётся значение из вспомогательного лабиринта со штуковиной, с прибавлением y-координаты игрока.  

Заключение
 В целом, разрабатывать игру мне очень понравилось.

Разработка игры длилась суммарно около 10ти дней, большинство из которых я ещё и ходил на работу. При этом первая половина этого времени была потрачена на написание основного функционала, а вторая — на придумывание и реализацию уровней.


Читать дальше......

июня 15, 2011

m4: временные макросы

Часто при использовании m4 может возникнуть необходимость использования локальных определений. Например, в случае языка разметки часто нужно оформлять какие-то списки. Списки бывают разных типов — по оформлению: нумерованный, с кружочками; по применению: оглавление, список литературы. И хочется иметь возможность быстро сменять один тип на другой, т.е. было бы удобно записывать как-то так:

LIST(
  ITEM(Ананас)
  ITEM(Банан)
  ITEM(Кокос))
REFERENCES(
  ITEM(Энциклопедический словарь Брокгауза и Ефрона: В 86 томах (82 т. и 4 доп.). — СПб.: 1890—1907.)
  ITEM(Перевод главы о бананах из книги Julia F. Morton «Fruits of Warm Climates» 1987)
  ITEM(Кокосовая пальма — статья из Большой советской энциклопедии))


Здесь в обоих конструкциях используется макрос ITEM, но в разных смыслах: в первом случае он будет раскрыт в нумерованный элемент, во втором — в элемент списка литературы.

Однако, подобный синтаксис реализовать в m4 невозможно. В любых конструкциях сперва вычисляются аргументы (т.е. ITEM'ы), и только после этого вызываются макросы, в которые эти аргументы передаются, т.е. в LIST и REFERENCES. Поэтому LIST и REFERENCES не могут никак повлиять на то, как будут вычисляться ITEM'ы. Как можно было бы обойти это ограничение? Самый простой способ — отказаться от локальных объявлений, а сделать глобальные, но с разными именами:
LIST(
  ITEM(Ананас)
  ITEM(Банан)
  ITEM(Кокос))
REFERENCES(
  RITEM(Энциклопедический словарь Брокгауза и Ефрона: В 86 томах (82 т. и 4 доп.). — СПб.: 1890—1907.)
  RITEM(Перевод главы о бананах из книги Julia F. Morton «Fruits of Warm Climates» 1987)
  RITEM(Кокосовая пальма — статья из Большой советской энциклопедии))


Этот метод не очень красив, не очень удобен, и может привести к трудностям, если требуется делать вложенные списки. Вместо этого способа мне больше нравится разделение LIST и REFERENCES на открывающий и закрывающий макросы:

LIST
  ITEM(Ананас)
  ITEM(Банан)
  ITEM(Кокос)
_LIST
REFERENCES
  ITEM(Энциклопедический словарь Брокгауза и Ефрона: В 86 томах (82 т. и 4 доп.). — СПб.: 1890—1907.)
  ITEM(Перевод главы о бананах из книги Julia F. Morton «Fruits of Warm Climates» 1987)
  ITEM(Кокосовая пальма — статья из Большой советской энциклопедии)
_REFERENCES


Теперь уже можно внутри REFERENCES ввести своё собственное объявление ITEM'а, а внутри _REFERENCES восстановить старое.

Создание временных макросов в m4 имеет несколько тонкостей. Во-первых, вместо обычного define следует использовать пару pushdef и popdef. Первый макрос определяет новый макрос, сохраняя все предыдущие, popdef удаляет последнее определение, восстанавливая предыдущие.

Во-вторых связано с использованием локальных переменных: если записать
define(`LIST', `<OL>pushdef(`ITEM', `<LI>$*</LI>')')
то вместо $* будет подставлен параметр макроса LIST, а не макроса ITEM. Более того, даже если заключить параметр в сколь угодно большое кол-во символов цитирования, всё равно оно будет считаться параметром макроса LIST. Я придумал решение, быть может не очень красивое, но рабочее: нужно сгенерировать текст «$*» вычислением, самый простой способ — конкатенация:
define(`CONCAT', `$1$2')
define(`_DS', `CONCAT($,*)') 
define(`LIST', `<OL>pushdef(`ITEM', `<LI>_DS</LI>')')
define(`_LIST', `popdef(`ITEM')</OL>')

(DS — аббревиатура для Dollar Star).

Можно аналогичным образом определить макросы _D1, _D2, ..., _D9 для, соответственно, $1, $2, ..., $9.

Ещё есть красивое решение, которое заключается в написании макросов _S, _1, _2, ..., _9, которые заменяются на, соответственно, *, 1, 2, ..., 9. Тогда «локальные параметры» подмакросов можно будет записывать как $_S, $_1, $_2, ..., $_9.

Составные конструкции можно ещё усовершенствовать: вместо пар LIST/_LIST, REFERENCES/_REFERENCES можно задавать всего по одному макросу LIST и REFERENCES, внутри которых будет определяться макрос END, определённый аналогичным ITEM'у способом. Этот способ реализован в моём языке разметок, в файлах util.m4 и html.m4 (см. списки и таблицы). В файле examples.m4 можно посмотреть примеры использования всего этого, а в файле examples.html то, что из этого сгенерировано: как видно, все списки и таблицы благополучно раскрываются в то, что нужно.


Читать дальше......

июня 14, 2011

Починил каты

Напомню, что когда-то я настроил в блоге каты, а когда сменил дизайн, они сломались: даже если пост не содержит ката, то на странице со списком всё равно писалось «Читать дальше......».

Сегодня, спустя более года после поломки, я решил всё починить. Оказалось, что после смены дизайна блоггер удалил всё, что было добавлено в теге head, и после добавления каты снова работают корректно.


Читать дальше......

Менеджер памяти

Известно, что если передавать паскалевские строки в/из длл, и ни в чём себя не ограничивать, то прога может упасть. Поэтому при взаимодействии с длл большинство использует строки в стиле Си.

Наткнулся на забавную статью, предлагающую решение проблемы в случае, если и прога, и длл пишутся вместе. Автор утверждает, что если и у длл, и у программмы установить один менеджер памяти, то проблем не будет. Это стоит ещё проверить, но звучит правдоподобно.


Читать дальше......

DEmbro: классы для исходного кода

Выносил из центрального объекта обработку исходного кода. Перемудрил с архитектурой. С первого раза написать хороший код не получилось, вышла большая каша, желание переделывать которую не было. Писать другие части DEmbro не представлялось возможным без этого, поэтому почти полтора месяца (!) я был деморализован и боялся всё переписывать. Недавно, наконец, нашёл в себе силы и осуществил задуманное.

Я думал, что в коде очень много связности и потребуется долгое переписывание под новую архитектуру, но это оказалось не так, и всё очень быстро встроилось.

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

За время этого прохода необходимо всего несколько операций: прочитать следующий символ входного потока, прочитать следующее слово (последовательность символов без пробелов) и прочитать всё до определённого ограничителя (например, комментарий пропускает все символы до заданного ограничителя). Возможно, что будут и другие операции, но эти — основные. Написание классов, отвечающих за это, и вынесение в них функционала по обработке исходников, и было одной из задач рефакторинга.

Самый главный класс — TSource, отвечает за промежуточное хранение исходного кода (последовательности символов) в оперативной памяти, и делегирует выполнение операций с исходным кодом вспомогательным классам. Пока что исходный код хранится только в памяти, и поэтому TSource может хранить в буфере его целиком, но в будущем будет возможность получать исходники и из других мест: из файла, из произвольного потока, по сети и т.д. Идея этого заключается в том, что так как нам не нужно хранить весь исходный код целиком в оперативке, а нужен только небольшой фрагмент, то разумно этим воспользоваться и в качестве бонуса получить малое потребление оперативной памяти. Кроме того, пользуясь особенностями конкретных источников исходника, можно оптимизировать чтение и выиграть в скорости (например, если исходный код приходит по сети, то можно выполнять по мере поступления приходящие куски). Кроме того, TSource должен хранить название источника кода (имя файла, например).

У этого класса есть два вспомогательных — TSpaceSkipper и TNameReader. Первый, как нетрудно догадаться, нужен для того, чтобы пропускать пробелы. Пока что пробелами считаются символы в диапазоне от 0 до 32, но при необходимости можно будет унаследовать своё поведение. Кроме того, в TSpaceSkipper можно будет добавить функциональность по подсчёту числа пробелов, и этим воспользоваться в DEmbro (например, в языке программирования питон для выделение блоков вместо ограничителей begin...end или {...} используются отступы — что достаточно удобно и наглядно. При записывании уровня игры символами в виде псевдографики проще пользоваться пробелами, чем какими-то другими символами). TNameReader, в свою очередь, читает имена. В имя могут входить только символы не из диапазона от 0 до 32, но можно будет унаследовать класс, который, например, будет воспринимать слова с пробелами, если слово заключено в одинарные кавычки.

Наконец, есть дополнительный класс — TLineReader. Он выделяет строки, считает номер текущей строки, и позицию в строке. Если это нужно, конечно, — класс можно будет отключить для ускорения работы.

Вроде как получилось расширяемо и ортогонально, но немного муторно.


Читать дальше......

июня 02, 2011

m4: Универсальный язык разметок

Этот пост — небольшая обучалка по m4. Как мне кажется, приведённый ниже пример
хорошо иллюстрирует некоторые базовые принципы использования m4.

Я весьма часто пишу тексты, и для разметки приходится использовать довольно разный
синтаксис: то html, то LaTex, то google wiki, то bbCode (upd ещё vkontakte разметку бывает
приходится использовать). Даже html бывает разного вида (например, некоторые блоги
сами вставляют тег br в конце каждой строки).

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

Для обеспечения единого синтаксиса я решил воспользоваться m4, а именно:
текст будет писаться с использованием макросов, а в зависимости от того
какой выходной файл нужно будет получить, эти макросы будут по разному
раскрываться.

Рассмотрим это на примере HTML и LaTeX. Я создал два файла: html.m4 и tex.m4.
Когда требуется из файла изготовить текст на HTML, то следует вызывать
m4 html.m4 file.m4 > file.html
Если же требуется получить LaTeX, то нужно вызывать
m4 tex.m4 file.m4 > file.tex

Этот вызов сначала выполнит html.m4 или tex.m4, потом file.m4, сольёт результат вместе и
запишет в file.out. При этом в файлах html.m4 и tex.m4 находится исключительно служебная
информация, и мы не хотим, чтобы из них что-то печаталось. Поэтому в начало
каждого такого файла добавляется строка
divert(-1)
которая весь дальнейший вывод выбрасывает, а в конце файла пишем
divert
после чего вывод будет происходить нормально.

Приступим, наконец, к написанию макросов. Самое простое — перевод строки.
html.m4:
define(`BR', `<BR>')
tex.m4:
define(`BR',`\\')

Я решил, что все макросы будут писаться большими буквами, чтобы было по-меньше
конфликтов имён.

Перейдём к более сложному макросу: жирный шрифт. Использование такого макроса
будет выглядеть примерно так: BOLD(жирный шрифт). Для реализации нужно
в теле макроса написать $* — вместо него будет подставлено всё, что находится
между скобочек:
html.m4:
define(`BOLD', `<strong>$*</strong>')
tex.m4:
define(`BOLD', `\textbf{$*}')

Далее, запись списков. Я выбрал такой синтаксис:
LIST(
  ITEM(Ананас)
  ITEM(Манго)
  ITEM(Кокос)
)


Оно создаст соответствующий нумерованный список. Реализация:
html.m4:
define(`LIST',`<OL>$*</OL>')
define(`ITEM',`<LI>$*</LI>')

tex.m4:
define('LIST', `\begin{enumerate}$*\end{enumerate}')
define('ITEM', `\item $*')


Перейдём к более сложному примеру: ссылки. Ссылки уже требуют двух параметров:
куда ссылается и что отображается. Для получения отдельных параметров вместо $*
следует использовать $1, $2, и т.д. Поэтому реализацию ссылки можно бы было
записать так:
define(`LINK', `<a href="$1">$2</a>')

Но эта конструкция имеет проблему: если написать
LINK(google.com, Используй гугл перед тем, как задать вопрос, пожалуйста)
то m4 будет думать, что тут четыре параметра, и второй — «Используй гугл перед тем»,
а не вся фраза целиком. Для решения проблемы следует использовать макрос «shift»:
он возвращает все свои параметры, кроме первого.
html.m4
define(`LINK', `<a href="$1">shift($*)</a>')
tex.m4
define(`LINK', `\href{shift($*)}{$1}')

Теперь указанный выше пример сработает корректно.

Далее — дело техники, уже перечисленного достаточно для реализации многого.
В случае, если при наборе какого-то текста критично то, что макросы для разметки слишком длинные, то легко можно вставить где-то в тексте строки вида:
define(`B',`BOLD')
и использовать краткие варианты макросов, ничего при этом не потеряв.

Вот мои файлы: html.m4 и tex.m4. Пока что они не полные и скорее полигон для экспериментов, чем что-то, что я использую в боевых условиях, но со временем эти файлы будут пополняться и совершенствоваться.


Читать дальше......

Постоянные читатели

Обо мне

Моя фотография
Мой e-mail: vitek_03(at)mail(dot)ru