Code

Package bemtevi;

Helpers
    digito = ['0' .. '9'];
    espaco = ' ';
    tab = 9;
    rc = 13;
    nl = 10;
    under = 95;
    maiusculas = ['A'..'Z'];
    minusculas = ['a'..'z'];
    letras = maiusculas | minusculas;
    aspa = 39;
    aspas_duplas = 34;
    tudo = [0 .. 0xFFFF];
    tudomenosnl = [tudo-nl];
    tracotraco = '--';
    tudomenosaspas = [tudo-aspa];
    not_eol = [tudo - [rc + nl]];
    not_single = [not_eol - 39];
    not_double = [not_eol - 34];
    hifen = '-';
    virgula = 44;
    negative = 45;
    exponencial = 'e' | 'E';
    chaveesquerda  = '{';
    chavedireita = '}';
    d_tudomenoschave = [tudo - chavedireita];
    e_tudomenoschave = [tudo - chaveesquerda];
    comentario_linhas = tracotraco tudomenosnl*;
    comentario_bloco = chaveesquerda  d_tudomenoschave* chavedireita;

Tokens
 classe = 'molde';
 objeto = 'objeto';
 initmolde = 'contem';
 final = 'fim';
 chamada = '.';
 se = 'se';
 passa = 'passa';
 por = 'por';
 funcao = 'funcao';
 tipobool = 'Bool';
 separador = '|';
 principal = '>>';
 pontovirgula = ';';
 doispontos = ':';
 vazio = (espaco | rc | nl | tab)+;
 entao = 'entao';
 senao = 'senao';
 falso = 'falso';
 sum = '+';
 sub = '-';
 mult = '*';
 div = '/';
 mod = '%';
 define = '=';
 igualigual = '==';
 menorque = '<';
 lte = '<=';
 not = '!';
 and = 'e';
 or = 'ou';
 paresquerdo = '(';
 pardireito = ')';
 colcheteesquerdo = '[';
 colchetedireito = ']';
 constante = 'constante';
 tiponumero = 'Numero';
 repeticao = 'recursao';
 verdadeiro = 'verdade';
 tipotexto = 'Texto';
 numero = digito+ ( virgula digito+ | exponencial hifen? digito+ )?;
 texto = aspas_duplas [tudo - aspas_duplas]* aspas_duplas;
 identificador_molde = maiusculas (minusculas | maiusculas | under)*;
 identificador_atributo_funcao = minusculas (minusculas | maiusculas | under | digito)*;
 comentario = (comentario_linhas | comentario_bloco);



Ignored Tokens
 vazio,
 comentario;


