ANTLR4 CPP gramática incapaz de gerar analisador; NullPointereException

Question

ANTLR4 CPP gramática incapaz de gerar analisador; NullPointereException

votos

2

Eu estou tentando gerar um CPP Analisador usando ANTLR4 gramática e

org.antlr.v4.Tool

é me dar a NullPointerException. Eu não obtê-lo. Se houver um problema com a minha gramática, então ele deveria ter declarado-lo com uma mensagem de erro significativa. Só mais uma coisa estranha é que, embora eu criei este gramática no vim, quando eu abri-lo em ANTLRWorks 2.1, o painel Navigator mostra Please Wait ... e nada mais. Aqui está a minha gramática dado abaixo: -

grammar CppGrammar;

cpp: (INCLUDE_STAT | funcDefinition)*;

INCLUDE_STAT: '#' 'include' (LT ID+ '.h'? GT | '' ID+ '.h'? '');

expr: assignmentExpr
    | expr COMMA assignmentExpr;

assignmentExpr: conditionalExpr
              | logicalOrExpr ASSIGNMENTOP assignmentExpr
              | throwExpr;

conditionalExpr: logicalOrExpr
               | logicalOrExpr QMARK expr COLON assignmentExpr;

logicalOrExpr: logicalAndExpr
             | logicalOrExpr OR_OP logicalAndExpr;

ASSIGNMENTOP: EQ
            | MULT_EQ
            | DIV_EQ
            | MOD_EQ
        | PLUS_EQ
        | MINUS_EQ
        | GT_GT_EQ
        | LT_LT_EQ
        | AND_EQ
        | EXP_EQ
        | EXC_EQ;

throwExpr: THROW assignmentExpr?;

logicalAndExpr: inclusiveOrExpr
              | logicalAndExpr AND_OP inclusiveOrExpr;

inclusiveOrExpr: exclusiveOrExpr
               | inclusiveOrExpr INC_OR_OP exclusiveOrExpr;

exclusiveOrExpr: andExpr
               | exclusiveOrExpr EX_OR_OP andExpr;

andExpr: equalityExpr
       | andExpr AND equalityExpr;

equalityExpr: relationalExpr
            | equalityExpr EQUALITY relationalExpr
        | equalityExpr EXC_EQ relationalExpr;

relationalExpr: shiftExpr
              | relationalExpr LT shiftExpr
          | relationalExpr GT shiftExpr
          | relationalExpr LT_EQ shiftExpr
          | relationalExpr GT_EQ shiftExpr;

shiftExpr: additiveExpr
         | shiftExpr LT_LT additiveExpr
     | shiftExpr GT_GT additiveExpr;

additiveExpr: multiplicativeExpr
            | additiveExpr PLUS multiplicativeExpr
        | additiveExpr MINUS multiplicativeExpr;

multiplicativeExpr: pmExpr
                  | multiplicativeExpr MULT pmExpr
          | multiplicativeExpr DIV pmExpr
          | multiplicativeExpr MOD pmExpr;

pmExpr: castExpr
      | pmExpr DOT_MULT castExpr
      | pmExpr MINUS_GT_MULT castExpr;

castExpr: unaryExpr
        | LPARAN typeId RPARAN castExpr;

unaryExpr: postfixExpr
         | PLUS_PLUS castExpr
     | MINUS_MINUS castExpr
     | UNARYOP castExpr
     | SIZEOF unaryExpr
     | SIZEOF LPARAN typeId RPARAN
     | newExpr
     | delExpr;

typeId: typeSpecifierSeq abstractDeclarator?;

