Как использовать отступы в качестве разделителей блоков с помощью bison и flex

Question

Я хочу знать, как реализовать отступ в качестве разделителей блоков в bison + flex.Точно так же, как в python.Я пишу свой собственный язык программирования (в основном для развлечения, но я намерен использовать его вместе с игровым движком), я постараюсь придумать что-то особенное, что минимизирует шаблонность и максимизирует скорость разработки.

Я уже написал компилятор ( на самом деле `лангТой" переводчику Nasm) на C, но потерпел неудачу.По какой-то причине он смог обработать только одну строку во всем исходном файле (ну, я не спал более 48 часов - так что...Ну, знаете, расплавление мозгов).

Я не знаю, проще ли реализовать фигурные скобки и / или begin -> end (у меня нет с этим проблем) или это просто мой мозг блокируется.

Заранее спасибо!

---

Обновить: Ладно, я понятия не имею, как это сделать с помощью flex.У меня проблемы с возвратом нескольких выделенных данных в анализатор.Flex / Bison для меня относительно новы.

---

Обновление 2: Это гибкий файл, который я придумал до сих пор;он не совсем понимает это:

%x t
%option noyywrap

%{
  int lineno = 0, ntab = 0, ltab = 0, dedent = 0;
%}

%%

<*>\n  { ntab = 0; BEGIN(t); }
<t>\t  { ++ntab; }
<t>.   { int i; /* my compiler complains not c99 if i use for( int i=0... */
         if( ntab > ltab )
           printf("> indent >\n");
         else if( ntab < ltab )
           for( i = 0; i < ltab - ntab; i++ )
             printf("< dedent <\n");
         else
           printf("=        =\n");

         ltab = ntab; ntab = 0;
         BEGIN(INITIAL);
         /* move to next rule */
         REJECT;}
.    /* ignore everything else for now */

%%

main()
{
  yyin = fopen( "test", "r" );
  yylex();
}

Ты можешь попробовать поиграть с этим, может быть, ты увидишь, чего мне не хватает.вернуть несколько выделенных элементов было бы проще простого в Haxe ( return t_dedent( num );).

Этот код не всегда корректно сопоставляет отступы.

---

Обновление 3: Я думаю, что я оставлю надежду на flex и сделаю это по-своему, если кто-нибудь знает, как это сделать во flex, я был бы рад услышать это в любом случае.

Answer 1

Вам нужно сделать так, чтобы flex подсчитывал количество пробелов в начале каждой строки и вставлял соответствующее количество токенов INDENT / UNINDENT, которые анализатор будет использовать для группировки вещей. Один вопрос заключается в том, что вы хотите сделать со вкладками и пробелами - хотите ли вы, чтобы они были эквивалентны фиксированным остановкам табуляции, или вы хотите, чтобы отступ был согласованным (поэтому, если одна строка начинается с вкладки, а следующая с пробелом вы сигнализируете об ошибке, которая, вероятно, немного сложнее).

Предполагая, что вам нужны фиксированные табуляции из 8 столбцов, вы можете использовать что-то вроде

%{
/* globals to track current indentation */
int current_line_indent = 0;   /* indentation of the current line */
int indent_level = 0;          /* indentation level passed to the parser */
%}

%x indent /* start state for parsing the indentation */
%s normal /* normal start state for everything else */

%%
<indent>" "      { current_line_indent++; }
<indent>"\t"     { current_line_indent = (current_line_indent + 8) & ~7; }
<indent>"\n"     { current_line_indent = 0; /*ignoring blank line */ }
<indent>.        {
                   unput(*yytext);
                   if (current_line_indent > indent_level) {
                       indent_level++;
                       return INDENT;
                   } else if (current_line_indent < indent_level) {
                       indent_level--;
                       return UNINDENT;
                   } else {
                       BEGIN normal;
                   }
                 }

<normal>"\n"     { current_line_indent = 0; BEGIN indent; }
... other flex rules ...

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

Answer 2

Ответ Криса имеет большое значение для создания удобного решения, большое спасибо за это!К сожалению, в нем отсутствует еще несколько важных аспектов, которые мне были нужны:

• Несколько отступов (unindents) одновременно.Рассмотрим, что следующий код должен выдавать два выходит после звонка в baz:

  def foo():
    if bar:
      baz()
  

• Выдает отступы, когда достигнут конец файла и все еще находится на некотором уровне отступа.

• Уровни отступов разного размера.Текущий код Криса корректно работает только с отступами в 1 пробел.

Основываясь на коде Криса, я придумал решение, которое работает во всех случаях, с которыми я сталкивался до сих пор.Я создал проект шаблона для синтаксического анализа текста на основе отступов, используя flex (и bison) на github: https://github.com/lucasb-eyer/flex-bison-indentation.Это полностью рабочий (основанный на CMake) проект, который также отслеживает положение строки и диапазон столбцов текущего токена.

На всякий случай, если ссылка по какой-либо причине оборвется, вот суть лексера:

#include <stack>

int g_current_line_indent = 0;
std::stack<size_t> g_indent_levels;
int g_is_fake_outdent_symbol = 0;

static const unsigned int TAB_WIDTH = 2;

#define YY_USER_INIT { \
    g_indent_levels.push(0); \
    BEGIN(initial); \
}
#include "parser.hh"

%}

%x initial
%x indent
%s normal

%%
    int indent_caller = normal;

 /* Everything runs in the <normal> mode and enters the <indent> mode
    when a newline symbol is encountered.
    There is no newline symbol before the first line, so we need to go
    into the <indent> mode by hand there.
 */
<initial>.  { set_yycolumn(yycolumn-1); indent_caller = normal; yyless(0); BEGIN(indent); }
<initial>\n { indent_caller = normal; yyless(0); BEGIN(indent); }    

<indent>" "     { g_current_line_indent++; }
<indent>\t      { g_current_line_indent = (g_current_line_indent + TAB_WIDTH) & ~(TAB_WIDTH-1); }
<indent>\n      { g_current_line_indent = 0; /* ignoring blank line */ }
<indent><<EOF>> {
                    // When encountering the end of file, we want to emit an
                    // outdent for all indents currently left.
                    if(g_indent_levels.top() != 0) {
                        g_indent_levels.pop();

                        // See the same code below (<indent>.) for a rationale.
                        if(g_current_line_indent != g_indent_levels.top()) {
                            unput('\n');
                            for(size_t i = 0 ; i < g_indent_levels.top() ; ++i) {
                                unput(' ');
                            }
                        } else {
                            BEGIN(indent_caller);
                        }

                        return TOK_OUTDENT;
                    } else {
                        yyterminate();
                    }
                }

<indent>.       {
                    if(!g_is_fake_outdent_symbol) {
                        unput(*yytext);
                    }
                    g_is_fake_outdent_symbol = 0;
                    // -2: -1 for putting it back and -1 for ending at the last space.
                    set_yycolumn(yycolumn-1);

                    // Indentation level has increased. It can only ever
                    // increase by one level at a time. Remember how many
                    // spaces this level has and emit an indentation token.
                    if(g_current_line_indent > g_indent_levels.top()) {
                        g_indent_levels.push(g_current_line_indent);
                        BEGIN(indent_caller);
                        return TOK_INDENT;
                    } else if(g_current_line_indent < g_indent_levels.top()) {
                        // Outdenting is the most difficult, as we might need to
                        // outdent multiple times at once, but flex doesn't allow
                        // emitting multiple tokens at once! So we fake this by
                        // 'unput'ting fake lines which will give us the next
                        // outdent.
                        g_indent_levels.pop();

                        if(g_current_line_indent != g_indent_levels.top()) {
                            // Unput the rest of the current line, including the newline.
                            // We want to keep it untouched.
                            for(size_t i = 0 ; i < g_current_line_indent ; ++i) {
                                unput(' ');
                            }
                            unput('\n');
                            // Now, insert a fake character indented just so
                            // that we get a correct outdent the next time.
                            unput('.');
                            // Though we need to remember that it's a fake one
                            // so we can ignore the symbol.
                            g_is_fake_outdent_symbol = 1;
                            for(size_t i = 0 ; i < g_indent_levels.top() ; ++i) {
                                unput(' ');
                            }
                            unput('\n');
                        } else {
                            BEGIN(indent_caller);
                        }

                        return TOK_OUTDENT;
                    } else {
                        // No change in indentation, not much to do here...
                        BEGIN(indent_caller);
                    }
                }

<normal>\n    { g_current_line_indent = 0; indent_caller = YY_START; BEGIN(indent); }

Answer 3

Вьющиеся скобки (и тому подобное) становятся проще, только если вы используете токенизатор, который удаляет все пробелы (используется только для разделения токенов). См. эту страницу (раздел " как компилятор анализирует отступы? ") для некоторых идей по токенизации Python.

Если вы не выполняете токенизацию перед синтаксическим анализом, тогда может потребоваться дополнительная работа, это зависит от того, как вы создаете парсер.

Answer 4

Вам нужно правило, которое выглядит аналогично этому (предполагается, что вы используете вкладки для отступов):

\ t: {return TABDENT; }

Честно говоря, я всегда обнаружил, что скобки (или начало / конец) легче писать и читать, как для человека, так и для автора лексера / парсера.