Productions


    start {-> P.start  } = {start_programa} programa {-> New start.programa (programa.a_programa  )  }
      | {start_definicao} definicao {-> New start.definicao (definicao )};

    expr_mat
         {-> P.expr_mat  } =

     {fator} fator
         {-> fator.expr_mat   }   |

     {sum} expr_mat sum fator
         {-> New expr_mat.sum (expr_mat , fator.expr_mat   )  }   |

     {menos} expr_mat sub fator
         {-> New expr_mat.menos (expr_mat , fator.expr_mat   )  }
     ;

    fator
         {-> P.expr_mat  } =

     {termo} termo
         {-> termo.expr_mat  }   |

     {mult} fator mult termo
         {-> New expr_mat.mult (fator.expr_mat ,  termo.expr_mat  )  }   |

     {div} fator div termo
         {-> New expr_mat.div (fator.expr_mat , termo.expr_mat  )  }   |

     {mod} fator mod termo
         {-> New expr_mat.mod (fator.expr_mat , termo.expr_mat  )  }
     ;

    termo {-> P.expr_mat  } =
    {numero} numero
         {-> New expr_mat.numero (numero  )  }   |

     {negativo} sub termo
         {-> New expr_mat.negativo (termo.expr_mat  )  }   |

     {exp_atributo} atributo
         {-> New expr_mat.exp_atributo (atributo  )  }   |

     {not} not termo
         {-> New expr_mat.not (termo.expr_mat  )  }   |

     {exp_id} identificador_atributo_funcao
         {-> New expr_mat.exp_id (identificador_atributo_funcao  )  }   |

     {exp_chamada} chamada
         {-> New expr_mat.exp_chamada (chamada  )  }   |

     {par} paresquerdo exp_geral pardireito
         {-> New expr_mat.par (exp_geral )  }
     ;


    programa {-> a_programa} = {programa} familia? def_molde+ {->New a_programa.ar_programa(familia.familia, [def_molde.def_molde])};



    aux_familia
         {-> P.familia  } =

     {aux_familia} pontovirgula relacao
         {-> New familia.aux_familia (relacao  )  }
    ;

    familia
         {-> P.familia  } =

    {afamiliafamilia1} relacao T.chamada
        {-> New familia.afamiliafamilia1 (relacao )  }   |

     {afamiliafamilia2} relacao P.a_aux_familia
         {-> New familia.afamiliafamilia2 (relacao , [ a_aux_familia.familia  ])  }
     ;

    relacao
         {-> P.relacao  } =

     {relacao} classe [first]: identificador_molde se passa por [second]: identificador_molde
         {-> New relacao.relacao (first ,  second  )  }
     ;

    def_molde
         {-> P.def_molde  } =

     {def_molde} classe identificador_molde initmolde atributos metodos final
         {-> New def_molde.def_molde (identificador_molde ,  atributos , metodos   )  }
     ;












    aux_atributos
         {-> P.aux_atributos  } =

     {dec_cons} dec_cons
         {-> New aux_atributos.dec_cons (dec_cons  )  }   |

     {dec_obj} dec_obj
         {-> New aux_atributos.dec_obj (dec_obj  )  }
     ;

    atributos
         {-> P.atributos  } =

     {aatributosatributos1}
         {-> New atributos.atributos ([  ] )  }   |

     {aatributosatributos2} P.a_aux_atributos
         {-> New atributos.atributos ([ a_aux_atributos.aux_atributos  ] )  }
     ;

    dec_cons
         {-> P.dec_cons  } =

     {def_cons} constante doispontos tipo_primitivo identificador_atributo_funcao pontovirgula
         {-> New dec_cons.def_cons (tipo_primitivo , identificador_atributo_funcao)  }   |

     {ini_cons} constante doispontos tipo_primitivo definicao
         {-> New dec_cons.ini_cons (tipo_primitivo , definicao  )  }
     ;

    dec_obj
         {-> P.dec_obj  } =

     {def_obj} objeto doispontos tipo_molde identificador_atributo_funcao pontovirgula
         {-> New dec_obj.def_obj (tipo_molde , identificador_atributo_funcao  )  }   |

     {ini_obj} objeto doispontos tipo_molde definicao
         {-> New dec_obj.ini_obj (tipo_molde , definicao  )  }
     ;

    tipo_primitivo
         {-> P.tipo_primitivo  } =

     {tipobool} tipobool
         {-> New tipo_primitivo.tipobool (tipobool  )  }   |

     {tiponumero} tiponumero
         {-> New tipo_primitivo.tiponumero (tiponumero  )  }   |

     {tipotexto} tipotexto
         {-> New tipo_primitivo.tipotexto (tipotexto  )  }
     ;

    tipo_molde
         {-> P.tipo_molde  } =

     {tipo_molde} identificador_molde
         {-> New tipo_molde.tipo_molde (identificador_molde  )  }
     ;

    tipo
         {-> P.tipo  } =

     {tipo_molde} tipo_molde
         {-> New tipo.tipo_molde (tipo_molde  )  }   |

     {tipo_primitivo} tipo_primitivo
         {-> New tipo.tipo_primitivo (tipo_primitivo  )  }
     ;

    metodos
         {-> P.metodos  } =

     {ametodosmetodos1}
         {-> New metodos.metodos ([  ] )  }   |

     {ametodosmetodos2} P.a_dec_funcao
         {-> New metodos.metodos ([ a_dec_funcao.dec_funcao  ] )  }
     ;

    dec_funcao
         {-> P.dec_funcao  } =

     {adeffuncaoinidecfuncao1} funcao doispontos tipo identificador_atributo_funcao paresquerdo pardireito bloco
         {-> New dec_funcao.adeffuncaoinidecfuncao1 (tipo , identificador_atributo_funcao  ,   bloco  )  }   |

     {adeffuncaoinidecfuncao2} principal funcao doispontos tipo identificador_atributo_funcao paresquerdo pardireito bloco
         {-> New dec_funcao.adeffuncaoinidecfuncao2 (tipo , identificador_atributo_funcao , bloco  )  }   |

     {adeffuncaoinidecfuncao3} funcao doispontos tipo identificador_atributo_funcao paresquerdo parametros pardireito bloco
         {-> New dec_funcao.adeffuncaoinidecfuncao3 (tipo , identificador_atributo_funcao , parametros, bloco  )  }   |

     {adeffuncaoinidecfuncao4} principal funcao doispontos tipo identificador_atributo_funcao paresquerdo parametros pardireito bloco
         {-> New dec_funcao.adeffuncaoinidecfuncao4 (tipo , identificador_atributo_funcao  , parametros ,  bloco  )  }   |

     {adeffuncaodecfuncao1} funcao doispontos tipo identificador_atributo_funcao paresquerdo pardireito pontovirgula
         {-> New dec_funcao.adeffuncaodecfuncao1 (tipo , identificador_atributo_funcao  )  }   |

     {adeffuncaodecfuncao2} principal funcao doispontos tipo identificador_atributo_funcao paresquerdo pardireito pontovirgula
         {-> New dec_funcao.adeffuncaodecfuncao2 (tipo , identificador_atributo_funcao)  }   |

     {adeffuncaodecfuncao3} funcao doispontos tipo identificador_atributo_funcao paresquerdo parametros pardireito pontovirgula
         {-> New dec_funcao.adeffuncaodecfuncao3 ( tipo , identificador_atributo_funcao ,  parametros  )  }   |

     {adeffuncaodecfuncao4} principal funcao doispontos tipo identificador_atributo_funcao paresquerdo parametros pardireito pontovirgula
         {-> New dec_funcao.adeffuncaodecfuncao4 (tipo , identificador_atributo_funcao , parametros    )  }
     ;

    aux_parametros
         {-> P.aux_parametros  } =

     {aux_parametros} separador parametro
         {-> New aux_parametros.aux_parametros (separador , parametro )};

    parametros
         {-> P.parametros  } =

     {aparametrosparametros1} parametro
         {-> New parametros.parametros (parametro , [  ] )  }   |

     {aparametrosparametros2} parametro P.a_aux_parametros
         {-> New parametros.parametros (parametro , [ a_aux_parametros.aux_parametros  ] )  }
     ;

    parametro
         {-> P.parametro  } =

     {parametro_id} tipo identificador_atributo_funcao
         {-> New parametro.parametro_id (tipo , identificador_atributo_funcao  )  }   |

     {parametro_ass} assinatura
         {-> New parametro.parametro_ass (assinatura  )  }
     ;

    assinatura
         {-> P.assinatura  } =

     {aassinaturaassinatura1} tipo identificador_atributo_funcao paresquerdo pardireito
         {-> New assinatura.aassinaturaassinatura1 (tipo , identificador_atributo_funcao   )  }   |

     {aassinaturaassinatura2} tipo identificador_atributo_funcao paresquerdo parametros_assinatura pardireito
         {-> New assinatura.aassinaturaassinatura2 (tipo , identificador_atributo_funcao , parametros_assinatura  )  }
     ;

    aux_parametros_assinatura
         {-> P.aux_parametros_assinatura  } =

     {aux_parametros_assinatura} separador parametro_assinatura
         {-> New aux_parametros_assinatura.aux_parametros_assinatura (separador , parametro_assinatura  )  }
     ;

    parametros_assinatura
         {-> P.parametros_assinatura  } =

     {aparamsassinaturaparametrosassinatura1} parametro_assinatura
         {-> New parametros_assinatura.params_assinatura (parametro_assinatura , [  ] )  }   |

     {aparamsassinaturaparametrosassinatura2} parametro_assinatura P.a_aux_parametros_assinatura
         {-> New parametros_assinatura.params_assinatura (parametro_assinatura , [ a_aux_parametros_assinatura.aux_parametros_assinatura  ] )  }
     ;

    parametro_assinatura
         {-> P.parametro_assinatura  } =

     {param_tipo} tipo
         {-> New parametro_assinatura.param_tipo (tipo  )  }   |

     {param_assinatura} assinatura
         {-> New parametro_assinatura.param_assinatura (assinatura  )  }
     ;

    aux_bloco
         {-> P.aux_bloco  } =

     {aux_bloco_cons} dec_cons
         {-> New aux_bloco.aux_bloco_cons (dec_cons  )  }   |

     {aux_bloco_obj} dec_obj
         {-> New aux_bloco.aux_bloco_obj (dec_obj  )  }   |

     {aux_bloco_def} definicao
         {-> New aux_bloco.aux_bloco_def (definicao  )  }
     ;

    bloco
         {-> P.bloco  } =

     {ablocobloco1} colcheteesquerdo exp_geral colchetedireito
         {-> New bloco.ablocobloco1 (exp_geral)  }   |

     {ablocobloco2} colcheteesquerdo P.a_aux_bloco exp_geral colchetedireito
         {-> New bloco.ablocobloco2 ([ a_aux_bloco.aux_bloco  ], exp_geral)  }
     ;












    aux_definicao
         {-> P.aux_definicao  } =
     {aux_definicao} identificador_atributo_funcao
         {-> New aux_definicao.aux_definicao (identificador_atributo_funcao  )  }   |

     atributo
         {-> New aux_definicao (atributo  )  }
     ;

    definicao
         {-> P.definicao  } =

     {definicao} aux_definicao define exp_geral pontovirgula
         {-> New definicao.definicao (aux_definicao  , exp_geral   )  }
     ;

    aux_atributo
         {-> P.aux_atributo  } =

     {aux_atributo} T.chamada identificador_atributo_funcao
         {-> New aux_atributo.aux_atributo (identificador_atributo_funcao  )  }
     ;

    atributo
         {-> P.atributo  } =

     {atributo} identificador_atributo_funcao P.a_aux_atributo
         {-> New atributo.atributo (identificador_atributo_funcao , [ a_aux_atributo.aux_atributo  ] )  }
     ;

    exp_geral {-> P.exp_geral  } = {exp_condicional} se paresquerdo exp_geral pardireito entao [first]:exp_geral_op_logico senao [second]: exp_geral_op_logico {-> New exp_geral.n_definicao (exp_geral , first.exp_geral ,  second.exp_geral  )}
        | {op_logico4} op_logico4 {->  op_logico4.exp_geral };

    op_logico4 {-> P.exp_geral  } = {op_logico3} op_logico3 {-> op_logico3.exp_geral   }
       | {op_logico_ou} exp_geral or exp_geral_op_logico {-> New exp_geral.ou_op_logico_ou (exp_geral , exp_geral_op_logico.exp_geral  )  }
     ;

    op_logico3 {-> P.exp_geral  } = {op_logico2} op_logico2 {-> op_logico2.exp_geral   }
        | {op_logico_e} exp_geral and exp_geral_op_logico {-> New exp_geral.e_op_logico_e (exp_geral , exp_geral_op_logico.exp_geral  )  }
     ;

    op_logico2 {-> P.exp_geral  } = {op_logico1} op_logico1 {-> op_logico1.exp_geral }
        | {igualigual} exp_geral igualigual exp_geral_op_logico
         {-> New exp_geral.n_igualigual (exp_geral ,  exp_geral_op_logico.exp_geral  )  }
     ;

    op_logico1 {-> P.exp_geral  } = {exp_geral_op_logico} exp_geral_op_logico {-> exp_geral_op_logico.exp_geral  }
        | {menor_que} exp_geral menorque exp_geral_op_logico {-> New exp_geral.n_menor_que (exp_geral , exp_geral_op_logico.exp_geral  )  }
        | {lte} exp_geral lte exp_geral_op_logico {-> New exp_geral.n_lte (exp_geral ,  exp_geral_op_logico.exp_geral  )  }
     ;

    exp_geral_op_logico {-> P.exp_geral  } = {exp_bloco} bloco {-> New exp_geral.exp_bloco (bloco  )  }   |

     {terminal} terminais {-> terminais.exp_geral }
     ;

    terminais
         {-> P.exp_geral  } =

     {exp_matematica} expr_mat {-> New exp_geral.exp_matematica (expr_mat  )  }   |

     {valor_texto} texto
         {-> New exp_geral.valor_texto (texto  )  }   |

     {bool_verdade} verdadeiro
         {-> New exp_geral.bool_verdade (verdadeiro  )  }   |

     {bool_falso} falso
         {-> New exp_geral.bool_falso (falso  )  }   |

     {exp_instancia} instancia
         {-> New exp_geral.exp_instancia (instancia  )  }
     ;

    instancia
         {-> P.instancia  } =

     {ainstanciainstancia} identificador_molde colcheteesquerdo lista_inicializacao colchetedireito
         {-> New instancia.instancia (identificador_molde  , lista_inicializacao  )  }
     ;

    aux_lista_inicializacao
         {-> P.aux_lista_inicializacao  } =

     {aauxlistainicializacaoauxlistainicializacao1} separador
         {-> New aux_lista_inicializacao.aux_lista_inicializacao (separador , [  ] )  }   |

     {aauxlistainicializacaoauxlistainicializacao2} separador P.a_inicializacao_objeto
         {-> New aux_lista_inicializacao.aux_lista_inicializacao (separador , [ a_inicializacao_objeto.inicializacao_objeto  ] )  }
     ;

    lista_inicializacao
         {-> P.lista_inicializacao  } =

     {alistainilistainicializacao1} inicializacao_objeto
         {-> New lista_inicializacao.lista_inicializacao (inicializacao_objeto , [  ] )  }   |

     {alistainilistainicializacao2} inicializacao_objeto P.a_aux_lista_inicializacao
         {-> New lista_inicializacao.lista_inicializacao (inicializacao_objeto , [ a_aux_lista_inicializacao.aux_lista_inicializacao  ] )  }
     ;

    aux_inicializacao_objeto
         {-> P.aux_inicializacao_objeto  } =

     {aux_inicializacao_objeto} T.chamada identificador_atributo_funcao
         {-> New aux_inicializacao_objeto.aux_inicializacao_objeto (identificador_atributo_funcao  )  }
     ;

    inicializacao_objeto
         {-> P.inicializacao_objeto  } =

     {ainiobjetoinicializacaoobjeto1} objeto T.chamada identificador_atributo_funcao define exp_geral
         {-> New inicializacao_objeto.ini_objeto (identificador_atributo_funcao , [  ],  exp_geral  )  }   |

     {ainiobjetoinicializacaoobjeto2} objeto T.chamada identificador_atributo_funcao P.a_aux_inicializacao_objeto define exp_geral
         {-> New inicializacao_objeto.ini_objeto (identificador_atributo_funcao , [ a_aux_inicializacao_objeto.aux_inicializacao_objeto  ],  exp_geral  )  }
     ;

    chamada_p
         {-> P.chamada_p  } =

     {achamadachamadap1} identificador_atributo_funcao paresquerdo pardireito
         {-> New chamada_p.achamadachamadap1 (identificador_atributo_funcao  )  }   |

     {achamadachamadap2} identificador_atributo_funcao P.a_aux_atributo paresquerdo pardireito
         {-> New chamada_p.achamadachamadap2 (identificador_atributo_funcao , [ a_aux_atributo.aux_atributo  ] )  }   |

     {achamadachamadap3} identificador_atributo_funcao paresquerdo lista_exp_geral pardireito
         {-> New chamada_p.achamadachamadap3 (identificador_atributo_funcao  , lista_exp_geral   )  }   |

     {achamadachamadap4} identificador_atributo_funcao P.a_aux_atributo paresquerdo lista_exp_geral pardireito
         {-> New chamada_p.achamadachamadap4 (identificador_atributo_funcao , [ a_aux_atributo.aux_atributo  ] , lista_exp_geral   )  }
     ;

    aux_lista_exp_geral
         {-> P.aux_lista_exp_geral  } =

     {aux_lista_exp_geral} separador exp_geral
         {-> New aux_lista_exp_geral.aux_lista_exp_geral ( exp_geral  )  }
     ;

    lista_exp_geral
         {-> P.lista_exp_geral  } =