postfixExpr: primaryExpr
           | postfixExpr LSQRBRAC expr RSQRBRAC
       | postfixExpr LPARAN exprList? RPARAN
       | simpleTypeSpecifier LPARAN exprList? RPARAN
       | TYPENAME COLON_COLON? nestedNameSpecifier ID LPARAN exprList? RPARAN
       | TYPENAME COLON_COLON? nestedNameSpecifier TEMPLATE? templateId LPARAN exprList RPARAN
       | postfixExpr DOT TEMPLATE? idExpr
       | postfixExpr MINUS_GT TEMPLATE? idExpr
       | postfixExpr DOT pseudoDestructorName
       | postfixExpr MINUS_GT pseudoDestructorName
       | postfixExpr PLUS_PLUS
       | postfixExpr MINUS_MINUS
       | DYNAMIC_CAST LT typeId GT LPARAN expr RPARAN
       | STATIC_CAST LT typeId GT LPARAN expr RPARAN
       | REINTERPRET_CAST LT typeId GT LPARAN expr RPARAN
       | CONST_CAST LT typeId GT LPARAN expr RPARAN
       | TYPEID LPARAN expr RPARAN
       | TYPEID LPARAN typeId RPARAN;

newExpr: COLON_COLON? NEW newPlacement? newTypeId newInitializer?
       | COLON_COLON? NEW newPlacement? LPARAN typeId RPARAN newInitializer?;

delExpr: COLON_COLON? DELETE castExpr
       | COLON_COLON? DELETE LSQRBRAC RSQRBRAC castExpr;

typeSpecifierSeq: typeSpecifier typeSpecifierSeq?;

abstractDeclarator: ptrOp abstractDeclarator?
                  | directAbstractDeclarator;

primaryExpr: LITERAL
           | THIS
       | LPARAN expr RPARAN
       | idExpr;

exprList: assignmentExpr
        | exprList COMMA assignmentExpr;

simpleTypeSpecifier: COLON_COLON? nestedNameSpecifier? typeName
                   | COLON_COLON? nestedNameSpecifier TEMPLATE templateId
           | CHAR
           | WCHAR_T
           | BOOL
           | SHORT
           | INT
           | LONG
           | SIGNED
           | UNSIGNED
           | FLOAT
           | DOUBLE
           | VOID;

nestedNameSpecifier: classOrNamespaceName COLON_COLON nestedNameSpecifier?
                   | classOrNamespaceName COLON_COLON TEMPLATE nestedNameSpecifier;

templateId: templateName LT templateArgumentList? GT;

templateName: ID;

idExpr: unqualifiedId
      | qualifiedId;

pseudoDestructorName: COLON_COLON? nestedNameSpecifier? typeName COLON_COLON NEG typeName
                    | COLON_COLON? nestedNameSpecifier TEMPLATE templateId COLON_COLON NEG typeName
            | COLON_COLON? nestedNameSpecifier? NEG typeName;

newPlacement: LPARAN exprList RPARAN;

newTypeId: typeSpecifierSeq newDeclarator?;

newInitializer: LPARAN exprList? RPARAN;

typeSpecifier: simpleTypeSpecifier
             | classSpecifier
         | enumSpecifier
         | elaboratedTypeSpecifier
         | cvQualifier;

//directAbstractDeclarator: directAbstractDeclarator? LPARAN parameterDeclarationClause RPARAN cvQualifierSeq? exceptionSpecification?
//                        | directAbstractDeclarator? LSQRBRAC constantExpr RSQRBRAC
//          | LPARAN abstractDeclarator RPARAN;

directAbstractDeclarator
   :   directAbstractDeclarator LPARAN parameterDeclarationClause RPARAN cvQualifierSeq? exceptionSpecification?
   |   directAbstractDeclarator LSQRBRAC constantExpr? RSQRBRAC
   |   LPARAN parameterDeclarationClause RPARAN cvQualifierSeq? exceptionSpecification?
   |   LSQRBRAC constantExpr? RSQRBRAC
   |   LPARAN abstractDeclarator RPARAN
;    

typeName: className
        | enumName
    | typedefName;

classOrNamespaceName: className
                    | namespaceName;

templateArgumentList: templateArgument
                    | templateArgumentList COMMA templateArgument;

unqualifiedId: ID
             | operatorFuncId
         | conversionFuncId
         | NEG className
         | templateId;

qualifiedId: COLON_COLON? nestedNameSpecifier TEMPLATE? unqualifiedId
           | COLON_COLON ID
       | COLON_COLON operatorFuncId
       | COLON_COLON templateId;

