Почему нельзя проанализировать C++ с помощью парсера LR (1)?

На Lambda the Ultimate есть интересная ветка, в которой обсуждается 9X_parser LALR grammar for C++.

Он включает ссылку на PhD thesis, которая включает 9X_cxx обсуждение синтаксического анализа C++, в 9X_parsing котором говорится, что:

"Грамматика 9X_formal-languages C++ неоднозначна, контекстно-зависимый 9X_c++ и потенциально требует бесконечного просмотра 9X_grammar вперед для разрешения некоторые неясности 9X_parsers ».

Далее приводится ряд примеров (см. стр. 147 9X_parsers PDF-файла).

Пример:

int(x), y, *const z;

значение

int x;
int y;
int *const z;

Сравнить с:

int(x), y, new int;

значение

(int(x)), (y), (new int));

(выражение, разделенное 9X_cpp запятыми).

Две последовательности токенов 9X_parse имеют одинаковую начальную подпоследовательность, но 9X_cxx разные деревья синтаксического анализа, которые 9X_cxx зависят от последнего элемента. До токена, устраняющего 9X_c++ неоднозначность, может быть сколь угодно 9X_parsing много токенов.

Проблема никогда не определяется так, хотя 9X_cxx она должна быть интересной:

каков наименьший 9X_parser набор модификаций грамматики C++, который 9X_cpp может потребоваться, чтобы эта новая грамматика 9X_parsers могла быть идеально проанализирована "неконтекстно-независимым" парсером 9X_cpp yacc? (с использованием только одного «хака»: устранение 9X_parse неоднозначности имени типа / идентификатора, синтаксический 9X_cpp анализатор, информирующий лексер о каждом 9X_parse определении типа / класса / структуры)

Я 9X_cxx вижу несколько:

1. Type Type; запрещено. Идентификатор, объявленный 9X_parser как typename, не может стать идентификатором, отличным 9X_cpp от typename (обратите внимание, что struct Type Type не 9X_c++ является двусмысленным и может быть разрешен).

   Есть 9X_c++ 3 типа names tokens:

   • types: встроенный тип или из-за определения типа / класса / структуры
   • шаблонные функции
   • идентификаторы: функции / методы и переменные / объекты

   Рассмотрение шаблонных функций как 9X_parser разных токенов решает двусмысленность func<. Если 9X_grammar func - имя функции-шаблона, то < должно быть 9X_grammar началом списка параметров шаблона, иначе 9X_grammar func - указатель на функцию, а < - оператор сравнения.

2. Type a(2); - это 9X_parsers экземпляр объекта. Type a(); и Type a(int) - прототипы функций.

3. int (k); полностью 9X_parse запрещен, следует писать int k;

4. typedef int func_type(); и typedef int (func_type)(); запрещены.

   Определение 9X_cxx типа функции должно быть указателем на функцию 9X_parsers typedef: typedef int (*func_ptr_type)();

5. рекурсия шаблона ограничена 1024, иначе 9X_parse увеличенный максимум может быть передан 9X_c++ компилятору в качестве опции.

6. int a,b,c[9],*d,(*f)(), (*g)()[9], h(char); тоже можно 9X_parser запретить, заменив его на int a,b,c[9],*d; int (*f)();

   int (*g)()[9];

   int h(char);

   по одной строке 9X_cpp на прототип функции или объявление указателя 9X_grammar функции.

   Наиболее предпочтительной альтернативой 9X_parsers было бы изменение ужасного синтаксиса указателя 9X_parsing на функцию,

   int (MyClass::*MethodPtr)(char*);

   подвергается повторному синтаксису 9X_parsing как:

   int (MyClass::*)(char*) MethodPtr;

   это согласовано с оператором приведения 9X_parser (int (MyClass::*)(char*))

7. typedef int type, *type_ptr; тоже может быть запрещено: по одной строке 9X_parse на typedef. Таким образом, это стало бы

   typedef int type;

   typedef int *type_ptr;