//     {alistaexplistaexpgeral1} exp_geral
//         {-> New lista_exp_geral.lista_exp (exp_geral  )  }   |

     {alistaexplistaexpgeral2} exp_geral P.a_aux_lista_exp_geral
         {-> New lista_exp_geral.lista_exp (exp_geral , [ a_aux_lista_exp_geral.aux_lista_exp_geral  ] )  }
     ;

    a_def_molde
         {-> P.def_molde*  } =

     {terminal} P.def_molde
         {-> [ P.def_molde.def_molde  ]  }   |

     {non_terminal} P.a_def_molde P.def_molde
         {-> [ a_def_molde.def_molde, P.def_molde.def_molde  ]  }
     ;


    a_aux_familia
         {-> P.familia*  } =

     {terminal} P.aux_familia
         {-> [ P.aux_familia.familia  ]  }   |

     {non_terminal} P.a_aux_familia P.aux_familia
         {-> [ a_aux_familia.familia, P.aux_familia.familia  ]  }
     ;

    a_aux_atributos
         {-> P.aux_atributos*  } =

     {terminal} P.aux_atributos
         {-> [ P.aux_atributos.aux_atributos  ]  }   |

     {non_terminal} P.a_aux_atributos P.aux_atributos
         {-> [ a_aux_atributos.aux_atributos, P.aux_atributos.aux_atributos  ]  }
     ;


    a_dec_funcao
         {-> P.dec_funcao*  } =

     {terminal} P.dec_funcao
         {-> [ P.dec_funcao.dec_funcao  ]  }   |

     {non_terminal} P.a_dec_funcao P.dec_funcao
         {-> [ a_dec_funcao.dec_funcao, P.dec_funcao.dec_funcao  ]  }
     ;

    a_aux_parametros
         {-> P.aux_parametros*  } =

     {terminal} P.aux_parametros
         {-> [ P.aux_parametros.aux_parametros  ]  }   |

     {non_terminal} P.a_aux_parametros P.aux_parametros
         {-> [ a_aux_parametros.aux_parametros, P.aux_parametros.aux_parametros  ]  }
     ;

    a_aux_parametros_assinatura
         {-> P.aux_parametros_assinatura*  } =

     {terminal} P.aux_parametros_assinatura
         {-> [ P.aux_parametros_assinatura.aux_parametros_assinatura  ]  }   |

     {non_terminal} P.a_aux_parametros_assinatura P.aux_parametros_assinatura
         {-> [ a_aux_parametros_assinatura.aux_parametros_assinatura, P.aux_parametros_assinatura.aux_parametros_assinatura  ]  }
     ;

    a_aux_bloco
         {-> P.aux_bloco*  } =

     {terminal} P.aux_bloco
         {-> [ P.aux_bloco.aux_bloco  ]  }   |

     {non_terminal} P.a_aux_bloco P.aux_bloco
         {-> [ a_aux_bloco.aux_bloco, P.aux_bloco.aux_bloco  ]  }
     ;

    a_aux_atributo
         {-> P.aux_atributo*  } =

     {terminal} P.aux_atributo
         {-> [ P.aux_atributo.aux_atributo  ]  }   |

     {non_terminal} P.a_aux_atributo P.aux_atributo
         {-> [ a_aux_atributo.aux_atributo, P.aux_atributo.aux_atributo  ]  }
     ;

    a_inicializacao_objeto
         {-> P.inicializacao_objeto*  } =

     {terminal} P.inicializacao_objeto
         {-> [ P.inicializacao_objeto.inicializacao_objeto  ]  }   |

     {non_terminal} P.a_inicializacao_objeto P.inicializacao_objeto
         {-> [ a_inicializacao_objeto.inicializacao_objeto, P.inicializacao_objeto.inicializacao_objeto  ]  }
     ;

    a_aux_lista_inicializacao
         {-> P.aux_lista_inicializacao*  } =

     {terminal} P.aux_lista_inicializacao
         {-> [ P.aux_lista_inicializacao.aux_lista_inicializacao  ]  }   |

     {non_terminal} P.a_aux_lista_inicializacao P.aux_lista_inicializacao
         {-> [ a_aux_lista_inicializacao.aux_lista_inicializacao, P.aux_lista_inicializacao.aux_lista_inicializacao  ]  }
     ;



    a_aux_inicializacao_objeto
         {-> P.aux_inicializacao_objeto*  } =

     {terminal} P.aux_inicializacao_objeto
         {-> [ P.aux_inicializacao_objeto.aux_inicializacao_objeto  ]  }   |

     {non_terminal} P.a_aux_inicializacao_objeto P.aux_inicializacao_objeto
         {-> [ a_aux_inicializacao_objeto.aux_inicializacao_objeto, P.aux_inicializacao_objeto.aux_inicializacao_objeto  ]  }
     ;

    a_aux_lista_exp_geral
         {-> P.aux_lista_exp_geral*  } =

     {terminal} P.aux_lista_exp_geral
         {-> [ P.aux_lista_exp_geral.aux_lista_exp_geral  ]  }   |

     {non_terminal} P.a_aux_lista_exp_geral P.aux_lista_exp_geral
         {-> [ a_aux_lista_exp_geral.aux_lista_exp_geral, P.aux_lista_exp_geral.aux_lista_exp_geral  ]  }
     ;