newDeclarator: ptrOp newDeclarator?
             | directNewDeclarator;

classSpecifier: classHead LBRACKET memberSpecification? RBRACKET;

enumSpecifier: ENUM ID? LBRACKET enumList? RBRACKET;

elaboratedTypeSpecifier: CLASS_KEY COLON_COLON nestedNameSpecifier? ID
                       | ENUM COLON_COLON? nestedNameSpecifier? ID
               | TYPENAME COLON_COLON? nestedNameSpecifier ID
               | TYPENAME COLON_COLON? nestedNameSpecifier TEMPLATE? templateId;

cvQualifier: CONST
           | VOLATILE;

parameterDeclarationClause: parameterDeclarationList? DOT_DOT_DOT?
                          | parameterDeclarationList COMMA DOT_DOT_DOT;

cvQualifierSeq: cvQualifier cvQualifierSeq?;

exceptionSpecification: THROW LPARAN typeIdList RPARAN;

constantExpr: conditionalExpr;

className: ID
         | templateId;

typedefName: ID;

enumName: ID;

namespaceName: originalNamespaceName
             | namespaceAlias;

templateArgument: assignmentExpr
                | typeId
        | idExpr;

operatorFuncId: OPERATOR OP;

conversionFuncId: OPERATOR conversionTypeId;

directNewDeclarator: LSQRBRAC expr RSQRBRAC
                   | directNewDeclarator LSQRBRAC constantExpr RSQRBRAC;

classHead: CLASS_KEY ID? baseClause?
         | CLASS_KEY nestedNameSpecifier ID baseClause?
     | CLASS_KEY nestedNameSpecifier? templateId baseClause?;

CLASS_KEY: CLASS
        | 'struct'
    | 'union';

memberSpecification: memberDeclaration memberSpecification?
                   | ACCESS_SPECIFIER COLON memberSpecification?;

memberDeclaration: declSpecifierSeq? memberDeclaratorList? SEMI_COLON
                 | funcDefinition SEMI_COLON?
         | COLON_COLON? nestedNameSpecifier TEMPLATE? unqualifiedId SEMI_COLON
         | usingDeclaration
         | templateDeclaration;

enumList: enumDefinition
        | enumList COMMA enumDefinition;

enumDefinition: enum
              | enum EQ constantExpr;

enum: ID;

parameterDeclarationList: parameterDeclaration
                        | parameterDeclarationList COMMA parameterDeclaration;

parameterDeclaration: declSpecifierSeq declarator
                    | declSpecifierSeq declarator EQ assignmentExpr
            | declSpecifierSeq abstractDeclarator?
            | declSpecifierSeq abstractDeclarator? EQ assignmentExpr;

typeIdList: typeId
          | typeIdList COMMA typeId;

originalNamespaceName: ID;

namespaceAlias: ID;

conversionTypeId: typeSpecifierSeq conversionDeclarator?;

conversionDeclarator: ptrOp conversionDeclarator?;

baseClause: COLON baseSpecifierList;

baseSpecifierList: baseSpecifier
                 | baseSpecifierList COMMA baseSpecifier;

baseSpecifier: COLON_COLON? nestedNameSpecifier? className
             | VIRTUAL ACCESS_SPECIFIER? COLON_COLON? nestedNameSpecifier? className
         | ACCESS_SPECIFIER VIRTUAL? COLON_COLON? nestedNameSpecifier? className;

ACCESS_SPECIFIER: 'private'
               | 'protected'
           | 'public';

declSpecifierSeq: declSpecifierSeq? declSpecifier;

declSpecifier: STORAGE_CLASS_SPECIFIER
             | typeSpecifier
         | FUNC_SPECIFIER
         | FRIEND
         | TYPEDEF;

memberDeclaratorList: memberDeclarator
                    | memberDeclaratorList COMMA memberDeclarator;

memberDeclarator: declarator PURE_SPECIFIER?
                | declarator constantInitializer?
        | ID? COLON constantExpr;

funcDefinition: declSpecifierSeq? declarator ctorInitializer? funcBody
              | declSpecifierSeq? declarator funcTryBlock;