8. sizeof int, sizeof char, sizeof long long и 9X_cxx т. д. может быть объявлен в каждом исходном 9X_formal-languages файле. Таким образом, каждый исходный файл, использующий 9X_formal-languages тип int, должен начинаться с

   #type int : signed_integer(4)

   и unsigned_integer(4) будут запрещены 9X_grammar вне директивы #type это было бы большим шагом 9X_parsing к глупой sizeof int двусмысленности, присутствующей 9X_c++ во многих заголовках C++

Компилятор, реализующий 9X_parse повторно синтезированный C++, при обнаружении 9X_formal-languages источника C++, использующего неоднозначный 9X_parsers синтаксис, переместит также source.cpp в папку ambiguous_syntax и 9X_c++ автоматически создаст однозначно переведенный 9X_parse source.cpp перед его компиляцией.

Пожалуйста, добавьте 9X_parsing свой неоднозначный синтаксис C++, если вы 9X_parsers его знаете!

Как вы можете видеть в моем answer here, C++ содержит 9X_grammar синтаксис, который не может быть детерминированно 9X_grammar проанализирован анализатором LL или LR из-за 9X_cxx стадии разрешения типа (обычно после синтаксического 9X_parser анализа), изменяющей порядок операций , и, следовательно, основная 9X_formal-languages форма AST (обычно ожидается, что она будет 9X_cxx предоставлена ​​на первом этапе синтаксического 9X_parsing анализа).

Думаю, вы довольно близки к ответу.

LR (1) означает, что 9X_parsing для синтаксического анализа слева направо 9X_cpp требуется только один токен для упреждающего 9X_cxx просмотра контекста, тогда как LR (∞) означает 9X_formal-languages бесконечный упреждающий просмотр. То есть 9X_cpp синтаксическому анализатору необходимо знать 9X_parsers все, что происходит, чтобы выяснить, где 9X_c++ он находится сейчас.

Проблема "typedef" в C++ может 9X_parse быть проанализирована с помощью синтаксического 9X_c++ анализатора LALR (1), который строит таблицу 9X_parser символов во время синтаксического анализа 9X_cpp (не чистый синтаксический анализатор LALR). Проблема 9X_parsing "шаблона", вероятно, не может 9X_parsing быть решена этим методом. Преимущество этого 9X_grammar типа парсера LALR (1) состоит в том, что 9X_parsing грамматика (показанная ниже) является грамматикой 9X_parsing LALR (1) (отсутствие двусмысленности).

/* C Typedef Solution. */

/* Terminal Declarations. */

    => lookup();  /* Symbol table lookup. */

/* Rules. */

   Goal        -> [Declaration]...                +> goal_

   Declaration -> Type... VarList ';'                  +> decl_
               -> typedef Type... TypeVarList ';'      +> typedecl_

   VarList     -> Var /','...     
   TypeVarList -> TypeVar /','...

   Var         -> [Ptr]... Identifier 
   TypeVar     -> [Ptr]... TypeIdentifier                               

   Identifier     ->        +> identifier_(1)      
   TypeIdentifier ->       =+> typedefidentifier_(1,{typedef})

// The above line will assign {typedef} to the ,  
// because {typedef} is the second argument of the action typeidentifier_(). 
// This handles the context-sensitive feature of the C++ language.

   Ptr          -> '*'                  +> ptr_

   Type         -> char                 +> type_(1)
                -> int                  +> type_(1)
                -> short                +> type_(1)
                -> unsigned             +> type_(1)
                -> {typedef}            +> type_(1)

/* End Of Grammar. */

Следующий 9X_parsers ввод может быть проанализирован без проблем:

 typedef int x;
 x * y;

 typedef unsigned int uint, *uintptr;
 uint    a, b, c;
 uintptr p, q, r;

LRSTAR parser generator считывает 9X_parser указанную выше нотацию грамматики и генерирует 9X_cpp синтаксический анализатор, который обрабатывает 9X_parsers проблему "typedef" без двусмысленности 9X_cxx в дереве синтаксического анализа или AST. (Раскрытие 9X_c++ информации: я тот парень, который создал 9X_c++ LRSTAR.)