Abstract Syntax Tree



    start = {programa} a_programa
       | {definicao} definicao;

    expr_mat = {sum} [esq]:expr_mat [dir]:expr_mat
        |{menos} [esq]:expr_mat [dir]:expr_mat
        |{mult} [esq]:expr_mat [dir]:expr_mat
        |{div} [esq]:expr_mat [dir]:expr_mat
        |{mod} [esq]:expr_mat [dir]:expr_mat
        |{exp_atributo} atributo
        |{exp_chamada} chamada
        |{numero} numero
        |{negativo} expr_mat
        |{not} expr_mat
        |{exp_id} identificador_atributo_funcao
        |{par} exp_geral;



    a_programa = {ar_programa} familia? def_molde+;



    familia = {aux_familia} relacao
    |{afamiliafamilia1} relacao
        |{afamiliafamilia2} relacao familia*;

    relacao =
     {relacao} [first]: identificador_molde [second]: identificador_molde
     ;

    def_molde =
     {def_molde} identificador_molde atributos metodos
     ;

    aux_atributos =
     {dec_cons} dec_cons |
     {dec_obj} dec_obj
     ;

    atributos =
     {atributos} aux_atributos*
     ;

    dec_cons =
     {def_cons} tipo_primitivo identificador_atributo_funcao |
     {ini_cons} tipo_primitivo definicao
     ;

    dec_obj =
     {def_obj} tipo_molde identificador_atributo_funcao  |
     {ini_obj} tipo_molde definicao
     ;

    tipo_primitivo =
     {tipobool} tipobool |
     {tiponumero} tiponumero |
     {tipotexto} tipotexto
     ;

    tipo_molde =
     {tipo_molde} identificador_molde
     ;

    tipo =
     {tipo_molde} tipo_molde |
     {tipo_primitivo} tipo_primitivo
     ;

    metodos =
     {metodos} dec_funcao*
     ;

    dec_funcao =
     {adeffuncaoinidecfuncao1} tipo identificador_atributo_funcao bloco |
     {adeffuncaoinidecfuncao2} tipo identificador_atributo_funcao bloco |
     {adeffuncaoinidecfuncao3} tipo identificador_atributo_funcao parametros? bloco |
     {adeffuncaoinidecfuncao4} tipo identificador_atributo_funcao parametros? bloco |
     {adeffuncaodecfuncao1} tipo identificador_atributo_funcao  |
     {adeffuncaodecfuncao2} tipo identificador_atributo_funcao  |
     {adeffuncaodecfuncao3} tipo identificador_atributo_funcao parametros?  |
     {adeffuncaodecfuncao4} tipo identificador_atributo_funcao parametros?  |
     {def_funcao}  tipo identificador_atributo_funcao  parametros?
     ;



    aux_parametros =
     {aux_parametros} separador parametro
     ;

    parametros =
     {parametros} parametro aux_parametros*
     ;

    parametro =
     {parametro_id} tipo identificador_atributo_funcao |
     {parametro_ass} assinatura
     ;

    assinatura =
     {aassinaturaassinatura1} tipo identificador_atributo_funcao |
     {aassinaturaassinatura2} tipo identificador_atributo_funcao parametros_assinatura?

     ;

    aux_parametros_assinatura =
     {aux_parametros_assinatura} separador parametro_assinatura
     ;

    parametros_assinatura =
     {params_assinatura} parametro_assinatura aux_parametros_assinatura*
     ;

    parametro_assinatura =
     {param_tipo} tipo |
     {param_assinatura} assinatura
     ;

    aux_bloco =
     {aux_bloco_cons} dec_cons |
     {aux_bloco_obj} dec_obj |
     {aux_bloco_def} definicao
     ;

    bloco =
     {ablocobloco1} exp_geral |
     {ablocobloco2} aux_bloco* exp_geral
     ;


    aux_definicao =
     {aux_definicao} identificador_atributo_funcao |
     atributo
     ;

    definicao =
     {definicao} aux_definicao exp_geral
     ;

    aux_atributo =
     {aux_atributo} identificador_atributo_funcao
     ;

    atributo =
     {atributo} identificador_atributo_funcao aux_atributo+
     ;

    exp_geral =
     {n_definicao} [third]:exp_geral [first]:exp_geral [second]:exp_geral
     |{ou_op_logico_ou} [first]:exp_geral [second]: exp_geral
     |{e_op_logico_e} [first]:exp_geral [second]: exp_geral
     | {n_igualigual} [first]:exp_geral [second]: exp_geral
     | {n_menor_que} [first]:exp_geral [second]: exp_geral
     | {n_lte} [first]:exp_geral [second]: exp_geral
     | {exp_bloco} bloco
     | {exp_instancia} instancia
     | {exp_matematica} expr_mat
     | {valor_texto} texto
     | {bool_verdade} verdadeiro
     | {bool_falso} falso
     ;


    terminais =
     {exp_matematica} expr_mat |
     {valor_texto} texto |
     {bool_verdade} verdadeiro |
     {bool_falso} falso |
     {exp_instancia} instancia
     ;

    instancia =
     {instancia} identificador_molde  lista_inicializacao?
     ;

    // aux_lista_inicializacao = {aux_lista_inicializacao} separador inicializacao_objeto* ;
    //;
    lista_inicializacao = {lista_inicializacao} inicializacao_objeto aux_lista_inicializacao* ;
    // ;
//    aux_lista_inicializacao = {aux_lista_inicializacao} separador lista_inicializacao;
    aux_lista_inicializacao = {aux_lista_inicializacao} separador inicializacao_objeto*;



    aux_inicializacao_objeto =
    {aux_inicializacao_objeto} identificador_atributo_funcao
     ;

    inicializacao_objeto =
     {ini_objeto} identificador_atributo_funcao aux_inicializacao_objeto* exp_geral
     ;

    //chamada_p =
    // {chamada} identificador_atributo_funcao aux_atributo*  lista_exp_geral?
    // ;

    chamada_p = {achamadachamadap1} identificador_atributo_funcao
        | {achamadachamadap2} identificador_atributo_funcao aux_atributo*
        | {achamadachamadap3} identificador_atributo_funcao lista_exp_geral?
        | {achamadachamadap4} identificador_atributo_funcao aux_atributo* lista_exp_geral?
    ;
    aux_lista_exp_geral =
     {aux_lista_exp_geral} exp_geral
     ;

    lista_exp_geral =
     {lista_exp} exp_geral aux_lista_exp_geral*
     ;