Есть-ли какой-нибудь формат для представления хода выполнения программы? Т.е. все вызовы функций, итерации циклов, проверки условий, присвоения переменных и т.д. Я хочу написать проход для компилятора который к исходному коду добавляет логи - т.е. для кода

for i in 0 .. 3:
  echo i

мы должны получить

for i in 0 .. 3:
  log("loop start")
  log("var set i = ", i)
  log("function call echo", i)
  echo i
  log("loop end")

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

Основная проблема в формате записи и восстановления хода работы после  выполнения программы - можно придумать какой-то свой формат записи, но может быть уже существуют похожие решения?

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

Есть-ли какой-нибудь формат для представления хода выполнения программы? Т.е. все вызовы функций, итерации циклов, проверки условий, присвоения переменных и т.д. Я хочу написать проход для компилятора который к исходному коду добавляет логи - т.е. для кода

for i in 0 .. 3:
  echo i

мы должны получить

for i in 0 .. 3:
  log("loop start")
  log("var set i = ", i)
  log("function call echo", i)
  echo i
  log("loop end")

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

Основная проблема в формате записи и восстановления хода работы после  выполнения программы - можно придумать какой-то свой формат записи, но может быть уже существуют похожие решения?

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

Что-то сходное с CFG да. Хотя скорее всего более конкретного решения по эту задачу все равно нет, так как я не смог найти ничего похожего кроме просто банальных блок-схем.

Если речь об исполнении, то не CFG, DFG — DAG, в котором узлы это операции, а ребра — динамические зависимости по данным. Такое существует и используется для визуализации трасс исполнения. Для весьма специальных применений.

Если речь об исполнении, то не CFG, DFG — DAG, в котором узлы это операции, а ребра — динамические зависимости по данным. Такое существует и используется для визуализации трасс исполнения. Для весьма специальных применений.

Есть-ли какой-нибудь формат для представления хода выполнения программы? Т.е. все вызовы функций, итерации циклов, проверки условий, присвоения переменных и т.д. Я хочу написать проход для компилятора который к исходному коду добавляет логи - т.е. для кода

for i in 0 .. 3:
  echo i

мы должны получить

for i in 0 .. 3:
  log("loop start")
  log("var set i = ", i)
  log("function call echo", i)
  echo i
  log("loop end")

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

Основная проблема в формате записи и восстановления хода работы после  выполнения программы - можно придумать какой-то свой формат записи, но может быть уже существуют похожие решения?

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

Есть-ли какой-нибудь формат для представления хода выполнения программы? Т.е. все вызовы функций, итерации циклов, проверки условий, присвоения переменных и т.д. Я хочу написать проход для компилятора который к исходному коду добавляет логи - т.е. для кода

for i in 0 .. 3:
  echo i

мы должны получить

for i in 0 .. 3:
  log("loop start")
  log("var set i = ", i)
  log("function call echo", i)
  echo i
  log("loop end")

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

Основная проблема в формате записи и восстановления хода работы после  выполнения программы - можно придумать какой-то свой формат записи, но может быть уже существуют похожие решения?

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

Делаю таблицу символов

Функции для работы с ней
SymTable_insert() - вставляет новый символ
SymTable_find() - находит символ илт NULL
SymTable_delLastN() - удаляет последние N символов (для закрытия области видимости)

И теперь вопрос:
Как правильно хранить N (кол-во симаолов в новом скоупе)

Либо хранить только последнее N и находя новый лекс блок рекурсивно работать с ним (так должно быть легче работать с парсером когда он собирает stmt_block, но дороже из-за рекурсии)
Либо хранить массив N и удалять/добавлять значения в нем (дороже по памяти)

Что можете подсказать по этому поводу?

Сделайте просто linked list из таблиц по одной на каждый скоуп.

Но тогда они не будут "наследоваться" ведь

{
     /* scope1 */
     {
          /* scope2 */
      }
}
Из scope2 можно обратиться к переменным scope1
И в текущем варианте такой  crossScopeSearch (выдуманый термин)
Относительно быстрый

А если у меня будет список (не обязателельно связный) таблиц
Мне прийдется проводить поиск в каждой из них

Слышали насчёт "premature optimization"? 😉

Ну... да, возможно это преждевременно, но тогда уж легче хранить список длин скоупов


И если есть реализация позволяющая быстро закрывать N последних
Почему бы ей не пользоваться?

А какая у Вас тогда асимптотика вставки и поиска?

Вставка и поиск идут по бинарному дереву
(Не сбалансированому) но имена перемнных вроде относительно "случайные" так что сильного вырождения быть не должно

Тогда откуда "реализация позволяющая быстро закрывать N последних"? Либо что значит "быстро"?