funcBody: compoundStatement;

funcTryBlock: TRY ctorInitializer? funcBody handlerSeq;

usingDeclaration: USING TYPENAME? COLON_COLON? nestedNameSpecifier unqualifiedId SEMI_COLON
                | USING COLON_COLON unqualifiedId SEMI_COLON;

templateDeclaration: EXPORT? TEMPLATE LT templateParameterList GT declaration;

templateParameterList: templateParameter
                     | templateParameterList COMMA templateParameter;

templateParameter: typeParameter
                 | parameterDeclaration;

typeParameter: CLASS ID?
             | CLASS ID? EQ typeId
         | TYPENAME ID?
         | TYPENAME ID? EQ typeId
         | TEMPLATE LT templateParameterList GT CLASS ID?
         | TEMPLATE LT templateParameterList GT CLASS ID? EQ idExpr;

declarator: directDeclarator
          | ptrOp declarator;

directDeclarator: declaratorId
                | directDeclarator LPARAN parameterDeclarationClause RPARAN cvQualifierSeq? exceptionSpecification?
        | directDeclarator LSQRBRAC constantExpr RSQRBRAC
        | LPARAN declarator RPARAN;

declaratorId: idExpr
            | COLON_COLON? nestedNameSpecifier? typeName;

STORAGE_CLASS_SPECIFIER: 'auto'
                     | 'register'
             | 'static'
             | EXTERN
             | 'mutable';

FUNC_SPECIFIER: 'inline'
             | VIRTUAL
         | 'explicit';

PURE_SPECIFIER: EQ '0';

constantInitializer: EQ constantExpr;

ctorInitializer: COLON memInitializerList;

memInitializerList: memInitializer
                  | memInitializer COMMA memInitializerList;

memInitializer: memInitializerId LPARAN exprList RPARAN;

memInitializerId: COLON_COLON? nestedNameSpecifier? className
                | ID;

compoundStatement: LBRACKET statementSeq? RBRACKET;

statementSeq: statement
            | statementSeq statement;

statement: labeledStatement
         | exprStatement
     | compoundStatement
     | selectionStatement
     | iterationStatement
     | jumpStatement
     | declarationStatement
     | tryBlock;

labeledStatement: ID COLON statement
                | CASE constantExpr COLON statement
        | DEFAULT COLON statement;

exprStatement: expr? SEMI_COLON;

selectionStatement: IF LPARAN condition RPARAN statement
                  | IF LPARAN condition RPARAN statement ELSE statement
          | SWITCH LPARAN condition RPARAN statement;

iterationStatement: WHILE LPARAN condition RPARAN statement
                  | DO statement WHILE LPARAN expr RPARAN SEMI_COLON
          | FOR LPARAN forInitStatement condition? SEMI_COLON expr? RPARAN statement;

jumpStatement: BREAK SEMI_COLON
             | CONTINUE SEMI_COLON
         | RETURN expr? SEMI_COLON
         | GOTO ID SEMI_COLON;

declarationStatement: blockDeclaration;

tryBlock: TRY compoundStatement handlerSeq;

condition: expr
         | typeSpecifierSeq declarator EQ assignmentExpr;

forInitStatement: exprStatement
                | simpleDeclaration;

simpleDeclaration: declSpecifierSeq? initDeclaratorList? SEMI_COLON;

initDeclaratorList: initDeclarator
                  | initDeclaratorList COMMA initDeclarator;

initDeclarator: declarator initializer?;

initializer: EQ initializerClause
           | LPARAN exprList RPARAN;

initializerClause: assignmentExpr
                 | LBRACKET initializerList COMMA? RBRACKET
         | LBRACKET RBRACKET;

initializerList: initializerClause
               | initializerList COMMA initializerClause;

blockDeclaration: simpleDeclaration
                | ASM_DEFINITION
        | namespaceAliasDefinition
        | usingDeclaration
        | usingDirective;

ASM_DEFINITION: 'asm' LPARAN STRING RPARAN SEMI_COLON;

