А вот и первые результаты использования профилировщика — нашёл узкое место в парсере PlantUML и оптимизировал его. Было (коммит fb26247):

$ /usr/bin/smc profile examples/parenthesis-check/out.log
Total transitions: 99
Total time:        20553 us
Stats:
  read_state_transition_to: 4690 us (22.8191 %)
  read_state_transition_guard: 2355 us (11.4582 %)
  read_word: 1597 us (7.7702 %)
  read_state_description: 1548 us (7.5317 %)
  read: 1404 us (6.8311 %)
  read_state_right_arrow: 1049 us (5.1039 %)
  search_state_transition: 988 us (4.8071 %)
  search_state_transition_to: 977 us (4.7536 %)
  read_state_transition_action: 779 us (3.7902 %)
  read_start_tag: 699 us (3.4010 %)
  search_state_transition_guard: 639 us (3.1090 %)
  search_state_transition_action: 223 us (1.0850 %)
  search_state_action_arrow: 201 us (.9780 %)
  read_state_action_arrow: 192 us (.9342 %)
  read_end_tag: 164 us (.7979 %)
  read_state: 163 us (.7931 %)

Стало (коммит dea3e6d):

$ /usr/bin/smc profile examples/parenthesis-check/out-3.log
Total transitions: 99
Total time:        14925 us
Stats:
  read: 3158 us (21.1591 %)
  read_state_transition_guard: 1663 us (11.1424 %)
  read_state_transition_to: 1483 us (9.9363 %)
  read_word: 1259 us (8.4355 %)
  read_state_description: 1014 us (6.7940 %)
  read_state_right_arrow: 839 us (5.6214 %)
  search_state_transition_to: 670 us (4.4891 %)
  search_state_transition: 638 us (4.2747 %)
  read_state_transition_action: 536 us (3.5913 %)
  read_start_tag: 535 us (3.5846 %)
  search_state_transition_guard: 428 us (2.8677 %)
  read_state: 178 us (1.1926 %)
  search_state_transition_action: 139 us (.9313 %)
  read_state_action_arrow: 139 us (.9313 %)
  search_state_action_arrow: 132 us (.8844 %)
  read_end_tag: 125 us (.8375 %)

Итого ускорение работы парсера на ~25% по моим прикидкам за счёт кэша резольвера процедур на базе хэш-таблицы.

#dev #guile #lisp #smc

В коммитах на master в Guile-SMC добавил standalone-режим для компилятора машин состояний, теперь все необходимые модули копируются в отдельный каталог.

$ tree
.
├── context.scm
├── fsm.puml
├── main.scm
└── README.org

0 directories, 5 files

Далее выполняем компиляцию в standalone-режиме:

$ cat fsm.puml | /usr/bin/smc compile -L . -U "((context))" -m "(custom-fsm)" \
    -t guile-standalone --debug > custom-fsm.scm

Содержимое каталога теперь выглядит так:

$ tree
.
├── context.scm
├── custom-fsm
│   ├── context.scm
│   └── smc
│       ├── context
│       │   ├── char-context.scm
│       │   └── context.scm
│       ├── core
│       │   ├── common.scm
│       │   ├── log.scm
│       │   ├── stack.scm
│       │   ├── state.scm
│       │   └── transition.scm
│       └── fsm.scm
├── custom-fsm.scm
├── fsm.puml
├── main.scm
└── README.org

4 directories, 14 files

Обратите внимание, что появился каталог с именем модуля, в котором указано расположить целевой ДКА — "custom-fsm". В этот каталог были скопированы модули Guile-SMC, необходимые для работы целевого ДКА, плюс зависимости из списка дополнительных модулей (-U "((context))").

При копировании в модулях происходит замена зависимостей так, чтобы они все указывали на скопированные модули. Например, было:

$ head -4 context.scm
(define-module (context)
  #:use-module (oop goops)
  #:use-module (ice-9 textual-ports)
  #:use-module (smc context char-context)

Стало:

$ head -4 custom-fsm/context.scm
(define-module (custom-fsm context)
  #:use-module (oop goops)
  #:use-module (ice-9 textual-ports)
  #:use-module (custom-fsm smc context char-context)

Такой автомат можно запускать без наличия Guile-SMC в системе.

#guile #smc #dev #lisp #fsm

Пример профилирования ДКА в Guile-INI 0.3.0 через Guile-SMC профилировщик.

Тестовая программа:

$ cat test.scm 
#!/usr/bin/guile-3.0 \
-L modules -e main -s
!#

(use-modules (ice-9 pretty-print)
             (oop goops)
             (logging logger)
             (smc core log)
             (ini))

(define (main args)
  (log-clear-handlers!)
  (log-add-handler! (make <port-log/us>
                      #:port (open-output-file "ini.log")))
  (let ((data (ini->scm (current-input-port) #:debug-mode? #t)))
    (pretty-print data)
    (scm->ini data)))

Запуск парсера с выводом лога в файл:

$ cat /etc/php/7.4/apache2/php.ini | ./test.scm

Лог:

$ wc ini.log 
  3528  21168 280750 ini.log
$ head ini.log 
2022-01-07 17:06:27.338353 (DEBUG): [*] -> [read]
2022-01-07 17:06:27.339380 (DEBUG): [read] -> [read_section_title]
2022-01-07 17:06:27.339982 (DEBUG): [read_section_title] -> [read_section_content]
2022-01-07 17:06:27.340274 (DEBUG): [read_section_content] -> [read_comment]
2022-01-07 17:06:27.340710 (DEBUG): [read_comment] -> [read_section_content]
2022-01-07 17:06:27.340888 (DEBUG): [read_section_content] -> [read_comment]
2022-01-07 17:06:27.341363 (DEBUG): [read_comment] -> [read_section_content]
2022-01-07 17:06:27.341504 (DEBUG): [read_section_content] -> [read_comment]
2022-01-07 17:06:27.341728 (DEBUG): [read_comment] -> [read_section_content]
2022-01-07 17:06:27.341860 (DEBUG): [read_section_content] -> [read_comment]

Собственно профилирование:

$ smc profile ini.log
Total transitions: 3528
Total time:        630510 us
Stats:
  read_comment: 416994 us (66.1360 %)
  read_section_content: 153088 us (24.2800 %)
  read_section_property_value: 17230 us (2.7327 %)
  read_section_property_key: 16376 us (2.5973 %)
  trim_section_property_key: 14990 us (2.3774 %)
  trim_section_property_value: 6673 us (1.0583 %)
  read_section_title: 4132 us (.6553 %)
  read: 1027 us (.1629 %)

#guile #smc #dev #lisp #fsm #profiling

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

#guile #smc #dev

Работаю над новой функциональностью для моего компилятора машин состояний — Guile-SMC.

Итоги работы: получилось сделать преобразование ДКА в код на Scheme, который никаким образом не зависит от самого Guile-SMC. На выходе получается самодостаточный код (который можно записать в одном файле), который похож на тот, который я мог бы написать руками.

Для того, чтобы получить подобный самодостаточный код, я копирую ядро Guile-SMC в выходной код, при этом сам ДКА преобразуется в подобное представление (реальный пример):

(define (run-fsm context)
  ""
  (define (DEFAULT context)
    "Count parenthesis."
    (let ((event (event-source context)))
      (cond ((guard:eof-object? context event)
             (let ((context (action:validate context event)))
               (log-debug "[~a] -> [*]" 'DEFAULT)
               context))
            ((guard:semicolon? context event)
             (let ((context (action:no-op context event)))
               (log-debug "[~a] -> [~a]" 'DEFAULT 'COMMENT)
               (COMMENT context)))
            ((guard:double-quote? context event)
             (let ((context (action:no-op context event)))
               (log-debug "[~a] -> [~a]" 'DEFAULT 'STRING)
               (STRING context)))
            ((#{guard:#t}# context event)
             (let ((context (action:count context event)))
               (DEFAULT context))))))
  (define (STRING context)
    "Skip a string."
    (let ((event (event-source context)))
      (cond ((guard:double-quote? context event)
             (let ((context (action:no-op context event)))
               (log-debug "[~a] -> [~a]" 'STRING 'DEFAULT)
               (DEFAULT context)))
            ((#{guard:#t}# context event)
             (let ((context (action:no-op context event)))
               (STRING context))))))
  (define (COMMENT context)
    "Skip a comment."
    (let ((event (event-source context)))
      (cond ((guard:newline? context event)
             (let ((context (action:no-op context event)))
               (log-debug "[~a] -> [~a]" 'COMMENT 'DEFAULT)
               (DEFAULT context)))
            ((#{guard:#t}# context event)
             (let ((context (action:no-op context event)))
               (COMMENT context))))))
  (DEFAULT context))

Из интересного: получилось также сделать некую "оптимизацию" выходного кода путём удаления неиспользуемых процедур.

Теперь у Guile-SMC три режима (цели) компиляции:
- guile — обычный режим компиляции, который выбирается по-умолчанию. В этом случае выходной код зависит от наличия Guile-SMC в системе и без него выполняться не будет.
- guile-standalone-copy — моя первая попытка сделать самодостаточный код. В этом случае все необходимые модули Guile-SMC копируются в отдельный каталог рядом с выходным ДКА, и зависимости ДКА переписываются так, чтобы они указывали на скопированные модули.
- guile-standalone — вторая (текущая) попытка сделать самодостаточный код, и похоже самая успешная (хотя я решил оставить guile-standalone-copy как вариант, т.к. в некотроых случаях он может быть удобнее.)

Пример запуска с указанием цели компиляции:

$ cat fsm.puml | smc compile -L .  -U "((context))" -t guile-standalone -m "(custom-fsm)"  > custom-fsm.scm

#projects #guile #smc #compiler

Добавил ещё один пример кода для работы с компилятором Guile-SMC:
https://github.com/artyom-poptsov/guile-smc/tree/master/examples/compiler

На выходе, в файле fsm.scm, после выполнения следующей команды:

$ guile -L . main.scm > fsm.scm

будет самодостаточный Guile-код, который можно запустить без наличия Guile-SMC в системе:

$ echo "hello world" | guile -L . run.scm

#guile #smc #fsm #projects

Выпустил релиз Guile-SMC 0.4.0:
https://lists.gnu.org/archive/html/guile-user/2022-03/msg00041.html

В новом релизе:
- Добавлен профайлер для ДКА, который позволяет выявлять "узкие" места в автомате за счёт анализа времени, сколько автомат проводит в каждом состоянии.
- Добавлено два режима (цели) компиляиции: guile-standalone и guile-standalone-copy. Эти режимы позволяют создавать ДКА на основе описания в PlantUML, которые пригодны для использования без наличия Guile-SMC в системе.
- Парсер для PlantUML оптимизирован и стал примерно на 25% быстрее (как раз "узкое" место выявлено с помощью smc profile)
- Добавлена man-страница для smc (см. man smc)
- Дополнена и расширена документация в Info.

#guile #smc #fsm #projects #dev

Работаю над портированием Guile-ICS на мой компилятор детерминированных конечных автоматов (ДКА) Guile-SMC:
https://github.com/artyom-poptsov/guile-ics

Интересная задача, которая позволяет выявить недостатки Guile-SMC и понять сам процесс проектирования и реализации ДКА — чтобы впоследствии адаптировать Guile-SMC.

Поскольку проект Guile-SMC является для меня исследовательским, сразу не всегда понятно, как должны быть реализованы те или иные вещи. Чтобы это понять, надо использовать инструмент и смотреть, подходит ли он под решаемую задачу.

Проекты наподобие Guile-SMC мне интересны во-первых тем, что они являются "инструментами для создания инструментов", и во-вторых, что они потенциально позволят думать о решаемых задачах по-новому (следовательно, лучше контролировать сложность задач.)

В Guile-ICS будет использоваться два ДКА, один будет вложен в другой.

Первый (базовый) ДКА необходим для разбора строк формата iCalendar (RFC5545). Второй (высокоуровневый) ДКА необходим для разобора потока объектов iCalendar.

В целом, первая часть задачи портирования (разработка и реализация ДКА) уже реализована, тесты в процессе написания. Вторая часть портирования заключается в переносе старого кода Guile-ICS на использование Guile-SMC.

#guile #smc #fsm #projects #dev

Почти завершил работу по портированию Guile-ICS на Guile-SMC. Код получается более понятный и легко адаптируемый. Часть вопросов решается правкой ДКА в формате PlantUML, иногда даже без правки Scheme-кода.

По ходу дела похоже исправил недоработку в старой версии Guile-ICS — теперь парсер способен читать все поддерживаемые типы компонентов календаря, согласно RFC5545.

Одна из проблем, которые остались — сборка в отдельном каталоге при make distcheck не может найти некоторые файлы.

Ещё думаю, что надо в ближайшее время зарелизить новую версию Guile-SMC, чтобы было, от чего отталкиваться при работе над связанными проектами.

#guile #smc #dev #projects

Выпустил релиз Guile-SMC 0.5.0 — компилятора детерминированных конечных автоматов (ДКА) для GNU Guile:
https://github.com/artyom-poptsov/guile-smc/releases/tag/v0.5.0

Официальный анонс в списке рассылки Guile:
https://lists.gnu.org/archive/html/guile-user/2022-08/msg00071.html

Основные возможности:
- Таблица переходов между состояниями может быть автоматически проверена на наличие тупиковых и недостижимых состояний.
- ДКА Guile-SMC при работе собирают статистику — можно узнать, сколько шагов и переходов делала машина состояний при работе.
- Guile-SMC включает в себя профилировщик, который позволяет по логам работы ДКА узнать, сколько система провела в каждом состоянии времени и какой процент от общего времени работы это составляет. Это позволяет находить "узкие места" и оптимизировать ДКА на основе цифр, полученных в реальной работе.
- Поддержка разных "целей" для компиляции — есть три цели: обычная "guile", которая даёт на выходе код ДКА, который для работы будет требовать наличие Guile-SMC в целевой системе; "автономный" режим ("guile-standalone"), который позволяет получить на выходе код ДКА, который не зависит от наличия Guile-SMC в целевой системе (и также по виду близок к тому, который мог бы быть написан в ручном режиме, где переход между состояниями по сути представлен рекурсивным вызовом процедур, каждая из которых представляет одно из состояний ДКА); и наконец "автономный" режим с сохранением Guile-SMC основы ("guile-standalone-copy"), который копирует в вместе с ДКА часть Guile-SMC, которая необходима для его работы.
- Возможность запустить ДКА напрямую из PlantUML-файла (см. команду smc run)

Цель проекта — автоматизировать и упростить разработку ДКА для различных задач (в первую очередь различных парсеров, как раз одна из областей моих интересов), избежать дублирования работы.

Основные изменения в версии 0.5.0:
- Для цели компиляции guile-standalone добавлены недостающие зависимости в целевой код.
- Для цели компиляции guile-standalone также изменён API: теперь в целевом коде процедура для запуска называется fsm-run!, которая функционирует также, как и при цели компиляции guile — что позволяет обеспечить одинаковый интерфейс запуска ДКА, который не зависит от цели компиляции.
- При компиляции для цели guile-standalone выходной код теперь имеет более аккуратный вид.
- Команда smc context теперь позволяет генерировать промежуточный контекст, который можно использовать для обеспечения минимальной зависимости от внутренней структуры модулей Guile-SMC (это необходимо для совместимости различных целей компиляции, что опять же позволяет использовать разные цели без переписывания пользовательского кода.) В будущем рекомендуется использовать именно этот промежуточный контекст, а не прямой доступ к модулям Guile-SMC.
- smc context теперь может читать описание ДКА в PlantUML из файла.
- Модуль (smc core stack) удалён.
- Исправлены справочные сообщения от команд.
- В команду smc run добавлены дополнительные проверки корректности параметров запуска.
- Документация в Texinfo обновлена.

#guile #smc #fsm #dev #projects

Переписываю систему логирования в Guile-SMC. В списке рассылки guix-patches указали на проблемы с текущей версией логирования, так что скоро будет Guile-SMC 0.5.1 с исправлениями и обратной совместимостью с 0.5.0.

В новой версии консольный интерфейс будет позволять указывать драйвер логирования и опции для него (идею подсмотрел в Docker, а более конкретно в dockerd.) При сборке хочу использовать драйвер логирования file, вместо syslog, который до этого по-умолчанию ставился.

Плюс добавится драйвер null, который будет заглушать все логи. Кстати, логирование в stderr будет также решаться отдельным драйвером, который однако будет ставиться в дополнении к другим драйверам логирования в режиме отладки.

#guile #smc #dev

Выпустил релиз Guile State Machine Compiler (Guile-SMC) 0.5.1:
https://github.com/artyom-poptsov/guile-smc/releases/tag/v0.5.1

Список основных изменений:
- Исправил нежелательное сокрытие внутренней процедуры Guile log процедурой из модуля (smc core log).
- Добавил возможность выставлять драйвер логирования для Guile-SMC — это в частности позволило решить проблемы со сборкой Guile-SMC в изолированных окружениях (и/или с ограниченным доступом к ФС и сервисам). Теперь можно при использовании консольной утилиты smc указывать один из драйверов: syslog (по-умолчанию), file или null (отключение логирования.)
- Добавил более гибкую возможность дублирования логов в stderr — теперь это работает с любым драйвером логирования, не только с syslog.
- При компиляции примера парсера для формата PNG теперь используется драйвер логирования null.
- В тестах теперь логирование использует драйвер file и логи сохраняются рядом с тестами в каталоге tests.
- Описание пакета для GNU Guix обновлено.
- Обновлена документация в формате Texinfo.

Программы, работающие с Guile-SMC 0.5.0 должны без изменений продолжать работать с 0.5.1.

Скоро отправлю патч в GNU Guix с обновлённым пакетом.

#guile #smc #fsm #dev #projects

В релизе Guile-SMC 0.5.1 обнаружилось несколько ошибок, пришлось в срочном порядке делать 0.5.2:
https://lists.gnu.org/archive/html/guile-user/2022-09/msg00002.html

Исправленные ошибки:
- Команды smc context и smc compile теперь добавляют к выходному коду модуль (smc core config).

#guile #smc #fsm #dev #projects

Очередной подход к продумыванию архитектуры Guile-SMC.

Хочется выделить универсальные строительные блоки для ДКА, при этом сохранив архитектуру гибкой. Думаю, есть смысл вынести предикаты (сторожи переходов, a.k.a.guards) в отдельные модули, т.к. они универсальны. При этом, сами контексты, над которыми оперируют ДКА, будут тоже в отдельных модулях. В итоге, должен получиться конструктор "собери себе ДКА".

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

Хочу также добавить функциональный контекст на базе модуля (srfi srfi-9 gnu), в дополнении к ООП-варианту, который был до этого.

#guile #smc #fsm #projects #dev

Выпустил релиз Guile-SMC 0.6.0 — компилятора конечных автоматов для GNU Guile:
https://github.com/artyom-poptsov/guile-smc/releases/tag/v0.6.0

Основные новшества:
- Новая реализация контекста. Теперь контекст предоставляет предикаты отдельно от структур данных для обеспечения ДКА памятью. То есть, теперь есть модули (smc context char) и (smc context u8), предоставляющие предикаты для ДКА, работающих с символами и байтами соответственно. При этом, предоставляются также функциональные и ООП-структуры данных для обеспечения ДКА памятью — например, (smc context functional u8) и (smc context oop u8).
- Убрана поддержка цели компиляции guile-standalone-copy, так как смысла в ней мало, а для её поддержки требуются мои (ограниченные) ресурсы. Остались цели guile (генерация кода, зависящего от Guile-SMC) и guile-standalone (генерация кода, не зависящего от Guile-SMC.)
- Класс <fsm> теперь позволяет добавлять специальные процедуры pre-action и post-action, которые выполняются в начале обработки события и в конце, соответственно.
- smc compile и smc context теперь позволяет указывать путь к установленным модулям Guile-SMC через опцию --guile-smc-path.
- smc profile теперь позволяет выдавать статистику в JSON-формате.
- При указании опции --debug, консольные команды больше не включают дублирование логов в stderr — вместо этого теперь предлагается использовать специальную опцию stderr=true в --log-opt.

#dev #projects #guile #smc #fsm

Выпустил релиз Guile-SMC 0.6.1, компилятора конечных автоматов для GNU Guile:
https://github.com/artyom-poptsov/guile-smc/releases/tag/v0.6.1

В новой версии:

- Добавлена возможность установки глобального источника событий для ДКА в разделе legend внутри PlantUML-файла. Например:

legend
event-source: next-char
endlegend

- Команда smc context теперь позволяет установить подтип генерируемого контекста. Если раньше можно было выбрать только из двух вариантов — oop и functional, то сейчас можно использовать такие варианты, как:

oop
oop/generic
oop/port
oop/char
oop/u8
functional
functional/generic
functional/char
functional/u8

Подобная мера позволила сократить объём генерируемого кода для контекста (не берутся те части контекста из Guile-SMC, которые не используются), и кроме того, это позволило решить проблему с дублированием процедур при использовании функционального (functional) контекста, где каждый вариант предоставлял свою копию процедур, но все основные процедуры имели одинаковые имена.

- Исправлена ошибка в процедуре fsm-run!, из-за которой при завершении работы ДКА возвращалась не последнаяя версия контекста, а предыдущая — это приводило к ошибкам работы функциональных вариантов контекста, где контекст не изменялся, а создавался новый на основе предыдущего. В этой ситуации если в конце работы ДКА происходило какое-то заключительное действие с контекстом (например, обновление через действие по выходу из состояния), то данные изменения не были видны. В случае использования ООП-контекста такой проблемы не возникало, так как ООП-контекст использует мутабельные структуры.

- Исправлены ошибки в сериализации/десериализации состояний в модуле (smc core state) — теперь exit-action корректно сохраняется при преобразовании состояния в список, а при обратном преобразовании списка в состояние восстанавливается.

- Обновлена документация.

#dev #projects #guile #smc #fsm

Исправил ошибки в профилировщике детерминированных конечных автоматов из поставки Guile-SMC, исправления пойдут в следующий релиз.

Использование профилировщика на примере Guile-DSV:

$ dsv --log-driver file --log-opt=file=smc.log -F rfc4180 --to unix datasets/covid.csv > test.csv
$ smc profile smc.log
Total transitions: 1661324
Total time:        84173181 us
Stats:
  read_quote: 30647003 us (36.4095 %)
  read_quoted_field: 27615130 us (32.8075 %)
  read_field_first_char: 23677038 us (28.1290 %)
  add_row: 2233946 us (2.6540 %)
  add_final_row: 35 us (.0000 %)
  read_first_field_first_char: 29 us (.0000 %)

Кусок файла smc.log:

$ head smc.log
2023-08-10 21:19:05.522313 (DEBUG): [*] -> [read_first_field_first_char]
2023-08-10 21:19:05.522342 (DEBUG): [read_first_field_first_char] -> [read_quoted_field]
2023-08-10 21:19:05.522377 (DEBUG): [read_quoted_field] -> [read_quote]
2023-08-10 21:19:05.522427 (DEBUG): [read_quote] -> [read_field_first_char]
2023-08-10 21:19:05.522448 (DEBUG): [read_field_first_char] -> [read_quoted_field]
2023-08-10 21:19:05.522483 (DEBUG): [read_quoted_field] -> [read_quote]
2023-08-10 21:19:05.522508 (DEBUG): [read_quote] -> [read_field_first_char]
2023-08-10 21:19:05.522527 (DEBUG): [read_field_first_char] -> [read_quoted_field]
2023-08-10 21:19:05.522556 (DEBUG): [read_quoted_field] -> [read_quote]
2023-08-10 21:19:05.522585 (DEBUG): [read_quote] -> [read_field_first_char]

#dev #projects #guile #dsv #smc

Выпустил релиз Guile-SMC 0.6.2:
https://github.com/artyom-poptsov/guile-smc/releases/tag/v0.6.2

Ключевые изменения:

- Исправлена ошибка с процедурой pre-action в модуле (smc context functional char): Теперь процедура во всех случаях возвращает контекст.

- Исправлена ошибка высчитывания отметок времени в модуле (smc trace-context). Теперь значение отметок времени всегда получается положительным, как и должно. При этом, если всё же обнаруживается уход времени в отрицательные значения, бросается ошибка.

- Исправлен рассчёт времени в модуле (smc cli command-profile) профайлера. Теперь профайлер Guile-SMC даёт правильные значения суммарного времени работы ДКА и времени для каждого отдельно взятого состояния.

- В модуль (smc context oop generic) добавлен недостающий модуль (smc core log). Его отсутствие приводило бы к ошибками при попытке использования (smc context oop generic).

- Теперь Guile-SMC позволяет задавать pre-action и post-action для ДКА прямо в PlantUML описании. Эти процедуры выполняются перед всеми остальными проверками для каждого состояния, и могут например использоваться для обновления счётчиков в контексте. Пример задания этих процедур в PlantUML файле описания ДКА:

legend
pre-action:  custom-pre-action
post-action: custom-post-action
endlegend

- Для класса <fsm> в модуле (smc fsm) теперь добавлены процедуры для задания pre-action (fsm-pre-action-set!) и post-action (fsm-post-action-set!). Также из модуля экспортированы процедуры fsm-pre-action и fsm-post-action для получения текущих значений pre-action и post-action соответственно.

- В модуле (smc core log) теперь регистрируется логгер по-умолчанию, под именем "guile-smc". Также добавлена процедура smc-log-default-logger.

- Обновлена документация.

Новый релиз обратно совместим с версиями 0.6.0 и 0.6.1.

#dev #projects #guile #smc

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

$ echo -e "a,b,c\nd,e\n" | ./pre-inst-env ./utils/dsv
Backtrace:
In ice-9/boot-9.scm:
  1752:10  7 (with-exception-handler _ _ #:unwind? _ # _)
In unknown file:
           6 (apply-smob/0 #<thunk 7f1b3a516300>)
In ice-9/boot-9.scm:
    724:2  5 (call-with-prompt _ _ #<procedure default-prompt-handle…>)
In ice-9/eval.scm:
    619:8  4 (_ #(#(#<directory (guile-user) 7f1b3a519c80>)))
In utils/dsv:
    272:8  3 (main _)
In dsv/table.scm:
   460:21  2 (format-table (("a" "b" "c") ("d" "e")) () #:width _ # _ …)
   347:27  1 (table-wrap (("a" "b" "c") ("d" "e")) _ #:width _ # _ # _)
   241:23  0 (table-wrap-row _ _)

dsv/table.scm:241:23: In procedure table-wrap-row:
In procedure car: Wrong type argument in position 1 (expecting pair): ()

Сейчас я исправил эту недоработку и добавил для процедуры dsv->scm опцию #:validate?, которая по-умолчанию выставлена в #f (false). Если же выставить её в #t (true), то тогда ошибка будет более понятной. Вот пример на тех же тестовых данных:

$ echo -e "a,b,c\nd,e\n" | ./pre-inst-env ./utils/dsv
Backtrace:
In ice-9/boot-9.scm:
  1752:10  9 (with-exception-handler _ _ #:unwind? _ # _)
In unknown file:
           8 (apply-smob/0 #<thunk 7f1f270af300>)
In ice-9/boot-9.scm:
    724:2  7 (call-with-prompt _ _ #<procedure default-prompt-handle…>)
In ice-9/eval.scm:
    619:8  6 (_ #(#(#<directory (guile-user) 7f1f270b2c80>)))
In utils/dsv:
    272:8  5 (main _)
In dsv/cli/common.scm:
   144:38  4 (print-file #<input: file 0> unix "" _ #:numbering? _ # …)
In dsv/unix.scm:
    81:19  3 (dsv->scm _ #:debug-mode? _ #:delimiter _ #:validate? _ …)
In smc/fsm.scm:
   469:37  2 (_ #<fsm current-state: add_row statistics: 11/5 7f1f1…> …)
   426:22  1 (_ #<fsm current-state: add_row statistics: 11/5 7f1f1…> …)
In dsv/fsm/dsv-context.scm:
    100:2  0 (throw-row-length-error _ _ _ _)

dsv/fsm/dsv-context.scm:100:2: In procedure throw-row-length-error:
Inconsistent row length on line 10: expected 3, got 2 #<input: file 0> 10 0 ("d" "e") #<char-context 7f1f1d41a8c0>

По ходу дела выяснилось также, что парсер RFC 4180 похоже неправильно парсит некоторые сложные поля, где внутри поля содержится знак-разделитель. Это ещё требует дополнительного исследования.

И ещё выяснилось, что в Guile-SMC оказывается неправильно считаются строки в контексте functional/char.

#guile #dsv #smc #projects