Можете ли вы добавить новые операторы в синтаксис Python?

вы можете найти это полезным - Python internals: добавление нового оператора в Python, цитируемый здесь:

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

все кодирование для этой статьи было сделано против передовой ветви Py3k в the зеркало репозитория Python Mercurial.

на until сообщении

некоторые языки, такие как Ruby, имеют until заявление, которое является дополнением к while (until num == 0 эквивалентно while num != 0). В Ruby, я могу написать:

num = 3
until num == 0 do
  puts num
  num -= 1
end

и он будет печатать:

3
2
1

Итак, я хочу добавить аналогичную возможность для Python. То есть уметь писать:

num = 3
until num == 0:
  print(num)
  num -= 1

язык-адвокатура отступление

эта статья не пытается предложить добавление until оператор для Python. Хотя я думаю, что такое утверждение сделало бы некоторый код более ясным, и эта статья показывает, насколько легко его добавить, я полностью уважаю философию минимализма Python. Все, что я пытаюсь сделать здесь, на самом деле, это получить некоторое представление о внутренней работе Python.

изменение грамматики

Python использует пользовательский генератор имени парсер pgen. Это синтаксический анализатор LL(1), который преобразует исходный код Python в дерево синтаксического анализа. Входным сигналом генератора синтаксического анализатора является файл Grammar/Grammar[1]. Это простой текстовый файл, который определяет грамматику Python.

[1]: с этого момента ссылки на файлы в источнике Python даются относительно корня дерева источника, который является каталогом, в котором вы запускаете configure и make для сборки Python.

две модификации должны быть сделаны в файле грамматики. Первый-добавить определение для until заявление. Я нашел, где while оператор был определен (while_stmt), и добавил until_stmt ниже [2]:

compound_stmt: if_stmt | while_stmt | until_stmt | for_stmt | try_stmt | with_stmt | funcdef | classdef | decorated
if_stmt: 'if' test ':' suite ('elif' test ':' suite)* ['else' ':' suite]
while_stmt: 'while' test ':' suite ['else' ':' suite]
until_stmt: 'until' test ':' suite

[2]: это демонстрирует общую технику, которую я использую при изменении исходного кода, с которым я не знаком:работа по подобию. Этот принцип не решит всех ваших проблем, но он определенно может облегчить процесс. С все, что нужно сделать для while также должно быть сделано для until, это служит довольно хорошим руководством.

обратите внимание, что я решил исключить else пункт из моего определения until, просто чтобы сделать его немного другим (и потому, что, честно говоря, мне не нравится else предложение циклов и не думаю, что оно хорошо сочетается с Дзен Python).

второе изменение заключается в изменении правила для compound_stmt включить until_stmt, как вы можете видеть в фрагмент выше. Это сразу после while_stmt снова.

при выполнении make после изменения Grammar/Grammar обратите внимание, что pgen программа запускается для повторного создания Include/graminit.h и Python/graminit.c, а затем несколько файлов повторно компилируются.

изменение кода поколения AST

после того, как синтаксический анализатор Python создал дерево синтаксического анализа, это дерево преобразуется в AST, так как ASTs гораздо проще работать с на последующих этапах процесс компиляции.

Итак, мы собираемся посетить Parser/Python.asdl который определяет структуру ASTs Python и добавляет узел AST для нашего нового until заявление, снова прямо под while:

| While(expr test, stmt* body, stmt* orelse)
| Until(expr test, stmt* body)

если вы сейчас запустите make обратите внимание, что перед компиляцией кучу файлов, Parser/asdl_c.py запускается для генерации кода C из файла определения AST. Это (как Grammar/Grammar) - еще один пример исходного кода Python с использованием мини-языка (другими словами, DSL) для упрощение программирования. Также обратите внимание, что с Parser/asdl_c.py это скрипт Python, это своего рода загрузки - чтобы построить Python с нуля, Python уже должен быть доступен.

пока Parser/asdl_c.py сгенерировал код для управления нашим недавно определенным узлом AST (в файлы Include/Python-ast.h и Python/Python-ast.c), мы все еще должны написать код, который преобразует соответствующий узел дерева синтаксического анализа в него вручную. Это делается в файле Python/ast.c. Есть функция с именем ast_for_stmt преобразует разберите узлы дерева для операторов в узлы AST. Опять же, руководствуясь нашим старым другом while, мы прыгаем прямо в большой switch для обработки составных операторов и добавления предложения для until_stmt:

case while_stmt:
    return ast_for_while_stmt(c, ch);
case until_stmt:
    return ast_for_until_stmt(c, ch);

теперь мы должны реализовать ast_for_until_stmt. Вот это:

static stmt_ty
ast_for_until_stmt(struct compiling *c, const node *n)
{
    /* until_stmt: 'until' test ':' suite */
    REQ(n, until_stmt);

    if (NCH(n) == 4) {
        expr_ty expression;
        asdl_seq *suite_seq;

        expression = ast_for_expr(c, CHILD(n, 1));
        if (!expression)
            return NULL;
        suite_seq = ast_for_suite(c, CHILD(n, 3));
        if (!suite_seq)
            return NULL;
        return Until(expression, suite_seq, LINENO(n), n->n_col_offset, c->c_arena);
    }

    PyErr_Format(PyExc_SystemError,
                 "wrong number of tokens for 'until' statement: %d",
                 NCH(n));
    return NULL;
}

опять же, это было закодировано, внимательно глядя на эквивалент ast_for_while_stmt, с той разницей, что для until я решил не поддерживать else предложения. Как и ожидалось, AST создается рекурсивно, используя другие функции создания AST, такие как ast_for_expr для выражения условия и ast_for_suite на теле until заявление. Наконец, новый узел с именем Until возвращается.

обратите внимание, что мы обращаемся к узлу дерева синтаксического анализа n использование некоторых макросов, таких как NCH и CHILD. Это стоит понять - их код находится в Include/node.h.

отступление: АСТ композиция

я решил создать новый тип AST для until заявление, но на самом деле в этом нет необходимости. Я мог бы сохранить некоторую работу и реализовать новую функциональность, используя состав существующих узлов AST, так как:

until condition:
   # do stuff

аналогично:

while not condition:
  # do stuff

вместо создания Until узел ast_for_until_stmt, я мог бы создать Not узел с While узел, как ребенок. Поскольку компилятор AST уже знает, как обрабатывать эти узлы, следующие шаги процесса могут быть пропущенный.

компиляция ASTs в байт-код

следующим шагом является компиляция AST в байт-код Python. Компиляция имеет промежуточный результат, который является CFG (график потока управления), но поскольку тот же код обрабатывает его, я пока проигнорирую эту деталь и оставлю ее для другой статьи.

код, который мы рассмотрим далее-это Python/compile.c. Следуя примеру while, мы находим функцию compiler_visit_stmt, который отвечает за составление отчетности в байткод. Мы добавляем предложение для Until:

case While_kind:
    return compiler_while(c, s);
case Until_kind:
    return compiler_until(c, s);

если вам интересно, что Until_kind есть, это константа (на самом деле значение _stmt_kind перечисление) автоматически генерируется из файла определения AST в Include/Python-ast.h. Во всяком случае, мы называем compiler_until которого, конечно, до сих пор не существует. Я займусь этим через минуту.

если вы любопытны, как я, Вы заметите, что compiler_visit_stmt свойственно. Нет количества grep-ping дерево источника показывает, где он называется. В этом случае остается только один вариант-c macro-fu. Действительно, короткое расследование приводит нас к VISIT макрос определен в Python/compile.c:

#define VISIT(C, TYPE, V) {\
    if (!compiler_visit_ ## TYPE((C), (V))) \
        return 0; \

он используется для вызова compiler_visit_stmt на compiler_body. Однако вернемся к нашему делу...

как и было обещано, вот compiler_until:

static int
compiler_until(struct compiler *c, stmt_ty s)
{
    basicblock *loop, *end, *anchor = NULL;
    int constant = expr_constant(s->v.Until.test);

    if (constant == 1) {
        return 1;
    }
    loop = compiler_new_block(c);
    end = compiler_new_block(c);
    if (constant == -1) {
        anchor = compiler_new_block(c);
        if (anchor == NULL)
            return 0;
    }
    if (loop == NULL || end == NULL)
        return 0;

    ADDOP_JREL(c, SETUP_LOOP, end);
    compiler_use_next_block(c, loop);
    if (!compiler_push_fblock(c, LOOP, loop))
        return 0;
    if (constant == -1) {
        VISIT(c, expr, s->v.Until.test);
        ADDOP_JABS(c, POP_JUMP_IF_TRUE, anchor);
    }
    VISIT_SEQ(c, stmt, s->v.Until.body);
    ADDOP_JABS(c, JUMP_ABSOLUTE, loop);

    if (constant == -1) {
        compiler_use_next_block(c, anchor);
        ADDOP(c, POP_BLOCK);
    }
    compiler_pop_fblock(c, LOOP, loop);
    compiler_use_next_block(c, end);

    return 1;
}

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

все, мы закончили... Не так ли?

после внесения всех изменений и работает make, мы можем запустить недавно скомпилированный Python и попробовать наш новый until заявление:

>>> until num == 0:
...   print(num)
...   num -= 1
...
3
2
1

вуаля, все работает! Давайте посмотрим байт-код, созданный для нового оператора с помощью dis модуль следующим образом:

import dis

def myfoo(num):
    until num == 0:
        print(num)
        num -= 1

dis.dis(myfoo)

вот результат:

4           0 SETUP_LOOP              36 (to 39)
      >>    3 LOAD_FAST                0 (num)
            6 LOAD_CONST               1 (0)
            9 COMPARE_OP               2 (==)
           12 POP_JUMP_IF_TRUE        38

5          15 LOAD_NAME                0 (print)
           18 LOAD_FAST                0 (num)
           21 CALL_FUNCTION            1
           24 POP_TOP

6          25 LOAD_FAST                0 (num)
           28 LOAD_CONST               2 (1)
           31 INPLACE_SUBTRACT
           32 STORE_FAST               0 (num)
           35 JUMP_ABSOLUTE            3
      >>   38 POP_BLOCK
      >>   39 LOAD_CONST               0 (None)
           42 RETURN_VALUE

самая интересная операция-номер 12: Если условие истинно, мы переходим к после цикла. Это правильная семантика для until. Если прыжок не выполняется, тело цикла продолжает работать, пока оно не вернется к состоянию при работе 35.

чувствуя себя хорошо о моем изменении, я попытался запустить функцию (выполнение myfoo(3)) вместо того, чтобы показывать свой байткод. Результат был не слишком обнадеживающим:--111-->

Traceback (most recent call last):
  File "zy.py", line 9, in
    myfoo(3)
  File "zy.py", line 5, in myfoo
    print(num)
SystemError: no locals when loading 'print'

Вау... это не может быть хорошо. Так что же пошло не так?

случай отсутствующей таблицы символов

одним из шагов компилятора Python при компиляции AST является создание таблицы символов для кода, который он компилирует. Вызов PySymtable_Build на PyAST_Compile вызовы в модуль таблицы символов (Python/symtable.c), который выполняет AST аналогично функциям генерации кода. Наличие таблицы символов для каждой области помогает компилятору вычислить некоторую ключевую информацию, например, какие переменные являются глобальными, а какие локальными для области.

чтобы устранить проблему, мы должны изменить на Python/symtable.c добавление кода для обработки until заявления, после аналогичного кода для while заявления [3]:

case While_kind:
    VISIT(st, expr, s->v.While.test);
    VISIT_SEQ(st, stmt, s->v.While.body);
    if (s->v.While.orelse)
        VISIT_SEQ(st, stmt, s->v.While.orelse);
    break;
case Until_kind:
    VISIT(st, expr, s->v.Until.test);
    VISIT_SEQ(st, stmt, s->v.Until.body);
    break;

[3]: кстати, без этого кода есть предупреждение компилятора для Python/symtable.c. Компилятор замечает, что Until_kind значение перечисления не обрабатывается в инструкции switch symtable_visit_stmt и жалуется. Всегда важно проверять наличие предупреждений компилятора!

и теперь мы действительно сделали. Компиляция источника после этого изменения делает выполнение myfoo(3) работать ожидаемый.

вывод

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

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

ссылки

я использовал несколько отличных ссылок для построения этой статьи. Вот они, в определенном порядке:--111-->

• PEP 339: дизайн компилятора CPython - наверное, самый важный и всеобъемлющий кусок официальный документация для компилятора Python. Будучи очень коротким, он болезненно показывает нехватку хорошей документации внутренних частей Python.
• "компилятор Python Internals" - статья Томаса Ли
• "Python: проектирование и реализация" - презентация Гвидо ван Россума
• виртуальная машина Python (2.5), экскурсия-презентация Питера Tröger

первоисточник