namespaceAliasDefinition: NAMESPACE ID EQ qualifiedNamespaceSpecifier SEMI_COLON;

qualifiedNamespaceSpecifier: COLON_COLON? nestedNameSpecifier? namespaceName; 

usingDirective: USING NAMESPACE COLON_COLON? nestedNameSpecifier? namespaceName SEMI_COLON;

handlerSeq: handler handlerSeq?;

handler: CATCH LPARAN exceptionDeclaration RPARAN compoundStatement;

exceptionDeclaration: typeSpecifierSeq declarator
                    | typeSpecifierSeq abstractDeclarator
            | typeSpecifierSeq
            | DOT_DOT_DOT;

declaration: blockDeclaration
           | funcDefinition
       | templateDeclaration
       | explicitInstantiation
       | explicitSpecialization
       | linkageSpecification
       | namespaceDefinition;

explicitInstantiation: TEMPLATE declaration;

explicitSpecialization: TEMPLATE LT GT declaration;

linkageSpecification: EXTERN STRING LBRACKET declarationSeq RBRACKET
                    | EXTERN STRING declaration;

declarationSeq: declaration
              | declarationSeq declaration;

namespaceDefinition: namedNamespaceDefinition
                   | unnamedNamespaceDefinition;

namedNamespaceDefinition: originalNamespaceDefinition
                        | extensionNamespaceDefinition;

originalNamespaceDefinition: NAMESPACE ID LBRACKET namespaceBody RBRACKET; 

extensionNamespaceDefinition: NAMESPACE originalNamespaceName LBRACKET namespaceBody RBRACKET;

unnamedNamespaceDefinition: NAMESPACE LBRACKET namespaceBody RBRACKET;

namespaceBody: declarationSeq?;

UNARYOP: MULT
       | AND
       | PLUS
       | MINUS
       | EXC
       | NEG;

ptrOp: MULT cvQualifierSeq?
     | AND
     | COLON_COLON? nestedNameSpecifier MULT cvQualifierSeq;

LITERAL: INT_L
       | CHAR_L
       | FLOAT_L
       | STRING
       | BOOL_L;

INT_L: DECIMAL INT_SUFFIX?
   | OCTAL INT_SUFFIX?
   | HEXADECIMAL INT_SUFFIX?;

DECIMAL: NONZERO_DIGIT
       | DECIMAL DIGIT;

NONZERO_DIGIT: '1'
             | '2'
         | '3'
         | '4'
         | '5'
         | '6'
         | '7'
         | '8'
         | '9';

OCTAL: '0'
     | OCTAL OCTAL_DIGIT;

HEXADECIMAL: '0x' HEXADECIMAL_DIGIT
           | '0X' HEXADECIMAL_DIGIT
       | HEXADECIMAL HEXADECIMAL_DIGIT;

INT_SUFFIX: UNSIGNED_SUFFIX LONG_SUFFIX?
          | LONG_SUFFIX UNSIGNED_SUFFIX?;

UNSIGNED_SUFFIX: 'u'
               | 'U';

LONG_SUFFIX: 'l'
           | 'L';

CHAR_L: '\'' C_CHAR_SEQUENCE '\''
    | 'L\'' C_CHAR_SEQUENCE '\'';

C_CHAR_SEQUENCE: C_CHAR
               | C_CHAR_SEQUENCE C_CHAR;

C_CHAR: ~('\n' | '\\' | '\'')
      | ESCAPE_SEQUENCE
      | UNIVERSAL_CHARACTER_NAME;

ESCAPE_SEQUENCE: SIMPLE_ESCAPE_SEQUENCE
               | OCTAL_ESCAPE_SEQUENCE
           | HEXADECIMAL_ESCAPE_SEQUENCE;

SIMPLE_ESCAPE_SEQUENCE: '\\\''
                      | '\\'
              | '\\?'
              | '\\\\'
              | '\\a'
              | '\\b'
              | '\\f'
              | '\\n'
              | '\\r'
              | '\\t'
              | '\\v';

