DokuWiki

You've loaded an old revision of the document! If you save it, you will create a new version with this data.

====== C3 - tutorial/cecko3.g ====

Gramatika zjednodušeného C++ používaná v kapitole "Objektově orientované syntaktické stromy"
[[http://gitlab.fjfi.cvut.cz/culikzde/view/-/blob/master/tutorial/cecko3.g|cecko3.g]]

Abychom odlišili lokální deklaraci od jednoduchého příkazu obsahujícího výraz a středník, \\
musíme si jazyk upravit a před deklaraci přidat klíčové slovo **dcl**.

<code C++>
decl_stat < CmmDeclStat: CmmStat >:
  "dcl" inner_decl:simple_decl ;

simple_stat < CmmSimpleStat: CmmStat >:
  inner_expr:expr
  ';' ;

Gramatika je již poměrně dlouhá:

<code C++>
/* statements */

while_stat < CmmWhileStat: CmmStat > :
 "while"
 '(' cond:expr ')'
 body_stat:inner_stat ;

if_stat < CmmIfStat: CmmStat >  :
  "if"
  '(' cond:expr ')'
  then_stat:inner_stat
  (
     <new_line>
     "else"
     else_stat:inner_stat
  )? ;

for_stat <CmmForStat:CmmStat>:
  "for"
  '('
  ( from_expr:expr )?
  ';'
  ( cond_expr:expr )?
  ';'
  ( step_expr:expr) ?
  ')'
  body_stat:inner_stat ;

return_stat <CmmReturnStat:CmmStat>:
  "return"
  ( return_expr:expr )?
  ';' ;

compound_stat < CmmCompoundStat: CmmStat > :
  '{'
  <indent>
  ( <new_line> <add> stat )*
  <unindent>
   '}' ;

simple_stat < CmmSimpleStat: CmmStat >:
  inner_expr:expr
  ';' ;

decl_stat < CmmDeclStat: CmmStat >:
  "dcl" inner_decl:simple_decl ;

empty_stat < CmmEmptyStat: CmmStat > :
  ';' ;

inner_stat < return CmmStat > :
  <indent>
  stat
  <unindent> ;

/* -------------------------------------------------------------------- */

/* expressions */

< struct CmmExpr { enum kind; } >
< struct CmmPostfixExpr : CmmExpr { CmmExpr left; } >
< struct CmmBinaryExpr : CmmExpr {  } >
< group expr * CmmExpr >

variable_expr <CmmVarExpr:CmmExpr, kind=varExp> :
  name:identifier
  <execute on_variable_expr> ;

int_value_expr <CmmIntValue:CmmExpr, kind=intValueExp> :
  value:number;

real_value_expr <CmmRealValue:CmmExpr, kind=realValueExp> :
  value:real_number;

char_value_expr <CmmCharValue:CmmExpr, kind=charValueExp> :
  value:character_literal;

string_value_expr <CmmStringValue:CmmExpr, kind=stringValueExp> :
  value:string_literal;

subexpr_expr <CmmSubexprExpr:CmmExpr, kind=subexprExp> :
  '(' inner_expr:expr ')' ;

sequence_expr <CmmSequenceExpr:CmmExpr, kind=sequenceExp> :
  '[' param:expr_list ']' ;

this_expr <CmmThisExpr:CmmExpr, kind=thisExp>:
  "this";

/* postfix expression */

index_expr <CmmIndexExpr:CmmPostfixExpr, kind=indexExp>:
  <store left:CmmExpr>
  '[' param:expr_list ']' ;

call_expr <CmmCallExpr:CmmPostfixExpr, kind=callExp>:
  <store left:CmmExpr>
  '(' param_list:expr_list ')' ;

compound_expr <CmmCompoundExpr:CmmPostfixExpr, kind=compoundExp>:
  <store left:CmmExpr>
  body:compound_stat ;

field_expr <CmmFieldExpr:CmmPostfixExpr, kind=fieldExp>:
  <store left:CmmExpr>
  <no_space> '.' <no_space>
  name:identifier
  <execute on_field_expr> ;

ptr_field_expr <CmmPtrFieldExpr:CmmPostfixExpr, kind=ptrFieldExp>:
  <store left:CmmExpr>
  <no_space> "->" <no_space>
  name:identifier ;

post_inc_expr <CmmPostIncExpr:CmmPostfixExpr, kind=postIncExp>:
  <store left:CmmExpr>
  "++" ;

post_dec_expr <CmmPostDecExpr:CmmPostfixExpr, kind=postDecExp>:
  <store left:CmmExpr>
  "--" ;

/* unary expression */

inc_expr <CmmIncExpr:CmmExpr, kind=incExp>:
  "++" param:unary_expr;

dec_expr <CmmDecExpr:CmmExpr, kind=decExp>:
  "--" param:unary_expr;

deref_expr <CmmDerefExpr:CmmExpr, kind=derefExp>:
  '*' param:unary_expr;

addr_expr <CmmAddrExpr:CmmExpr, kind=addrExp>:
  '&' param:unary_expr;

plus_expr <CmmPlusExpr:CmmExpr, kind=plusExp>:
  '+' param:unary_expr;

minus_expr <CmmMinusExpr:CmmExpr, kind=minusExp>:
  '-' param:unary_expr;

bit_not_expr <CmmBitNotExpr:CmmExpr, kind=bitNotExp>:
  '~' param:unary_expr;

log_not_expr <CmmLogNotExpr:CmmExpr, kind=logNotExp>:
  '!' param:unary_expr;

allocation_expr <CmmNewExpr:CmmExpr, kind=newExp>:
  "new"
  type:identifier
  (
    '(' init_list:expr_list ')'
  )? ;

deallocation_expr <CmmDeleteExpr:CmmExpr, kind=deleteExp>:
  "delete"
  param:unary_expr ;

/* binary expressions */

multiplicative_expr <choose CmmExpr>:
  unary_expr
  (
     <new CmmMulExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( '*' <set kind=mulExp> |
       '/' <set kind=divExp> |
       '%' <set kind=modExp> )
     right:unary_expr
  )* ;

additive_expr <choose CmmExpr>:
  multiplicative_expr
  (
     <new CmmAddExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( '+' <set kind=addExp> |
       '-' <set kind=subExp> )
     right:multiplicative_expr
  )* ;

shift_expr <choose CmmExpr>:
  additive_expr
  (
     <new CmmShiftExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( "<<" <set kind=shlExp> |
       ">>" <set kind=shrExp> )
     right:additive_expr
  )* ;

relational_expr <choose CmmExpr>:
  shift_expr
  (
     <new CmmRelExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( '<'  <set kind=ltExp> |
       '>'  <set kind=gtExp> |
       "<=" <set kind=leExp> |
       ">=" <set kind=geExp> )
     right:shift_expr
  )* ;

equality_expr <choose CmmExpr>:
  relational_expr
  (
     <new CmmEqExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( "==" <set kind=eqExp> |
       "!=" <set kind=neExp> )
     right:relational_expr
  )* ;

and_expr <choose CmmExpr>:
  equality_expr
  (
     <new CmmAndExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     '&' <set kind=bitAndExp>
     right:equality_expr
  )* ;

exclusive_or_expr <choose CmmExpr>:
  and_expr
  (
     <new CmmXorExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     '^' <set kind=bitXorExp>
     right:and_expr
  )* ;

inclusive_or_expr <choose CmmExpr>:
  exclusive_or_expr
  (
     <new CmmOrExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( '|' <set kind=bitOrExp> )
     right:exclusive_or_expr
  )* ;

logical_and_expr <choose CmmExpr>:
  inclusive_or_expr
  (
     <new CmmAndAndExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     "&&" <set kind=logAndExp>
     right:inclusive_or_expr
  )* ;

logical_or_expr <choose CmmExpr>:
  logical_and_expr
  (
     <new CmmOrOrExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     "||" <set kind=logOrExp>
     right:logical_and_expr
  )* ;

assignment_expr <choose CmmExpr>:
  logical_or_expr
  (
     <new CmmAssignExpr:CmmBinaryExpr>
     <store left:CmmExpr>
     ( '=' <set kind=assignExp>     |
        "+="  <set kind=addAssignExp> |
        "-="  <set kind=subAssignExp> )
     right:assignment_expr
  )? ;

expr <return CmmExpr> :
  assignment_expr ;

expr_list <CmmExprList>:
  (
     <add> expr
     ( ',' <add> expr )*
  )? ;

/* -------------------------------------------------------------------- */

namespace_decl <CmmNamespace:CmmDecl> :
  "namespace"
  name:identifier
  <execute open_namespace>
  <new_line>
  '{'
     <indent>
     ( <new_line> <add> decl ) *
     <unindent>
  '}'
  <execute close_namespace> ;

/* -------------------------------------------------------------------- */

class_decl <CmmClass:CmmDecl> :
  <execute begin_class>
  "class"
  name:identifier
  <execute open_class>
  <new_line>
  '{'
     <indent>
     ( <new_line> <add> simple_decl ) *
     <unindent>
  '}'
  <execute close_class>
  <execute end_class> ;

/* -------------------------------------------------------------------- */

enum_decl <CmmEnum:CmmDecl> :
  "enum"
  name:identifier
  <execute open_enum>
  '{'
     <add> enum_item
     ( ',' <add> enum_item ) *
  '}'
  <execute close_enum> ;

enum_item <CmmEnumItem:CmmDecl> :
  name:identifier
  <execute on_enum_item> ;

/* -------------------------------------------------------------------- */

template_decl <CmmTemplate:CmmDecl> :
  <execute begin_template>
  "template"
  '<'
  (
     <add> template_param
     ( ',' <add> template_param )*
     <set parameters=true>
  )?
  '>'
  <indent>
  inner_decl:decl
  <unindent>
  <execute end_template> ;

template_param <CmmTemplateParam> :
  name:identifier ;

/* -------------------------------------------------------------------- */

simple_decl <CmmSimpleDecl:CmmDecl> :
  type:identifier
  ( '*' <set pointer=true> )?
  name:identifier
  <execute on_simple_decl>
  (
     ( '=' init_value:expr )?
     ';'
     <set variable=true>
  |
     init_stat:compound_stat
  |
     <execute open_parameters>
     param_list:parameter_list
     <execute close_parameters>
     <new_line>
     <execute open_function>
     body:compound_stat
     <execute close_function>
  ) ;

parameter_list <CmmParamList> :
  '('
     (
        <add> parameter_decl
        ( ',' <add> parameter_decl )*
     )?
  ')' ;

parameter_decl <CmmParamDecl:CmmDecl> :
  type:identifier
  name:identifier
  <execute on_param_decl> ;

empty_decl <CmmEmptyDecl:CmmDecl> :
  ';' ;

/* -------------------------------------------------------------------- */

program <CmmDeclList> :
  <execute on_start_program>
  (
    <new_line>
    <add> decl
    <empty_line>
  )* ;
</code>

Edit summary

Note: By editing this page you agree to license your content under the following license: CC Attribution-Noncommercial-Share Alike 4.0 International