| %{ |
| #include "actions.h" |
| #include <iostream> |
| |
| extern int yyerror(char *); |
| extern int yylex(); |
| extern int line_number, token_number; |
| extern char* yytext; |
| |
| using namespace std; |
| extern int last_seen_cv; |
| extern bool seen_const; |
| extern bool seen_volatile; |
| extern int last_seen; |
| extern int line_num_for_abs_decl; |
| %} |
| |
| |
| %union { |
| int tokenvalue; |
| expression* expression_ptr; |
| member_declarator* member_declarator_ptr; |
| param_declarator* param_declarator_ptr; |
| string* string_ptr; |
| member_declarator_list* member_declarator_list_ptr; |
| string_list* string_list_ptr; |
| base_specifier_list* base_specifier_list_ptr; |
| base_specifier* base_specifier_ptr; |
| void* any_ptr; |
| param_decl* param_decl_ptr; |
| param_decl_list* param_decl_list_ptr; |
| class_head* class_head_ptr; |
| } |
| |
| |
| /*** Keywords ***/ |
| %token KW_asm KW_do KW_inline KW_short KW_typeid |
| %token KW_auto KW_double KW_int KW_signed KW_typename |
| %token KW_bool KW_dynamic_cast KW_long KW_sizeof KW_union |
| %token KW_break KW_else KW_mutable KW_static KW_unsigned |
| %token KW_case KW_enum KW_namespace KW_static_cast KW_using |
| %token KW_catch KW_explicit KW_new KW_struct KW_virtual |
| %token KW_char KW_extern KW_operator KW_switch KW_void |
| %token KW_class KW_false KW_private KW_template KW_volatile |
| %token KW_const KW_float KW_protected KW_this KW_wchar_t |
| %token KW_const_cast KW_for KW_public KW_throw KW_while |
| %token KW_continue KW_friend KW_register KW_true |
| %token KW_default KW_goto KW_reinterpret_cast KW_try |
| %token KW_delete KW_if KW_return KW_typedef |
| %token KW_export |
| %token KW_string |
| |
| /*** Pseduo Keywords ***/ |
| |
| %token KW_unsigned_char KW_unsigned_short KW_unsigned_long KW_long_double |
| |
| /*** Literals ***/ |
| %token INTEGER_LITERAL CHARACTER_LITERAL FLOATING_LITERAL STRING_LITERAL |
| |
| /*** Axis specific ***/ |
| /* %token ACCESSBEAN_MACRO */ |
| |
| /*** Single-Character Operators ***/ |
| %token LEFTPAREN RIGHTPAREN // ( ) |
| %token LEFTBRACK RIGHTBRACK // { } |
| %token LEFTARRAY RIGHTARRAY // [ ] |
| %token PLUS MINUS STAR DIVIDE MOD // + - * / % |
| %token GREATER LESS EQUAL // > < = |
| %token AND OR NOT XOR // & | ! ^ |
| %token COMMA SEMI COLON // , ; : |
| %token COMPLEMENT DOT QUESTION // ~ . ? |
| |
| /*** Multi-Character Operators ***/ |
| %token COLCOL ELLIPSES |
| %token PLUSEQ MINUSEQ STAREQ DIVEQ MODEQ |
| %token XOREQ ANDEQ OREQ LTLT GTGT GTGTEQ LTLTEQ EQEQ NOTEQ |
| %token LEQ GEQ ANDAND OROR PLUSPLUS MINUSMINUS DOTSTAR ARROWSTAR ARROW |
| |
| |
| /*** The context-sensitive versions of IDENTIFIER ***/ |
| |
| %token IDENTIFIER |
| |
| %token ID_typedef_name |
| %token ID_enum_name ID_class_name |
| |
| %type <tokenvalue> KW_class KW_struct KW_union KW_enum KW_namespace KW_template |
| %type <tokenvalue> KW_protected KW_public KW_private |
| %type <tokenvalue> KW_typename KW_operator class_key COMMA COLON |
| %type <tokenvalue> colcol_opt ptr_operator |
| %type <tokenvalue> comma_opt virtual_opt cv_qualifier cv_qualifier_seq |
| %type <tokenvalue> cv_qualifier_seq_opt |
| |
| //%type <> CHARACTER_LITERAL FLOATING_LITERAL |
| //%type <> STRING_LITERAL |
| |
| %type <tokenvalue> access_specifier access_specifier_opt |
| //%type <> declaration block_declaration |
| //%type <> simple_declaration |
| %type <member_declarator_ptr> declarator direct_declarator |
| %type <member_declarator_ptr> member_declarator init_declarator |
| %type <param_declarator_ptr> parameter_declarator direct_parameter_declarator |
| //%type <> enumerator_definition |
| %type <param_decl_ptr> parameter_declaration |
| %type <param_decl_list_ptr> parameter_declaration_list parameter_declaration_list_opt parameter_declaration_clause |
| %type <expression_ptr> initializer initializer_opt initializer_clause assignment_expression |
| %type <tokenvalue> pure_specifier pure_specifier_opt |
| %type <expression_ptr> constant_expression constant_expression_opt |
| %type <expression_ptr> constant_initializer constant_initializer_opt |
| //%type <> initializer_list |
| %type <string_ptr> unqualified_id id_expression |
| %type <string_ptr> class_name type_name declarator_id |
| %type <string_ptr> simple_type_specifier type_specifier decl_specifier function_specifier |
| %type <ctype> type_specifier_seq |
| %type <ctype> type_specifier_seq_opt |
| %type <ctype> class_specifier |
| %type <class_head_ptr> class_head |
| %type <base_specifier_ptr> base_specifier |
| //%type <> expression_list expression_list_opt |
| |
| %type <any_ptr> member_specification member_specification_opt |
| %type <any_ptr> member_declaration |
| %type <member_declarator_list_ptr> declaration_seq declaration_seq_opt |
| %type <member_declarator_list_ptr> member_declarator_list |
| //%type <> enumerator_list enumerator_list_opt |
| %type <string_list_ptr> decl_specifier_seq decl_specifier_seq_opt |
| %type <base_specifier_list_ptr> base_clause_opt base_clause base_specifier_list |
| |
| %type <string_ptr> any_identifier |
| |
| %start translation_unit |
| |
| %% |
| |
| any_identifier |
| : ID_typedef_name {$$ = new string(yytext);} |
| //| ID_original_namespace_name {$$ = new string(yytext);} |
| //| ID_namespace_alias {$$ = new string(yytext);} |
| //| ID_enum_name {$$ = new string(yytext);} |
| | ID_class_name {$$ = new string(yytext);} |
| //| ID_template_name {$$ = new string(yytext);} |
| | IDENTIFIER {$$ = new string(yytext);} |
| ; |
| |
| //any_identifier_or_template : |
| // any_identifier {} |
| //| template_id {} |
| //; |
| |
| // ********* Context-sensitive identifiers ********** |
| // |
| // ID_typedef_name |
| // : IDENTIFIER {} |
| // ; |
| // ID_original_namespace_name |
| // : IDENTIFIER {} |
| // ; |
| |
| ID_namespace_alias |
| : IDENTIFIER { } |
| ; |
| |
| // ID_enum_name |
| // : IDENTIFIER {} |
| // ; |
| // ID_class_name |
| // : IDENTIFIER {} |
| // ; |
| |
| |
| // ********** 1.1 Keywords [gram.key] ********** |
| |
| typedef_name |
| : ID_typedef_name {} |
| ; |
| |
| namespace_name |
| : |
| // original_namespace_name {} |
| // | |
| namespace_alias { } |
| ; |
| |
| //original_namespace_name |
| // : ID_original_namespace_name {} |
| // ; |
| |
| namespace_alias |
| : ID_namespace_alias {} |
| ; |
| |
| class_name |
| : ID_class_name {$$ = new string(yytext);} |
| // | template_id {} |
| ; |
| |
| //enum_name |
| // : ID_enum_name {} |
| // ; |
| |
| //template_name |
| // : ID_template_name {} |
| // ; |
| |
| |
| // ********** 1.2 Lexical conventions [gram.lex] ********** |
| |
| |
| // ********** 1.3 Basic concepts [gram.basic] ********** |
| translation_unit |
| : { |
| translation_unit_start(); |
| } |
| declaration_seq_opt |
| {} |
| ; |
| |
| |
| // ********** 1.4 Expressions [gram.expr] ********** |
| //primary_expression |
| // : INTEGER_LITERAL {} |
| // | CHARACTER_LITERAL {} |
| // | FLOATING_LITERAL {} |
| // | STRING_LITERAL {} |
| // | KW_true {} |
| // | KW_false {} |
| // | KW_this {} |
| // | LEFTPAREN expression RIGHTPAREN {} |
| // | id_expression {} |
| //; |
| |
| id_expression |
| : unqualified_id {$$ = $1;} |
| // | qualified_id {} |
| ; |
| |
| unqualified_id |
| /* not any_identifier, cannot have :: */ |
| : IDENTIFIER {$$ = new string(yytext);} |
| | class_name {$$ = $1;} |
| // | operator_function_id {} |
| // | conversion_function_id {} |
| | COMPLEMENT class_name {$$ = $2; g_bdestructor_seen = true;} |
| // | template_id {} |
| ; |
| |
| //qualified_id |
| // : colcol_opt nested_name_specifier template_opt unqualified_id |
| // {} |
| // /* not any_identifier, must have :: */ |
| // | COLCOL IDENTIFIER {} |
| // | COLCOL operator_function_id {} |
| // | COLCOL template_id {} |
| // ; |
| |
| //nested_name_specifier |
| // : class_or_namespace_name COLCOL nested_name_specifier_opt |
| // {} |
| // | class_or_namespace_name COLCOL KW_template nested_name_specifier |
| // {} |
| //; |
| |
| //nested_name_specifier_opt |
| // : nested_name_specifier {} |
| // | /* Empty */ {} |
| // ; |
| |
| //class_or_namespace_name |
| // : class_name {} |
| // | namespace_name {} |
| // ; |
| |
| //postfix_expression |
| // : primary_expression |
| // {} |
| // | postfix_expression LEFTARRAY expression RIGHTARRAY |
| // {} |
| // | postfix_expression |
| // {} |
| // LEFTPAREN expression_list_opt RIGHTPAREN |
| // {} |
| // | simple_type_specifier LEFTPAREN expression_list_opt RIGHTPAREN |
| // {} |
| // | KW_typename colcol_opt nested_name_specifier any_identifier_or_template |
| // LEFTPAREN expression_list_opt RIGHTPAREN |
| // {} |
| // | KW_typename colcol_opt nested_name_specifier template_opt template_id |
| // LEFTPAREN expression_list_opt RIGHTPAREN |
| // {} |
| // | postfix_expression DOT template_opt id_expression |
| // {} |
| // | postfix_expression ARROW template_opt id_expression |
| // {} |
| // | postfix_expression DOT pseudo_destructor_name |
| // {} |
| // | postfix_expression ARROW pseudo_destructor_name |
| // {} |
| // | postfix_expression PLUSPLUS |
| // {} |
| // | postfix_expression MINUSMINUS |
| // {} |
| // | KW_dynamic_cast LESS type_id GREATER LEFTPAREN expression RIGHTPAREN |
| // {} |
| // | KW_static_cast LESS type_id GREATER LEFTPAREN expression RIGHTPAREN |
| // {} |
| // | KW_reinterpret_cast LESS type_id GREATER LEFTPAREN expression RIGHTPAREN |
| // {} |
| // | KW_const_cast LESS type_id GREATER LEFTPAREN expression RIGHTPAREN |
| // {} |
| // | KW_typeid LEFTPAREN expression RIGHTPAREN |
| // {} |
| // | KW_typeid LEFTPAREN type_id RIGHTPAREN |
| // {} |
| // ; |
| |
| expression_list |
| : assignment_expression |
| {} |
| | expression_list COMMA assignment_expression |
| {} |
| ; |
| |
| //expression_list_opt |
| // : expression_list {} |
| // | /* Empty */ {} |
| // ; |
| |
| //pseudo_destructor_name |
| // : colcol_opt nested_name_specifier_opt type_name COLCOL COMPLEMENT type_name |
| // {} |
| // | colcol_opt nested_name_specifier KW_template template_id COLCOL |
| // COMPLEMENT type_name |
| // {} |
| // | colcol_opt nested_name_specifier_opt COMPLEMENT type_name |
| // {} |
| // ; |
| |
| //unary_expression |
| // : postfix_expression |
| // {} |
| // | PLUSPLUS cast_expression |
| // {} |
| // | MINUSMINUS cast_expression |
| // {} |
| // | STAR cast_expression |
| // {} |
| // | AND cast_expression |
| // {} |
| // | PLUS cast_expression |
| // {} |
| // | MINUS cast_expression |
| // {} |
| // | NOT cast_expression |
| // {} |
| // | COMPLEMENT cast_expression |
| // {} |
| // | KW_sizeof unary_expression |
| // {} |
| // | KW_sizeof LEFTPAREN type_id RIGHTPAREN |
| // {} |
| // | new_expression |
| // {} |
| // | delete_expression |
| // {} |
| // ; |
| |
| //new_expression |
| // : colcol_opt KW_new new_placement_opt new_type_id new_initializer_opt |
| // {} |
| // | colcol_opt KW_new new_placement_opt LEFTPAREN type_id RIGHTPAREN |
| // new_initializer_opt |
| // {} |
| // ; |
| |
| //new_placement |
| // : LEFTPAREN expression_list RIGHTPAREN {} |
| // ; |
| |
| //new_placement_opt |
| // : new_placement {} |
| // | /* Empty */ {/*$$ = NULL; */} |
| // ; |
| |
| //new_type_id |
| // : type_specifier_seq new_declarator_opt |
| // {} |
| // ; |
| |
| //new_declarator |
| // : ptr_operator new_declarator_opt |
| // {} |
| // | direct_new_declarator |
| // {} |
| // ; |
| |
| //new_declarator_opt |
| // : new_declarator {} |
| // | /* Empty */ {} |
| // ; |
| |
| //direct_new_declarator |
| // : LEFTARRAY expression RIGHTARRAY |
| // {} |
| // | direct_new_declarator LEFTARRAY constant_expression RIGHTARRAY |
| // {} |
| // ; |
| |
| //new_initializer |
| // : LEFTPAREN expression_list_opt RIGHTPAREN {} |
| // ; |
| |
| //new_initializer_opt |
| // : new_initializer {} |
| // | /* Empty */ {} |
| // ; |
| |
| //delete_expression |
| // : colcol_opt KW_delete cast_expression |
| // {} |
| // | colcol_opt KW_delete LEFTARRAY RIGHTARRAY cast_expression |
| // {} |
| // ; |
| |
| //cast_expression |
| // : unary_expression {} |
| // | LEFTPAREN type_id RIGHTPAREN cast_expression |
| // {} |
| // ; |
| |
| //pm_expression |
| // : cast_expression {} |
| // | pm_expression DOTSTAR cast_expression |
| // {} |
| // | pm_expression ARROWSTAR cast_expression |
| // {} |
| // ; |
| |
| //multiplicative_expression |
| // : pm_expression {} |
| // | multiplicative_expression STAR pm_expression |
| // {} |
| // | multiplicative_expression DIVIDE pm_expression |
| // {} |
| // | multiplicative_expression MOD pm_expression |
| // {} |
| // ; |
| |
| //additive_expression |
| // : multiplicative_expression {} |
| // | additive_expression PLUS multiplicative_expression |
| // {} |
| // | additive_expression MINUS multiplicative_expression |
| // {} |
| // ; |
| |
| //shift_expression |
| // : additive_expression {} |
| // | shift_expression LTLT additive_expression |
| // {} |
| // | shift_expression GTGT additive_expression |
| // {} |
| // ; |
| |
| //relational_expression |
| // : shift_expression {} |
| // | relational_expression LESS shift_expression |
| // {} |
| // | relational_expression GREATER shift_expression |
| // {} |
| // | relational_expression LEQ shift_expression |
| // {} |
| // | relational_expression GEQ shift_expression |
| // {} |
| // ; |
| |
| //equality_expression |
| // : relational_expression {} |
| // | equality_expression EQEQ relational_expression |
| // {} |
| // | equality_expression NOTEQ relational_expression |
| // {} |
| // ; |
| |
| //and_expression |
| // : equality_expression {} |
| // | and_expression AND equality_expression |
| // {} |
| // ; |
| |
| //exclusive_or_expression |
| // : and_expression {} |
| // | exclusive_or_expression XOR and_expression |
| // {} |
| // ; |
| |
| //inclusive_or_expression |
| // : exclusive_or_expression {} |
| // | inclusive_or_expression OR exclusive_or_expression |
| // {} |
| // ; |
| |
| //logical_and_expression |
| // : inclusive_or_expression {} |
| // | logical_and_expression ANDAND inclusive_or_expression |
| // {} |
| // ; |
| |
| //logical_or_expression |
| // : logical_and_expression {} |
| // | logical_or_expression OROR logical_and_expression |
| // {} |
| // ; |
| |
| //conditional_expression |
| // : logical_or_expression {} |
| // | logical_or_expression QUESTION expression COLON assignment_expression |
| // {} |
| // ; |
| |
| assignment_expression |
| : INTEGER_LITERAL |
| { |
| $$ = new expression; |
| $$->expr.n = atoi(yytext); |
| } |
| // conditional_expression {} |
| // | logical_or_expression assignment_operator assignment_expression |
| // {} |
| // | throw_expression {} |
| ; |
| |
| //assignment_operator |
| // : EQUAL {} |
| // | STAREQ {} |
| // | DIVEQ {} |
| // | MODEQ {} |
| // | PLUSEQ {} |
| // | MINUSEQ {} |
| // | GTGTEQ {} |
| // | LTLTEQ {} |
| // | ANDEQ {} |
| // | XOREQ {} |
| // | OREQ {} |
| // ; |
| |
| //expression |
| // : assignment_expression {} |
| // | expression COMMA assignment_expression |
| // {} |
| // ; |
| |
| //expression_opt |
| // : expression {} |
| // | /* Empty */ {} |
| // ; |
| |
| constant_expression |
| : INTEGER_LITERAL |
| { |
| $$ = new expression; |
| $$->expr.n = atoi(yytext); |
| } |
| ; |
| |
| constant_expression_opt |
| : constant_expression {$$ = $1;} |
| | /* Empty */ {$$ = NULL;} |
| ; |
| |
| |
| // ********** 1.5 Statements [gram.stmt.stmt] ********** |
| //statement |
| // : labeled_statement {} |
| // | expression_statement {} |
| // | compound_statement {} |
| // | selection_statement {} |
| // | iteration_statement {} |
| // | jump_statement {} |
| // | declaration_statement {} |
| // | try_block {} |
| // ; |
| |
| //labeled_statement |
| // : any_identifier COLON statement |
| // {} |
| // | KW_case constant_expression COLON statement |
| // {} |
| // | KW_default COLON statement |
| // {} |
| // ; |
| |
| //expression_statement |
| // : expression SEMI {} |
| // // Was expression_opt, but this is covered by simple_declaration |
| // ; |
| |
| //compound_statement |
| // : LEFTBRACK |
| // {} |
| // statement_seq_opt |
| // RIGHTBRACK |
| // {} |
| // ; |
| |
| //statement_seq |
| // : statement |
| // {} |
| // | statement_seq statement |
| // {} |
| // ; |
| |
| //statement_seq_opt |
| // : statement_seq {} |
| // | /* Empty */ {} |
| // ; |
| |
| //selection_statement |
| // : KW_if LEFTPAREN condition RIGHTPAREN statement |
| // {} |
| // | KW_if LEFTPAREN condition RIGHTPAREN statement KW_else statement |
| // {} |
| // | KW_switch LEFTPAREN condition RIGHTPAREN statement |
| // {} |
| // ; |
| |
| //condition |
| // : expression {} |
| // | type_specifier_seq declarator EQUAL assignment_expression |
| // {} |
| // ; |
| |
| //condition_opt |
| // : condition {} |
| // | /* Empty */ {} |
| // ; |
| |
| //iteration_statement |
| // : KW_while LEFTPAREN condition RIGHTPAREN statement |
| // {} |
| // | KW_do statement KW_while LEFTPAREN expression RIGHTPAREN SEMI |
| // {} |
| // | KW_for LEFTPAREN for_init_statement condition_opt SEMI |
| // expression_opt RIGHTPAREN statement |
| // {} |
| // ; |
| |
| //for_init_statement |
| // : expression_statement {} |
| // | simple_declaration {} |
| // ; |
| |
| //jump_statement |
| // : KW_break SEMI |
| // {} |
| // | KW_continue SEMI |
| // {} |
| // | KW_return expression_opt SEMI |
| // {} |
| // | KW_goto any_identifier SEMI |
| // {} |
| // ; |
| |
| //declaration_statement |
| // : block_declaration {} |
| // ; |
| |
| |
| // ********** 1.6 Declarations [gram.dcl.dcl] ********** |
| |
| declaration_seq |
| : declaration |
| {} |
| | declaration_seq declaration |
| {} |
| ; |
| |
| declaration_seq_opt |
| : declaration_seq {} |
| | /* Empty */ {} |
| ; |
| |
| declaration |
| : block_declaration |
| {} |
| // | function_definition |
| // {} |
| // | template_declaration |
| // {} |
| // | explicit_instantiation |
| // {} |
| // | explicit_specialization |
| // {} |
| // | linkage_specification |
| // {} |
| // | namespace_definition |
| // {} |
| ; |
| |
| block_declaration |
| : simple_declaration |
| {} |
| // | asm_definition |
| // {/* $$ = NULL;/*XXX*/ } |
| // | namespace_alias_definition |
| // {} |
| // | using_declaration |
| // {} |
| | using_directive |
| { } |
| ; |
| |
| simple_declaration |
| : decl_specifier_seq_opt |
| init_declarator_list_opt // there can be global variable or extern declarations - Susantha. |
| SEMI |
| {} |
| ; |
| |
| decl_specifier |
| : |
| // storage_class_specifier |
| // {} |
| // | |
| type_specifier |
| {} |
| | function_specifier |
| { $$ = $1;} |
| // | KW_friend |
| // {} |
| // | KW_typedef |
| // {} |
| ; |
| |
| decl_specifier_seq |
| : decl_specifier_seq_opt decl_specifier |
| { |
| if ($2 != NULL) |
| { |
| if ($$ == NULL) {$$ = new string_list;} |
| $$->push_back($2); |
| } |
| else |
| { |
| $$ = NULL; |
| } |
| } |
| ; |
| |
| decl_specifier_seq_opt |
| : decl_specifier_seq |
| {$$ = $1;} |
| | /* Empty */ |
| {$$ = NULL;} |
| ; |
| |
| //storage_class_specifier |
| // : KW_auto |
| // {} |
| // | KW_register |
| // {} |
| // | KW_static |
| // {} |
| // | KW_extern |
| // {} |
| // | KW_mutable |
| // {} |
| // ; |
| |
| function_specifier |
| : |
| // KW_inline |
| // {} |
| // | |
| KW_virtual |
| { $$ = NULL;} |
| // | KW_explicit |
| // {} |
| ; |
| |
| |
| type_specifier |
| : simple_type_specifier |
| {$$ = $1;} |
| | class_specifier |
| {} |
| // | enum_specifier |
| // {} |
| // | elaborated_type_specifier |
| // {} |
| | cv_qualifier |
| {} |
| ; |
| |
| /***** Multi word types ********/ |
| simple_type_specifier |
| : |
| // colcol_opt nested_name_specifier_opt |
| type_name |
| {$$ = $1;} |
| // | colcol_opt nested_name_specifier KW_template template_id |
| // {} |
| // | |
| | KW_char |
| {$$ = new string("char");} |
| | KW_unsigned_char |
| {$$ = new string("unsigned char");} |
| | KW_wchar_t |
| {$$ = new string("wchar_t");} |
| | KW_bool |
| {$$ = new string("bool");} |
| | KW_short |
| {$$ = new string("short");} |
| | KW_unsigned_short |
| {$$ = new string("unsigned short");} |
| | KW_int |
| {$$ = new string("int");} |
| | KW_long |
| {$$ = new string("long");} |
| | KW_unsigned_long |
| {$$ = new string("unsigned long");} |
| | KW_signed |
| {$$ = new string("signed");} |
| | KW_unsigned |
| {$$ = new string("unsigned");} |
| | KW_float |
| {$$ = new string("float");} |
| | KW_double |
| {$$ = new string("double");} |
| | KW_void |
| {$$ = new string("void");} |
| | KW_string |
| {$$ = new string("string");} |
| ; |
| |
| type_name |
| : class_name {$$ = $1;} |
| // | enum_name {} |
| // | typedef_name {} |
| ; |
| |
| //elaborated_type_specifier |
| // : class_key colcol_opt nested_name_specifier_opt any_identifier_or_template |
| // {} |
| // | KW_enum colcol_opt nested_name_specifier_opt any_identifier |
| // {} |
| // | KW_typename colcol_opt nested_name_specifier any_identifier |
| // {} |
| // | KW_typename colcol_opt nested_name_specifier template_opt template_id |
| // {} |
| // ; |
| |
| //enum_specifier |
| // : KW_enum identifier_opt |
| // {} |
| // LEFTBRACK enumerator_list_opt RIGHTBRACK |
| // {} |
| // ; |
| |
| |
| //enumerator_list |
| // : enumerator_definition |
| // {} |
| // | enumerator_list COMMA enumerator_definition |
| // {} |
| // ; |
| |
| //enumerator_list_opt |
| // : enumerator_list {} |
| // | /* Empty */ {} |
| // ; |
| |
| //enumerator_definition |
| // : enumerator |
| // {} |
| // | enumerator EQUAL constant_expression |
| // {} |
| // ; |
| |
| //enumerator |
| // : any_identifier {} |
| // ; |
| |
| |
| //namespace_definition |
| // : named_namespace_definition {} |
| // | unnamed_namespace_definition {} |
| // ; |
| |
| |
| //named_namespace_definition |
| // : original_namespace_definition {} |
| // | extension_namespace_definition {} |
| // ; |
| |
| |
| //original_namespace_definition |
| // : KW_namespace any_identifier |
| // {} |
| // LEFTBRACK namespace_body RIGHTBRACK |
| // {} |
| // ; |
| |
| |
| //extension_namespace_definition |
| // : KW_namespace original_namespace_name |
| // {} |
| // LEFTBRACK namespace_body RIGHTBRACK |
| // {} |
| // ; |
| |
| |
| //unnamed_namespace_definition |
| // : KW_namespace |
| // {} |
| // LEFTBRACK namespace_body RIGHTBRACK |
| // {} |
| // ; |
| |
| |
| //namespace_body |
| // : declaration_seq_opt {} |
| // ; |
| |
| |
| //namespace_alias_definition |
| // : KW_namespace any_identifier EQUAL qualified_namespace_specifier SEMI |
| // {} |
| // ; |
| |
| |
| //qualified_namespace_specifier |
| // : colcol_opt nested_name_specifier_opt namespace_name |
| // {/* $$ = $3; */} |
| // ; |
| |
| //using_declaration |
| // : KW_using KW_typename colcol_opt nested_name_specifier any_unqualified_id |
| // SEMI |
| // {} |
| // | KW_using colcol_opt nested_name_specifier any_unqualified_id |
| // SEMI |
| // {} |
| // | KW_using COLCOL any_unqualified_id |
| // SEMI |
| // {} |
| // ; |
| |
| using_directive |
| : KW_using KW_namespace |
| //colcol_opt nested_name_specifier_opt |
| namespace_name |
| SEMI |
| { } |
| ; |
| |
| //asm_definition |
| // : KW_asm LEFTPAREN STRING_LITERAL RIGHTPAREN SEMI |
| // {} |
| // ; |
| |
| //linkage_specification |
| // : KW_extern STRING_LITERAL LEFTBRACK declaration_seq_opt RIGHTBRACK |
| // {} |
| // | KW_extern STRING_LITERAL declaration |
| // {} |
| // ; |
| |
| |
| |
| // ********** 1.7 Declarators [gram.dcl.decl] ********** |
| |
| init_declarator_list |
| : init_declarator |
| {} |
| | init_declarator_list |
| COMMA init_declarator |
| {} |
| ; |
| |
| init_declarator_list_opt |
| : init_declarator_list {} |
| | /* Empty */ {} |
| ; |
| |
| init_declarator |
| : declarator initializer_opt |
| {} |
| ; |
| |
| parameter_declarator |
| : direct_parameter_declarator |
| {$$=$1;} |
| | ptr_operator |
| parameter_declarator |
| { |
| $$=$2; |
| $$->ptr_ops.push_back($1); |
| } |
| ; |
| |
| direct_parameter_declarator |
| : declarator_id |
| { |
| $$ = new param_declarator; |
| $$->decl_id = $1->c_str(); |
| } |
| | direct_parameter_declarator LEFTARRAY constant_expression_opt RIGHTARRAY |
| { |
| $$ = $1; |
| if ($3 != 0) |
| { |
| $$->arr_dim.push_back($3); |
| } |
| } |
| ; |
| |
| declarator |
| : direct_declarator |
| {$$ = $1;} |
| | ptr_operator |
| declarator |
| { |
| $$ = $2; |
| $$->ptr_ops.push_back($1); |
| } |
| ; |
| |
| direct_declarator |
| : declarator_id |
| { |
| $$ = new member_declarator; |
| $$->method = false; |
| $$->declarator_id = $1; |
| } |
| | direct_declarator |
| LEFTPAREN |
| parameter_declaration_clause RIGHTPAREN |
| // cv_qualifier_seq_opt |
| // exception_specification_opt |
| { |
| $$->params = $3; |
| $$->method = true; |
| } |
| | direct_declarator LEFTARRAY constant_expression_opt RIGHTARRAY |
| { |
| $$->array_indexes.push_back($3); |
| } |
| // | LEFTPAREN declarator RIGHTPAREN |
| // {} |
| ; |
| |
| ptr_operator |
| : STAR cv_qualifier_seq_opt |
| {$$ = STAR;} |
| | AND |
| {$$ = AND;} |
| // | colcol_opt nested_name_specifier STAR cv_qualifier_seq_opt |
| // {} |
| ; |
| |
| cv_qualifier_seq |
| : cv_qualifier cv_qualifier_seq_opt {/* $$ = $1 + $2; */} |
| ; |
| |
| cv_qualifier_seq_opt |
| : cv_qualifier_seq {} |
| | /* Empty */ {/* $$ = 0; */} |
| ; |
| |
| cv_qualifier |
| : KW_const |
| { |
| } |
| // | KW_volatile |
| // {} |
| ; |
| |
| declarator_id |
| : id_expression |
| {$$ = $1;} |
| // | colcol_opt nested_name_specifier_opt type_name |
| // {/* $$ = $3; */} |
| ; |
| |
| //type_id |
| // : type_specifier_seq abstract_declarator_opt |
| // {} |
| // ; |
| |
| type_specifier_seq_opt |
| : type_specifier_seq {} |
| | /* Empty */ {} |
| ; |
| |
| type_specifier_seq |
| : type_specifier type_specifier_seq_opt |
| {} |
| ; |
| |
| //abstract_declarator |
| // : ptr_operator abstract_declarator_opt |
| // {} |
| // | direct_abstract_declarator {} |
| // ; |
| |
| //abstract_declarator_opt |
| //: abstract_declarator {} |
| // | /* Empty */ {} |
| // ; |
| |
| //direct_abstract_declarator |
| // : direct_abstract_declarator_opt LEFTPAREN |
| // {} |
| // parameter_declaration_clause RIGHTPAREN cv_qualifier_seq_opt |
| // exception_specification_opt |
| // {} |
| // | direct_abstract_declarator_opt LEFTARRAY constant_expression_opt RIGHTARRAY |
| // {} |
| // | LEFTPAREN abstract_declarator RIGHTPAREN |
| // {} |
| // ; |
| |
| //direct_abstract_declarator_opt |
| // : direct_abstract_declarator {} |
| // | /* Empty */ {} |
| // ; |
| |
| parameter_declaration_clause |
| : parameter_declaration_list_opt |
| // ellipses_opt //we probably never support this - Susantha |
| {$$ = $1;} |
| // | parameter_declaration_list COMMA ELLIPSES |
| //{} |
| ; |
| |
| ellipses_opt |
| : ELLIPSES {} |
| | /* Empty */ {} |
| ; |
| |
| parameter_declaration_list_opt |
| : parameter_declaration_list {} |
| | /* Empty */ {$$ = NULL;} |
| ; |
| |
| parameter_declaration_list |
| : parameter_declaration |
| { |
| $$ = new param_decl_list; |
| $$->push_back($1); |
| } |
| | parameter_declaration_list COMMA parameter_declaration |
| { |
| $$ = $1; |
| $$->push_back($3); |
| } |
| ; |
| |
| parameter_declaration |
| : decl_specifier_seq parameter_declarator |
| { |
| $$ = new param_decl; |
| $$->decl_specs = $1; |
| $$->param = $2; |
| $$->bdef = false; |
| } |
| | decl_specifier_seq parameter_declarator EQUAL assignment_expression |
| { |
| $$ = new param_decl; |
| $$->decl_specs = $1; |
| $$->param = $2; |
| $$->bdef = true; |
| $$->defval = $4; |
| } |
| // | decl_specifier_seq abstract_declarator_opt |
| // {} |
| // | decl_specifier_seq abstract_declarator_opt EQUAL assignment_expression |
| // {} |
| ; |
| |
| //function_definition |
| // : decl_specifier_seq_opt |
| // declarator |
| // {} |
| // ctor_initializer_opt |
| // {} |
| // function_body |
| // {} |
| // | decl_specifier_seq_opt |
| // declarator |
| // {} |
| // function_try_block |
| // {} |
| // ; |
| |
| //function_body |
| // : compound_statement {/*$$ = $1; */} |
| // ; |
| |
| initializer |
| : EQUAL initializer_clause |
| {} |
| | LEFTPAREN expression_list RIGHTPAREN |
| {} |
| ; |
| |
| initializer_opt |
| : initializer |
| {} |
| | /* Empty */ {} |
| ; |
| |
| initializer_clause |
| : assignment_expression {} |
| | LEFTBRACK initializer_list comma_opt RIGHTBRACK |
| {/* $$ = $3; */} |
| | LEFTBRACK RIGHTBRACK {} |
| ; |
| |
| comma_opt |
| : COMMA {/* $$ = 1; */} |
| | /* Empty */ {/* $$ = 0; */} |
| ; |
| |
| initializer_list |
| : initializer_clause |
| {} |
| | initializer_list COMMA initializer_clause |
| {} |
| ; |
| |
| /********** 1.8 Classes [gram.class] **********/ |
| class_specifier |
| : class_head |
| //add to defined classes list |
| { |
| if (!is_defined_class($1->class_name->c_str())) |
| { |
| //check if this class should be wrapped or not depending on wsdd information |
| if (!is_webservice_class($1->class_name->c_str())) //bean class |
| { |
| BeanClass* pBeanClass = new BeanClass(); |
| pBeanClass->SetClassName(*($1->class_name)); |
| g_pTranslationUnit->AddBeanClass(pBeanClass); |
| g_pCurrentBeanClass = pBeanClass; |
| g_currentclasstype = BEANCLASS; |
| // g_baccessbeanmacrofound = false; |
| //following line adds default namespace for this complex type. |
| //This should be removed when we get the namespace from the wsdd. |
| string defns = "http://www.opensource.lk/" + (*($1->class_name)); |
| g_ClassNamespaces[*($1->class_name)] = defns; |
| } |
| else // this is the webservice class - there cannot be 2 web service classes |
| { |
| WSClass* pWSClass = new WSClass(); |
| pWSClass->SetClassName(*($1->class_name)); |
| g_pTranslationUnit->SetWSClass(pWSClass); |
| g_pCurrentWSClass = pWSClass; |
| g_currentclasstype = WSCLASS; |
| // g_baccessbeanmacrofound = false; |
| //following line adds default namespace for this web service. |
| //This should be removed when we get the namespace from the wsdd. |
| string defns = "http://www.opensource.lk/" + (*($1->class_name)); |
| g_ClassNamespaces[*($1->class_name)] = defns; |
| } |
| g_classesfound.push_back(g_classname); |
| } |
| } |
| LEFTBRACK member_specification_opt RIGHTBRACK |
| { |
| g_classname = ""; //end of class scope |
| } |
| ; |
| |
| class_head |
| : class_key any_identifier |
| base_clause_opt |
| { |
| g_classname = $2->c_str(); |
| $$ = new class_head; |
| $$->class_name = $2; |
| $$->baselist = $3; //may be NULL |
| } |
| // | class_key nested_name_specifier any_identifier |
| // {} |
| // base_clause_opt {} |
| // | class_key nested_name_specifier_opt template_id |
| // {} |
| // base_clause_opt {} |
| ; |
| |
| class_key |
| : KW_class {} |
| // We dont support structs and unions for the moment - Susantha. |
| // | KW_struct {} |
| // | KW_union {} |
| ; |
| |
| member_specification |
| : member_declaration member_specification_opt |
| {} |
| | access_specifier |
| COLON member_specification_opt |
| {} |
| ; |
| |
| member_specification_opt |
| : member_specification {} |
| | /* Empty */ {} |
| ; |
| |
| member_declaration |
| : { g_bdestructor_seen = false;} |
| decl_specifier_seq_opt |
| member_declarator_list |
| SEMI |
| { |
| add_member_declaration($2, $3); |
| } |
| // | function_definition |
| // {} |
| // semi_opt |
| // | colcol_opt nested_name_specifier template_opt unqualified_id SEMI |
| // {} |
| // | using_declaration |
| // {} |
| // | template_declaration |
| // {} |
| // ************** Axis Specific ************* |
| // | ACCESSBEAN_MACRO |
| // { g_baccessbeanmacrofound = true;} |
| ; |
| |
| semi_opt |
| : SEMI |
| | |
| ; |
| |
| member_declarator_list |
| : member_declarator |
| { |
| $$ = new member_declarator_list; |
| $$->push_back($1); |
| } |
| | member_declarator_list COMMA member_declarator |
| { |
| $$ = $1; |
| $$->push_back($3); |
| } |
| ; |
| |
| //member_declarator_list_opt |
| // : member_declarator_list {} |
| // | /* Empty */ {} |
| // ; |
| |
| member_declarator |
| : declarator pure_specifier_opt |
| { |
| $$ = $1; |
| if ($1 != 0) //there is a pure specifier |
| { |
| $$->bpure = true; |
| } |
| } |
| | declarator constant_initializer_opt |
| { |
| $$ = $1; |
| if ($2 != NULL) |
| { |
| $$->expr = $2; |
| } |
| } |
| // | identifier_opt COLON constant_expression |
| // {} |
| ; |
| |
| pure_specifier |
| : EQUAL INTEGER_LITERAL /* Should be "0" */ |
| {$$ = 1;} |
| ; |
| |
| pure_specifier_opt |
| : pure_specifier {$$ = $1;} |
| | /* Empty */ {$$ = 0;} |
| ; |
| |
| constant_initializer |
| : EQUAL constant_expression |
| {$$ = $2;} |
| ; |
| |
| constant_initializer_opt |
| : constant_initializer {$$ = $1;} |
| | /* Empty */ {$$ = NULL;} |
| ; |
| |
| /********** 1.9 Derived classes [gram.class.derived] **********/ |
| base_clause_opt |
| : base_clause {$$ = $1;} |
| | /* Empty */ {$$ = NULL;} |
| ; |
| |
| base_clause |
| : COLON base_specifier_list {$$ = $2;} |
| ; |
| |
| base_specifier_list |
| : base_specifier |
| { |
| $$ = new base_specifier_list; |
| $$->push_back($1); |
| } |
| | base_specifier_list COMMA base_specifier |
| { |
| $$->push_back($3); |
| } |
| ; |
| |
| base_specifier |
| : |
| // colcol_opt nested_name_specifier_opt class_name |
| // {} |
| // | KW_virtual access_specifier_opt colcol_opt nested_name_specifier_opt |
| // class_name |
| // {} |
| // | |
| access_specifier |
| // virtual_opt colcol_opt nested_name_specifier_opt |
| class_name |
| { |
| $$ = new base_specifier; |
| $$->access = $1; |
| $$->class_name = $2; |
| } |
| ; |
| |
| virtual_opt |
| : KW_virtual {/*$$ = 1; */} |
| | /* Empty */ {/* $$ = 0; */} |
| ; |
| |
| access_specifier |
| : KW_public |
| {$$ = $1; g_currentaccessspecifier = $1;} |
| | KW_protected |
| {$$ = $1; g_currentaccessspecifier = $1;} |
| | KW_private |
| {$$ = $1; g_currentaccessspecifier = $1;} |
| ; |
| |
| access_specifier_opt |
| : access_specifier |
| {$$=$1;} |
| | /* Empty */ {$$ = 0;} |
| ; |
| |
| /********** 1.10 Special member functions [gram.special] **********/ |
| //conversion_function_id |
| // : KW_operator conversion_type_id |
| // {} |
| // ; |
| |
| //conversion_type_id |
| // : type_specifier_seq conversion_declarator_opt |
| // {} |
| // ; |
| |
| //conversion_declarator |
| // : ptr_operator conversion_declarator_opt |
| // {} |
| // ; |
| |
| //conversion_declarator_opt |
| // : conversion_declarator {} |
| // | /* Empty */ {} |
| // ; |
| |
| //ctor_initializer |
| // : COLON mem_initializer_list |
| // {} |
| // ; |
| |
| //ctor_initializer_opt |
| // : ctor_initializer {} |
| // | /* Empty */ {} |
| // ; |
| |
| //mem_initializer_list |
| // : mem_initializer |
| // {} |
| // | mem_initializer COMMA mem_initializer_list |
| // {} |
| // ; |
| //mem_initializer |
| // : mem_initializer_id LEFTPAREN expression_list_opt RIGHTPAREN |
| // {} |
| // ; |
| |
| //mem_initializer_id |
| // : colcol_opt nested_name_specifier_opt class_name |
| // {} |
| // | any_identifier |
| // {} |
| // ; |
| |
| colcol_opt |
| : COLCOL {} |
| | /* Empty */ {} |
| ; |
| |
| |
| // ********** 1.11 Overloading [gram.over] ********** |
| //operator_function_id |
| // : KW_operator an_operator |
| // {} |
| // ; |
| |
| //an_operator |
| // : KW_new {/* $$ = new string("new"); */} |
| // | KW_delete {/* $$ = new string("delete"); */} |
| // | KW_new LEFTARRAY RIGHTARRAY {/* $$ = new string("new[]"); */} |
| // | KW_delete LEFTARRAY RIGHTARRAY {/* $$ = new string("delete[]"); */} |
| // | PLUS {/* $$ = new string("+"); */} |
| // | MINUS {/* $$ = new string("-"); */} |
| // | STAR {/* $$ = new string("*"); */} |
| // | DIVIDE {/* $$ = new string("/"); */} |
| // | MOD {/* $$ = new string("%"); */} |
| // | XOR {/* $$ = new string("^"); */} |
| // | AND {/* $$ = new string("&"); */} |
| // | OR {/* $$ = new string("|"); */} |
| // | COMPLEMENT {/* $$ = new string("~"); */} |
| // | NOT {/* $$ = new string("!"); */} |
| // | EQUAL {/* $$ = new string("="); */} |
| // | LESS {/* $$ = new string("<"); */} |
| // | GREATER {/* $$ = new string(">"); */} |
| // | PLUSEQ {/* $$ = new string("+="); */} |
| // | MINUSEQ {/* $$ = new string("-="); */} |
| // | STAREQ {/* $$ = new string("*="); */} |
| // | DIVEQ {/* $$ = new string("/="); */} |
| // | MODEQ {/* $$ = new string("%="); */} |
| // | XOREQ {/* $$ = new string("^="); */} |
| // | ANDEQ {/* $$ = new string("&="); */} |
| // | OREQ {/* $$ = new string("|="); */} |
| // | LTLT {/* $$ = new string("<<"); */} |
| // | GTGT {/* $$ = new string(">>"); */} |
| // | GTGTEQ {/* $$ = new string(">>="); */} |
| // | LTLTEQ {/* $$ = new string("<<="); */} |
| // | EQEQ {/* $$ = new string("=="); */} |
| // | NOTEQ {/* $$ = new string("!="); */} |
| // | LEQ {/* $$ = new string("<="); */} |
| // | GEQ {/* $$ = new string(">="); */} |
| // | ANDAND {/* $$ = new string("&&"); */} |
| // | OROR {/* $$ = new string("||"); */} |
| // | PLUSPLUS {/* $$ = new string("++"); */} |
| // | MINUSMINUS {/* $$ = new string("--"); */} |
| // | COMMA {/* $$ = new string(","); */} |
| // | ARROWSTAR {/* $$ = new string("->*"); */} |
| // | ARROW {/* $$ = new string("->"); */} |
| // | LEFTPAREN RIGHTPAREN {/* $$ = new string("()"); */} |
| // | LEFTARRAY RIGHTARRAY {/* $$ = new string("[]"); */} |
| // ; |
| |
| |
| // ********** 1.12 Templates [gram.temp] ********** |
| //template_declaration |
| // : export_opt KW_template LESS |
| // {} |
| // template_parameter_list GREATER |
| // {} |
| // declaration |
| // {} |
| // ; |
| |
| //export_opt |
| //: KW_export {} |
| //| /* Empty */ {} |
| // ; |
| |
| //template_parameter_list |
| // : template_parameter |
| // {} |
| // | template_parameter_list COMMA template_parameter |
| // {} |
| // ; |
| |
| //template_parameter |
| // : type_parameter {} |
| // | parameter_declaration |
| // {} |
| // ; |
| |
| //template_opt |
| //: KW_template {} |
| //| /* Empty */ {} |
| // ; |
| |
| //type_parameter |
| // : KW_class identifier_opt |
| // {} |
| // | KW_class identifier_opt EQUAL type_id |
| // {} |
| // | KW_typename identifier_opt |
| // {} |
| // | KW_typename identifier_opt EQUAL type_id |
| // {} |
| // | KW_template LESS template_parameter_list GREATER KW_class identifier_opt |
| // {} |
| // | KW_template LESS template_parameter_list GREATER KW_class |
| // identifier_opt EQUAL any_id_expression |
| // {} |
| // ; |
| |
| identifier_opt |
| : any_identifier |
| {} |
| | /* Empty */ {} |
| ; |
| |
| //template_id |
| // : template_name LESS |
| // template_argument_list_opt GREATER |
| // {} |
| // ; |
| |
| |
| //template_argument_list |
| // : template_argument |
| // {} |
| // | template_argument_list COMMA template_argument |
| // {} |
| // ; |
| |
| //template_argument_list_opt |
| // : template_argument_list {} |
| // | /* Empty */ {} |
| // ; |
| |
| //template_argument |
| // : assignment_expression {} |
| // | type_id {} |
| // | id_expression {} |
| // ; |
| |
| //explicit_instantiation |
| // : KW_template declaration {} |
| // ; |
| |
| //explicit_specialization |
| // : KW_template LESS GREATER declaration {} |
| // ; |
| |
| |
| // ********** 1.13 Exception handling [gram.except] ********** |
| //try_block |
| // : KW_try compound_statement handler_seq |
| // {} |
| // ; |
| |
| // |
| // : KW_try ctor_initializer_opt function_body handler_seq |
| // {} |
| // ; |
| |
| //handler_seq |
| // : handler handler_seq_opt |
| // {} |
| // ; |
| |
| //handler_seq_opt |
| // : handler_seq {} |
| // | /* Empty */ {} |
| // ; |
| |
| //handler |
| // : KW_catch LEFTPAREN exception_declaration RIGHTPAREN compound_statement |
| // {} |
| // ; |
| |
| //exception_declaration |
| // : type_specifier_seq declarator |
| // {} |
| // | type_specifier_seq abstract_declarator |
| // {} |
| // | type_specifier_seq |
| // {} |
| // | ELLIPSES |
| // {} |
| // ; |
| |
| //throw_expression |
| //: KW_throw assignment_expression_opt |
| // {} |
| // ; |
| |
| assignment_expression_opt |
| : assignment_expression {} |
| | /* Empty */ {} |
| ; |
| |
| //exception_specification |
| // : KW_throw LEFTPAREN type_id_list_opt RIGHTPAREN |
| // {} |
| // ; |
| |
| //exception_specification_opt |
| // : exception_specification {} |
| // | /* Empty */ {} |
| // ; |
| |
| //type_id_list |
| // : type_id |
| // {} |
| // | type_id_list COMMA type_id |
| // {} |
| // ; |
| |
| //type_id_list_opt |
| // : type_id_list {} |
| // | /* Empty */ {} |
| // ; |
| |
| // ********** Our hack ********** |
| |
| //any_id_expression |
| // : any_unqualified_id {} |
| // | any_qualified_id {} |
| // ; |
| |
| //any_unqualified_id |
| // : any_identifier {} |
| // | operator_function_id {} |
| // | conversion_function_id {} |
| // | COMPLEMENT class_name |
| // { |
| // } |
| // | template_id {} |
| // ; |
| |
| //any_qualified_id |
| // : colcol_opt nested_name_specifier template_opt any_unqualified_id |
| // {} |
| // | COLCOL any_identifier {} |
| // | COLCOL operator_function_id {} |
| // | COLCOL template_id {} |
| // ; |
| |
| // ********** 1.14 Preprocessing directives [gram.cpp] ********** |
| |
| %% |