OCTAL_ESCAPE_SEQUENCE: '\\' OCTAL_DIGIT
                     | '\\' OCTAL_DIGIT OCTAL_DIGIT
             | '\\' OCTAL_DIGIT OCTAL_DIGIT OCTAL_DIGIT;

OCTAL_DIGIT: '0'
           | '1'
       | '2'
       | '3'
       | '4'
       | '5'
       | '6'
       | '7';

HEXADECIMAL_ESCAPE_SEQUENCE: '\x' HEXADECIMAL_DIGIT
                           | HEXADECIMAL_ESCAPE_SEQUENCE HEXADECIMAL_DIGIT;

HEXADECIMAL_DIGIT: '0'
                 | '1'
         | '2'
         | '3'
         | '4'
         | '5'
         | '6'
         | '7'
         | '8'
         | '9'
         | 'a'
         | 'b'
         | 'c'
         | 'd'
         | 'e'
         | 'f'
         | 'A'
         | 'B'
         | 'C'
         | 'D'
         | 'E'
         | 'F';

UNIVERSAL_CHARACTER_NAME: '\u' HEX_QUAD
                        | '\U' HEX_QUAD HEX_QUAD;

HEX_QUAD: HEXADECIMAL_DIGIT HEXADECIMAL_DIGIT HEXADECIMAL_DIGIT HEXADECIMAL_DIGIT;

FLOAT_L: FRACTIONAL_CONSTANT EXPONENT_PART? FLOAT_SUFFIX?
     | DIGIT_SEQUENCE EXPONENT_PART FLOAT_SUFFIX?;

FRACTIONAL_CONSTANT: DIGIT_SEQUENCE? DOT DIGIT_SEQUENCE
                   | DIGIT_SEQUENCE DOT;

EXPONENT_PART: 'e' SIGN? DIGIT_SEQUENCE
             | 'E' SIGN? DIGIT_SEQUENCE;

SIGN: PLUS
    | MINUS;

DIGIT_SEQUENCE: DIGIT
              | DIGIT_SEQUENCE DIGIT;

DIGIT: '0'
     | '1'
     | '2'
     | '3'
     | '4'
     | '5'
     | '6'
     | '7'
     | '8'
     | '9';

FLOAT_SUFFIX: 'f'
            | 'l'
        | 'F'
        | 'L';

BOOL_L: 'false'
    | 'true';

OP: NEW
  | DELETE
  | 'new[]'
  | 'delete[]'
  | PLUS
  | MINUS
  | MULT
  | DIV
  | MOD
  | EXP
  | AND
  | OR
  | NEG
  | EXC
  | EQ
  | LT
  | GT
  | PLUS_EQ
  | MINUS_EQ
  | MULT_EQ
  | DIV_EQ
  | MOD_EQ
  | EXP_EQ
  | AND_EQ
  | OR_EQ
  | LT_LT
  | GT_GT
  | GT_GT_EQ
  | LT_LT_EQ
  | EQ_EQ
  | EXC_EQ
  | LT_EQ
  | GT_EQ
  | AND_AND
  | OR_OR
  | PLUS_PLUS
  | MINUS_MINUS
  | COMMA
  | MINUS_GT_MULT
  | MINUS_GT
  | LP_RP
  | LB_RB;

NEW: 'new';
DELETE: 'delete';
PLUS: '+';
MINUS: '-';
MULT: '*';
DIV: '/';
MOD: '%';
EXP: '^';
AND: '&';
OR: '|';
NEG: '~';
EXC: '!';
EQ: '=';
LT: '<';
GT: '>';
PLUS_EQ: '+=';
MINUS_EQ: '-=';
MULT_EQ: '*=';
DIV_EQ: '/=';
MOD_EQ: '%=';
EXP_EQ: '^=';
AND_EQ: '&=';
OR_EQ: '|=';
LT_LT: '<<';
GT_GT: '>>';
GT_GT_EQ: '>>=';
LT_LT_EQ: '<<=';
EQ_EQ: '==';
EXC_EQ: '!=';
LT_EQ: '<=';
GT_EQ: '>=';
AND_AND: '&&';
OR_OR: '||';
PLUS_PLUS: '++';
MINUS_MINUS: '--';
COMMA: ',';
MINUS_GT_MULT: '->*';
MINUS_GT: '->';
LP_RP: '()';
LB_RB: '[]';

