%{ #define tags(x) x #include #include /*------------------------------------------------------------------- ###### # # ## ##### #### ###### ##### # # # # # # # # # # ###### # # # # #### ##### # # # ###### ##### # # ##### # # # # # # # # # # # # # # # #### ###### # # Versao <$Revision$$Date$> -------------------------------------------------------------------*/ int _accao=1; int in_sequence = 0; int cont_alt = 0; int cont_tup = 0; char * idtup() { char s[80]; sprintf(s,"_p%d", cont_tup++); return strdup(s); } char CONTEXTO= 'd'; #include "version" char straux [30], command [50]; char option; int jjDEBUG =1; #include "sexp.h" #include "met.h" void erro(char *e); void yyerror(char *s); void gera_tag_pair(char *nome); void geratag(char *nome); extern FILE *yyin, *yyout; extern int yylineno; extern char yytext[]; #include /* ---(Formata output )-------------------------------------------------*/ static int queres_comentarios=0; #if INTERACTIVE || FUNC #include "iformata.c" #else #include "formata.c" #endif struct t_tipo { char ti[5]; struct t_tipo *arg1, *arg2, *next; }; typedef struct t_tipo TIPO; typedef struct t_tipo *APTIPO; %} %union { char *str; } %{ /* *** Simbolos Terminais *** */ %} %token NYAVAIL SIMB CONSTANTE INTEGER STRING BOOL FUNCAO '=' %token SET LIST TYPE ENDTYPE P4 NIL RELACAO INCLUDE INCLUDEM DEBUGON TBOOL %token DEBUGOFF QUIT MODEL ENDMODEL FSETA2 INV COMP FPROD FADD DEFTYPE %{ /* *** fim de definicao de terminais *** */ %} %{ /* *** prioridades e associatividades: *** */ %} %nonassoc minima %nonassoc ';' %left ',' %nonassoc FUNCAO %nonassoc LAMBDA %nonassoc baixa %nonassoc SSETA %nonassoc LET OTHER SETA IF THEN RELBEGIN RELEND PRE ESTADO %nonassoc PERTENCE ELSE RETUR ALL EXIST EXIST1 %nonassoc '>' %left IMPLICA %left AND %left OR OR2 %left NOT %nonassoc EQ NEQ LEQ GEQ '<' GT %nonassoc TRIPLO %left STRCAT %left ADD SUB %left MUL DIV %nonassoc NOTIN IN %left UNION %left INTER %left '-' %nonassoc '#' alta %left '^' %left PLUS %left '/' %left '\\' %left '.' %left '[' %left '(' BEGINARRAY NEWLINE %left COMP %left FSETA LIST SET %right FSETA2 %left FADD %left FPROD %nonassoc CONSF ID IS TIN TOUT ':' ORIO QUOTE %right maxima %nonassoc maximam %{ /* *** fim de definicao de prioridades *** */ %} %{ /* *** Simbolos Nao Terminais *** */ %} %% especificacao : especificacao typesMod | especificacao bloco | especificacao ENDMODEL | especificacao MODEL SIMB { } | ; /*--( Definicao de tipos )-------------------------------------------*/ defTipo : idTipo '=' defTp inv ';' { } | idTipo P4 defTp inv ';' { } | error ';' { yyerrok; } ; inv : INV '(' SIMB ')' '=' {CONTEXTO='d';} exp {CONTEXTO='t'; } | ; idTipo: SIMB { } ; defTp: simpleType { } | alternativa2 { } | alternativa { } | simpleType INTER rtuplo2 %prec baixa { /* simple tuplo */ } | funcmat { } | tuplo { } ; funcmat : SSETA simpleType { } | simpleType SSETA simpleType { } | simpleType INTER rtuplo2 SSETA simpleType %prec baixa { } ; simpleType : SIMB { } | NIL { } | relacao { } | funcfin { } | TBOOL { } | lista { } | conjunto { } | segmentoInicial { } | '(' simpleType ')' { } | '(' funcmat ')' { } | NYAVAIL { } ; rtuplo2 : simpleType %prec baixa { } | rtuplo2 INTER simpleType %prec baixa { } ; tuplo : itemtuplo rtuplo { } ; rtuplo: itemtuplo rtuplo { } | { } ; itemtuplo : SIMB ':' simpleType %prec baixa { } ; itemtuplo : INTER SIMB ':' simpleType %prec baixa { } ; funcfin : simpleType SETA simpleType { } ; relacao : simpleType RELACAO simpleType { } ; lista : SIMB LIST { } | TBOOL LIST { } | '(' simpleType ')' LIST { } | segmentoInicial LIST { } ; conjunto : SIMB SET { } | TBOOL SET { } | '(' simpleType ')' SET { } | segmentoInicial SET { } ; segmentoInicial : INTEGER { } ; alternativa : '[' simpleType ']' %prec baixa { } | simpleType '|' simpleType %prec baixa { } | alternativa '|' '[' simpleType ']' %prec baixa { } | alternativa '|' simpleType %prec baixa { } ; alternativa2 : simpleType PLUS simpleType %prec baixa { } | alternativa2 PLUS simpleType %prec baixa { } ; /*--( Definicao de tipos nos modulos )-------------------------------*/ typesMod : TYPE {CONTEXTO='t'; } defTipo { } restDefTypesMod ENDTYPE {CONTEXTO='d';} | DEFTYPE {CONTEXTO='t'; } defTipo { CONTEXTO='d'; } ; restDefTypesMod : defTipo { } restDefTypesMod | ; /*--( Bloco = (deffuncao+include+teste)* )---------------------------*/ bloco : bloco elemento | elemento ; elemento : exp ';' { } | include { } | ESTADO SIMB ':' tipo ';' { } | directiva | deffuncao ';' { } | error ';' {yyerrok;} elemento | QUIT { return(0);} ; /*--( directivas de debug/outras )-----------------------------------*/ directiva : DEBUGON {jjDEBUG = 1;} | DEBUGOFF {jjDEBUG = 0;} ; /*--( Includes )-----------------------------------------------------*/ include : INCLUDE SIMB '.' SIMB { } | INCLUDE STRING { } | INCLUDE SIMB { } | INCLUDEM STRING { } | INCLUDEM SIMB '.' SIMB { } | INCLUDEM SIMB { } ; /*--( definicao de funcoes )-----------------------------------------*/ deffuncao : SIMB '(' explist ')' '=' exp { tags(geratag($1)); } | SIMB '=' exp %prec baixa { } | FUNCAO SIMB assinatura precond /* mensagem */ poscondicao { geratag($2); } ; poscondicao : estado retorno { } | retorno estado { } | retorno { } | estado { } | LET '(' deflist ')' IN poscondicao { } ; retorno : RETUR exp { } ; estado : ESTADO exp { } ; assinatura : '(' explist2 ')' resultado { } ; resultado : ':' resultado1 { } | { } ; resultado1 : resultado1 tipo { } | { } ; tipo : defTp { } ; explist2 : SIMB ':' tipo ',' explist2 { } | SIMB ':' tipo { } | SIMB ',' explist2 { } | SIMB { } | '(' SIMB ')' ',' explist2 { } | '(' SIMB ')' { } | { } ; precond : PRE exp { } | PRE exp SETA exp { } | { } ; /*--( definicao de variaveis de Estado )-----------------------------*/ defobj : SIMB atrib exp %prec baixa { } | SIMB '.' SIMB atrib exp %prec baixa { } ; atrib : PERTENCE ; /*--( Expressoes )---------------------------------------------------*/ exp : SIMB { } | BEGINARRAY exp ')' { } | exp NEWLINE { } | '(' exp ')' { } | NYAVAIL { } | CONSTANTE { } /* | exp exp { #ifdef NYAG $$=mklista(cons($1,$2)); #endif #ifdef PRETTY $$ = ppExpExpList($1,$2); #endif } */ | exp '(' explist ')' %prec '(' { } | FUNCAO assinatura precond /* mensagem */ poscondicao { } | LAMBDA '(' explist ')' '.' exp %prec PERTENCE { } | SIMB '(' explist ')' %prec '(' { tags(gera_tag_pair($1)); } | QUOTE '(' explist ')' { } | op_orio ORIO '(' exp ',' exp ')' { } | NIL { } | defobj { } | strexp { } | intexp { } | ffexp { } | relexp { } | seqexp { } | setexp { } | letexp { } | ifexp { } | boolexp { } | exp '\\' exp { } | exp '/' exp { } | exp '[' exp ']' %prec maxima { } | SIMB '.' SIMB { } | FunctExp ; strexp : STRING { } | exp STRCAT exp { } ; op_orio : SIMB { } | ADD { } | STRCAT { } | MUL { } | OR { } /* | '^' {$$=mkatconst("append");} */ | PLUS { } ; /*--( Expressoes Inteiras )----------------------------------------------*/ intexp : INTEGER { } | '#' exp { } | exp ADD exp { } | exp SUB exp { } | exp DIV exp { } | exp MUL exp { } ; /*--( Expressoes Bool )----------------------------------------------*/ boolexp : exp IN exp { } | exp NOTIN exp { } | exp EQ exp { } | exp AND exp { } | exp IMPLICA exp { } | exp OR2 exp { } | exp OR exp { } | NOT exp { } /* | exp '<' exp '<' exp %prec TRIPLO { @ifdef NYAG $$=_and(funbin("lt",$1,$3),funbin("lt",copia($3),$5)); @ifdef PRETTY $$ = ppBoolLT(ppBoolLT($1,$3),$5); } */ | exp '<' exp { } | exp GT exp { } | exp '>' exp { } /* | exp LEQ exp LEQ exp %prec TRIPLO { #ifdef NYAG $$=_and(funbin("leq",$1,$3),funbin("leq",copia($3),$5)); #endif #ifdef PRETTY $$ = ppBoolLEQ(ppBoolLEQ($1,$3),$5); #endif } */ | exp LEQ exp { } | exp GEQ exp { } | exp NEQ exp { } | IS defTp '(' exp ')' { } | ALL '(' all ')' { } | EXIST '(' exist ')' { } | EXIST1 '(' exist1 ')' { } | BOOL { } ; FunctExp : exp SET { } | exp LIST { } | exp FSETA { } | FSETA2 exp { } | exp COMP exp { } | ID exp { } | CONSF exp { } | expFAlist { } | expFPlist { } | TOUT SIMB { } | TOUT SIMB '(' exp ')' { } | TIN SIMB { } | TIN SIMB '(' exp ')' { } ; expFAlist : exp FADD exp { } | expFAlist FADD exp { } ; expFPlist : exp FPROD exp { } | expFPlist FPROD exp { } ; all : SIMB PERTENCE exp ',' all { } | SIMB PERTENCE exp ':' exp { } | '(' SIMB SETA SIMB ')' PERTENCE exp ':' exp { } ; exist : SIMB PERTENCE exp ',' exist { } | SIMB PERTENCE exp ':' exp { } | '(' SIMB SETA SIMB ')' PERTENCE exp ':' exp { } ; exist1 : SIMB PERTENCE exp ',' exist1 { } | SIMB PERTENCE exp ':' exp { } | '(' SIMB SETA SIMB ')' PERTENCE exp ':' exp { } ; /*--( Set e Seq )----------------------------------------------------*/ setexp : '{' compreensao '}' { } | '{' extensao '}' { } | '{' '}' { } | exp INTER exp { } | exp UNION exp { } | exp '-' exp { } ; compreensao : exp '|' fromlist { } ; compreensao2 : exp '|' fromlist2 { } ; extensao : extensao ',' exp { } | exp { } seqexp2 : compreensao2 { } | extensao ',' exp '>' { } | exp '>' { } | '>' { } | exp ':' exp '>' { } ; seqexp : '<' {in_sequence++ ;} seqexp2 { } | exp '^' exp { } ; fromlist : from ',' fromlist { } | from { } ; fromlist2 : from ',' fromlist2 { } | from2 { } ; from : SIMB PERTENCE exp { } | SIMB PERTENCE exp ':' exp { } ; from2 : SIMB PERTENCE exp '>' { } | SIMB PERTENCE exp ':' exp '>' { } ; /*--( Funcoes finitas e relacoes binarias )--------------------------*/ ffexp : '[' ffcompreensao ']' { } | '[' exppairlist ']' { } | exp PLUS exp { } ; ffcompreensao : exp SETA exp '|' fromlist { } ; exppairlist : exppairlist ',' exppair { } | exppair { } | { } ; exppair : exp SETA exp { } ; relexp : RELBEGIN ffcompreensao RELEND { } | RELBEGIN exppairlist RELEND { } ; explist : exp ',' explist { } | exp { } | { } ; /*--( Expressoes condicionais )--------------------------------------*/ letexp : LET '(' deflist ')' IN exp %prec LET { } ; deflist : def ',' deflist { } | def { } | comdef ',' deflist { } | comdef { } ; comdef : '<' SIMB ',' SIMB GTs '=' exp { } | '<' SIMB ',' SIMB ',' SIMB GTs '=' exp { } ; def : SIMB '=' exp { } | SIMB '(' explist ')' '=' exp { } | '=' exp { } ; ifexp : IF exp THEN exp { } | IF '(' expcaselist { } | IF exp THEN exp ELSE exp { } ; expcaselist : casepair ',' expcaselist { } | casepair ')' { } | ELSE SETA exp ')' { } | casepair ')' OTHER exp { } ; casepair : exp SETA exp { } | is_exp ; is_exp: exp IS '<' SIMB ':' SIMB GTs SETA exp { } | exp IS '<' GTs SETA exp { } | exp IS '{' SIMB ':' SIMB '}' SETA exp { } | exp IS '{' '}' SETA exp { } | exp IS '[' SIMB SETA SIMB ':' SIMB ']' SETA exp { } | exp IS '[' ']' SETA exp { } | exp IS tag ':' SIMB SETA exp { } ; GTs : '>' | GT ; tag : INTEGER /*DANGER ?*/ | SIMB ; %% /* ---(Analisador lexico )----------------------------------------------*/ #include extern jmp_buf xljmpbuf ; #include "lex.yy.c" /* ---(Funcoes auxiliares)----------------------------------------------*/ void met(char s[]) { strcat(strcpy(straux,s),".met"); } char *aspas(char *s) {char *aux; aux=(char *) malloc(strlen(s)+3); return(strcat(strcat(strcpy(aux,"\""),s),"\"")); } #ifdef __TURBOC__ #define NAOBUF #else #define NAOBUF(f1,f2) setbuf(f1,NULL); setbuf(f2,NULL); fflush(f1); fflush(f2); /* #define NAOBUF setvbuf(yyout,buff,_IOLBF,BUFSIZ) #define NAOBUFi setvbuf(stdin,buff,_IOLBF,BUFSIZ) */ #endif /* __TURBOC__ */ /* ---(main )-----------------------------------------------------------*/ FILE *ftags; char fichin[100]; char buff[BUFSIZ]; char buffi[BUFSIZ]; int _ERRO=0; char *FILENAME=""; #ifdef FUNC char * S_GLOBI; char * S_GLOBO; int seca(S,S2) char * S; char * S2; { _ERRO=0; line_read=(char*)NULL; S_GLOBI=S; S_GLOBO=S2; clear_metoobuf(); yyparse(); return(_ERRO); } /* ---(Tratamento de erros em FUNC)-------------------------------------*/ void erro(char *s){ _ERRO=1;} void yyerror(char *s) {_ERRO=1;} #else /*FUNC*/ #include int jjexist(char* s){ FILE *aux; int r; aux = fopen(s,"r"); if(aux){fclose(aux); r=1;} else {errno= r = 0;} return r; } extern int neverprompt; main (int argc,char *argv[]) { #ifdef INTERACTIVE int i; char S[200]; #ifdef PIPE neverprompt=1; NAOBUF(stdin,stdout); #endif /*PIPE*/ tags( ftags=fopen("tags.aux","a")); #ifndef PIPE printversion(); printf("camila version %s (%s)\n",cam_version, cam_date); #endif /*PIPE*/ libxminit(0,NULL); /* inicia xmetoo */ sprintf(S,"%s/.metoorc",getenv("HOME")); if(getenv("HOME") && jjexist(S)) { sprintf(S,"(load \"%s/.metoorc\")",getenv("HOME")); libxmevalstr(S); #ifndef PIPE puts(S+7); #endif /*PIPE*/ } else { /* printf ("Erro: cant find metoorc; continuing anyway\n"); */ } if((argc ==3) && (!strcmp(argv[1],"-n"))) { #ifdef PIPE yyin=fopen(argv[2],"r"); #else /*PIPE*/ freopen(argv[2],"r",stdin); #endif /*PIPE*/ FILENAME = strdup(argv[2]); yyout = stdout; queres_comentarios=0; NAOBUF(yyin,yyout); } else if((argc ==2) && (!strcmp(argv[1],"-n"))) { yyout = stdout; queres_comentarios=0; NAOBUF(stdin,yyout); } else for(i=1; i< argc ; i++) { if(! neverprompt) puts(argv[i]); sprintf(S,"(def _FILENAME \"%s\" ) ",argv[i]); libxmevalstr(S); if(strcmp((char*)(argv[i] + strlen(argv[i]) -4),".met")==0) sprintf(S,"(load \"%s\" ) ",argv[i]); else sprintf(S,"(nload \"%s\" ) ",argv[i]); libxmevalstr(S); } yyparse(); #else /*INTERACTIVE */ if((argc ==3) && (!strcmp(argv[1],"-n"))) { yyin = fopen(argv[2],"r"); FILENAME = strdup(argv[2]); fprintf(stderr,"DEBUG1: %s %s %s\n",argv[0],argv[1], argv[2]); yyout = stdout; queres_comentarios=0; NAOBUF(yyout,yyin); yyparse(); } else if((argc ==2) && (!strcmp(argv[1],"-n"))) { yyin = stdin; yyout = stdout; NAOBUF(yyout,yyin); FILENAME = strdup(""); fprintf(stderr,"DEBUG2: %s -n\n",argv[0]); queres_comentarios=0; yyparse(); } /* tags : seca -t file else if((argc ==3) && (!strcmp(argv[1],"-t"))) { _accao = 2; yyin = fopen(argv[2],"r"); FILENAME = strdup(argv[2]); if(yyin) { ftags=fopen("tags.aux","a"); queres_comentarios=0; strcpy(fichin,argv[2]); yyparse(); } else fprintf(stderr,".can't open file '%s'\n",argv[3]); } */ /* prettyp : seca -p infile outfile */ else if((argc == 4) && (!strcmp(argv[1],"-p"))) { _accao = 3; yyin = fopen(argv[2],"r"); FILENAME = strdup(argv[2]); if(yyin) { yyout = fopen(argv[3],"w+"); yyparse();} else fprintf(stderr,"..can't open file '%s'\n",argv[2]); } /* nyag : seca filein fileout */ else if(argc == 3) { _accao = 1; yyin = fopen(argv[1],"r"); FILENAME = strdup(argv[1]); if(yyin) { yyout = fopen(argv[2],"w+"); yyparse();} else fprintf(stderr,"...can't open file '%s'\n",argv[1]); } /* nyag : seca file */ else if(argc ==2) { _accao = 1; yyin = fopen(argv[1],"r"); FILENAME = strdup(argv[1]); if(yyin) yyparse(); else fprintf(stderr,"....can't open file '%s'\n",argv[1]); } else if(argc == 1) yyparse(); else fprintf(stderr,"Use:\n%s [filein [fileout]]\n -p filein fileout\n -t filein\n",argv[0]); return _ERRO; #endif /*INTERACTIVE */ } /* ---(Tratamento de erros )--------------------------------------------*/ void erro(char *s) { _ERRO=1;fprintf(stderr,"%s %d : semantic ERROR: %s\n",FILENAME, yylineno,s);} void yyerror(char *s) { _ERRO=1;fprintf(stderr,"%s %d : syntatic ERROR detected in '%s'\n", FILENAME, yylineno,yytext);} #endif /*FUNC */ yywrap() { return (1);} /* ---(Tratamento de tipos )--------------------------------------------*/ #include "secatipo.c" /*---(Gerador de TAGS )------------------------------------------------ */ static char func_name[30]; void gera_tag_pair(char *nome) { printf("invocada - %s\n",nome); } void geratag(char *nome) { fprintf(ftags,"%s %s /FUNC\\ [ ]\\ *\\ <%s\\ >/\n",nome,fichin,nome); printf(" %s\n\n",nome); }