ID: [a-zA-Z0-9_$]+;

COMMENT: ('/*' .*? '*/' | '//' .*? '\r'? '\n') -> skip;

WS: [ \t\r\n]+ -> skip;

STRING: '' ( '\\' | . )*? '';

QMARK: '?';

CHAR: 'char';

WCHAR_T: 'wchar_t';

BOOL: 'bool';

SHORT: 'short';

INT: 'int';

LONG: 'long';

SIGNED: 'signed';

UNSIGNED: 'unsigned';

FLOAT: 'float';

DOUBLE: 'double';

VOID: 'void';

DOT_MULT: '.*';

LPARAN: '(';

RPARAN: ')';

COLON_COLON: '::';

LBRACKET: '{';

RBRACKET: '}';

LSQRBRAC: '[';

RSQRBRAC: ']';

COLON: ':';

SEMI_COLON: ';';

DOT: '.';

DOT_DOT_DOT: '...';

SIZEOF: 'sizeof';

TYPENAME: 'typename';

TEMPLATE: 'template';

DYNAMIC_CAST: 'dynamic_cast';

STATIC_CAST: 'static_cast';

REINTERPRET_CAST: 'reinterpret_cast';

CONST_CAST: 'const_cast';

TYPEID: 'typeid';      

THIS: 'this';

ENUM: 'enum';

CONST: 'const';

VOLATILE: 'volatile';

THROW: 'throw';

OPERATOR: 'operator';

VIRTUAL: 'virtual';

CLASS: 'class';

NAMESPACE: 'namespace';

FRIEND: 'friend';

TYPEDEF: 'typedef';

IF: 'if';

SWITCH: 'switch';

WHILE: 'while';

DO: 'do';

FOR: 'for';

BREAK: 'break';

CONTINUE: 'continue';

RETURN: 'return';

GOTO: 'goto';

TRY: 'try';

USING: 'using';

EXPORT: 'export';

CASE: 'case';

DEFAULT: 'default';

ELSE: 'else';

CATCH: 'catch';

EXTERN: 'extern';

Estou recebendo uma exceção:

 [java] Exception in thread main java.lang.NullPointerException
 [java]     at org.antlr.v4.automata.ParserATNFactory.elemList(ParserATNFactory.java:452)
 [java]     at org.antlr.v4.automata.ParserATNFactory.alt(ParserATNFactory.java:439)
 [java]     at org.antlr.v4.parse.ATNBuilder.alternative(ATNBuilder.java:567)
 [java]     at org.antlr.v4.parse.ATNBuilder.ruleBlock(ATNBuilder.java:289)
 [java]     at org.antlr.v4.automata.ParserATNFactory._createATN(ParserATNFactory.java:177)
 [java]     at org.antlr.v4.automata.LexerATNFactory.createATN(LexerATNFactory.java:94)
 [java]     at org.antlr.v4.Tool.processNonCombinedGrammar(Tool.java:407)
 [java]     at org.antlr.v4.Tool.process(Tool.java:376)
 [java]     at org.antlr.v4.Tool.processGrammarsOnCommandLine(Tool.java:343)
 [java]     at org.antlr.v4.Tool.main(Tool.java:190)

Se alguém sabe o que é tão errado sobre a minha gramática, por favor deixe-me saber sobre isso.

Obrigado e cumprimentos, Prakhar Mishra

c++parsing antlr4

Publicado 07/12/2013 em 09:14
fonte usuário Prakhar Mishra

Em outras línguas...

3 respostas

votos

1

Isto pode soar duro, mas você está um pouco louco para tentar construir a sua própria gramática C ++, se você quiser um resultado útil.

Em primeiro lugar, obter o direito gramática é muito difícil. Você começa a descobrir o que o C ++ (98? 2011? 2014?) Padrão realmente diz, lançará no gerador de analisador (ANTLR4) termos, em seguida, descobrir o que os compiladores realmente aceitar (invariavelmente diferente, e realmente arcano). Você vai ter que lutar com parses ambíguas, que ANTLR4 tem alguma ajuda para, mas não pode resolver inteiramente sem tabelas de símbolos (ver abaixo).

Para processar programas reais, você precisará de um pré-processador completo C ++. Mesmas ressalvas.

Para fazer qualquer coisa útil com tal gramática, você vai precisar para construir tabelas de símbolos. Mesmas ressalvas, mas dez vezes mais difícil, porque você não tem qualquer sintaxe formal, apenas as palavras informais no padrão página 600 (e o comportamento em situação irregular dos compiladores reais).

Eu tenho uma pequena equipe de engenheiros que trabalham com isso e pensamos muito boas ferramentas de suporte. Temos cerca de 15 anos-homem investido e acho que temos um resultado muito bom; Eu não acho que você pode fazê-lo muito mais rápido. A equipe Clang é distribuído e, provavelmente, muito maior que a nossa.

Se você está apenas fazendo isso para fins educativos, bem, então, bem, ver a resposta de 280Z28. Esperar para ser ferido.

Respondeu 08/12/2013 em 04:26
fonte usuário Ira Baxter

votos

-1

Não é a gramática que joga. A verdadeira questão que gera a exceção é: '\ u'. Substituir com '\\ u' pára o lance NullPointerException.

linhas 605:

UNIVERSAL_CHARACTER_NAME: '\\u' HEX_QUAD

Agora, o seguinte erro e avisos. A saída após a substituição:

error(119): \CppGrammar.g4::: The following sets of rules are mutually left-recursive [DECIMAL] and [OCTAL] and [HEXADECIMAL] and [DIGIT_SEQUENCE] and [HEXADECIMAL_ESCAPE_SEQUENCE] and [C_CHAR_SEQUENCE]
warning(125): \CppGrammar.g4:5:22: implicit definition of token 'OR_OP' in parser
warning(125): \CppGrammar.g4:5:22: implicit definition of token 'AND_OP' in parser
warning(125): \CppGrammar.g4:5:22: implicit definition of token 'INC_OR_OP' in parser
warning(125): \CppGrammar.g4:5:22: implicit definition of token 'EX_OR_OP' in parser
warning(125): \CppGrammar.g4:5:22: implicit definition of token 'EQUALITY' in parser
error(119): \CppGrammar.g4::: The following sets of rules are mutually left-recursive [declSpecifierSeq]

Respondeu 24/01/2014 em 00:50
fonte usuário Rabamirezzan

Sam Harwell · Accepted Answer · 2013-12-07 21:32

À primeira vista, a sua gramática tem muitos, muitos bugs. Eu não tenho certeza o que está causando o NullPointerException, mas você definitivamente precisa para resolver estes antes de ele funciona para você.

O seguinte é uma lista incompleta de questões importantes I relativa a um primeiro olhar através da gramática.

A gramática devem ser separados de modo que todas as regras do analisador (que começam com uma letra minúscula) aparecem antes de todas as regras lexer (que começam com uma letra maiúscula).
O seu lexer nunca vai criar um PLUSsímbolo, porque a OPregra lexer corresponde +ea OPregra aparece antes da PLUSregra na gramática. Tokens são atribuídos exatamente um tipo de token, então você nunca pode ter um símbolo que é tanto OPe PLUS. Isso se aplica a muitos, se não todos, os outros itens listados na OPregra.
A INCLUDE_STATregra não permite qualquer espaço em branco para aparecer em qualquer lugar em uma #includedirectiva.
O identificador fnunca será um ID, porque a FLOAT_SUFFIXregra corresponder fe aparece antes da IDregra. Eu acredito que você significou para marcar a FLOAT_SUFFIXregra como uma fragmentregra. Este erro conceitual aparece muitas outras vezes na gramática.
A palavra-chave elsenunca será um ELSE, porque a IDregra também corresponde elsee aparece antes da ELSEregra na gramática. Este erro conceitual se aplica a cada palavra-chave listada após a IDregra na gramática.