parser.y

   1 %{
   2 #include <stdio.h>
   3 #include <string.h>
   4 #include "base.h"
   5 #include "parser.h"
   6 #include "ast.h"
   7 #include "symbol_table.h"
   8
   9 /*extern char *yytext;*/
  10 extern FILE *yyin;
  11
  12 static void yyerror (/*YYLTYPE *locp, */const char *msg);
  13 /*int yylex (YYSTYPE *yylval_param, YYLTYPE *yylloc_param);*/
  14 %}
  15
  16 %defines
  17 %locations
  18 %pure-parser
  19 %error-verbose
  20 /*%parse-param {ValaParser *parser}
  21 %lex-param {ValaParser *parser}*/
  22
  23 %union {
  24     char* lexeme;
  25     int integer;
  26     int boolean;
  27     char character;
  28     int type;
  29     struct AstNode *astnode;
  30 }
  31
  32 /* Tokens */
  33 %left <lexeme> T_OR
  34 %left <lexeme> T_AND
  35 %left <lexeme> T_EQUAL T_NOTEQUAL
  36 %left <lexeme> T_LESSER T_GREATER T_LESSEREQUAL T_GREATEREQUAL
  37 %left <lexeme> T_PLUS T_MINUS
  38 %left <lexeme> T_STAR T_SLASH
  39 %left <lexeme> T_NOT
  40
  41 %token T_PROGRAM
  42 %token T_VAR
  43 %token T_PROCEDURE
  44 %token T_FUNCTION
  45 %token T_BEGIN
  46 %token T_END
  47
  48 %token T_IF
  49 %token T_THEN
  50 %token T_ELSE
  51 %token T_WHILE
  52 %token T_FOR
  53 %token T_TO
  54 %token T_DO
  55
  56 %token T_ASSIGNMENT
  57
  58 %token T_LPAR
  59 %token T_RPAR
  60 %token T_SEMICOLON
  61 %token T_COLON
  62 %token T_COMMA
  63 %token T_DOT
  64
  65 %token T_PRINT_INT
  66 %token T_PRINT_CHAR
  67 %token T_PRINT_BOOL
  68 %token T_PRINT_LINE
  69
  70 %token <type> TYPE_IDENTIFIER
  71 %token <lexeme> IDENTIFIER
  72 %token <integer> INT_LITERAL
  73 %token <boolean> BOOL_LITERAL
  74 %token <character> CHAR_LITERAL
  75
  76 /* Tipos das Regras */
  77 %type <astnode> Program
  78 %type <astnode> ProgramDecl
  79 %type <astnode> VarDeclList
  80 %type <astnode> MultiVarDecl
  81 %type <astnode> VarDecl
  82 %type <astnode> IdentifierList
  83 %type <astnode> MultiIdentifier
  84 %type <astnode> SingleIdentifier
  85
  86 %type <astnode> ProcFuncList
  87 %type <astnode> MultiProcFuncDecl
  88 %type <astnode> ProcFuncDecl
  89 %type <astnode> ProcDecl
  90 %type <astnode> FuncDecl
  91 %type <astnode> ParamList
  92 %type <astnode> SingleParam
  93 %type <astnode> MultiParam
  94
  95 %type <astnode> MainCodeBlock
  96 %type <astnode> CodeBlock
  97 %type <astnode> StatementList
  98 %type <astnode> MultiStatement
  99 %type <astnode> Statement
 100 %type <astnode> IfStatement
 101 %type <astnode> ElseStatement
 102 %type <astnode> WhileStatement
 103 %type <astnode> ForStatement
 104 %type <astnode> PrintStatement
 105 %type <astnode> PrintCharStatement
 106 %type <astnode> PrintIntStatement
 107 %type <astnode> PrintBoolStatement
 108 %type <astnode> PrintLineStatement
 109
 110 %type <astnode> Expression
 111 %type <astnode> SimpleExpression
 112 %type <astnode> NotFactor
 113 %type <astnode> Factor
 114 %type <astnode> Term
 115
 116 %type <astnode> Call
 117 %type <astnode> CallParamList
 118 %type <astnode> MultiCallParam
 119
 120 %type <astnode> Assignment
 121 %type <astnode> Identifier
 122 %type <astnode> Literal
 123
 124 %type <astnode> AddOp
 125 %type <astnode> MulOp
 126 %type <astnode> RelOp
 127 %type <astnode> NotOp
 128
 129 %start Program
 130
 131 %%
 132 Program:
 133     ProgramDecl VarDeclList ProcFuncList MainCodeBlock
 134     {
 135         Symbol *symtab;
 136         struct AstNode *ast_node;
 137         ast_node = ast_node_new("Program", PROGRAM, NONE_TYPE,
 138                                 yylloc.last_line, NULL);
 139         ast_node_add_child(ast_node, $1);
 140         ast_node_add_child(ast_node, $2);
 141         ast_node_add_child(ast_node, $3);
 142         ast_node_add_child(ast_node, $4);
 143         $$ = ast_node;
 144
 145         symtab = symbol_new(NULL);
 146         ast_node->symbol = symtab;
 147         ast_node_fill_symbol_table(ast_node, symtab);
 148
 149         //ast_node_print(ast_node);
 150         //ast_node_print_graph(ast_node, ast_node->symbol);
 151         //symbol_table_dump(ast_node->symbol);
 152     }
 153     ;
 154
 155 ProgramDecl:
 156     T_PROGRAM Identifier T_SEMICOLON
 157     {
 158         struct AstNode *ast_node;
 159         ast_node = ast_node_new("ProgramDecl", NONE_KIND, NONE_TYPE,
 160                                 yylloc.last_line, NULL);
 161         ast_node_add_child(ast_node, $2);
 162         $$ = ast_node;
 163     }
 164     ;
 165
 166 VarDeclList:
 167     /* empty */ { $$ = NULL; }
 168     | MultiVarDecl
 169     {
 170         struct AstNode *ast_node;
 171         ast_node = ast_node_new("VarDeclList", NONE_KIND, NONE_TYPE,
 172                                 yylloc.last_line, NULL);
 173         ast_node_add_child(ast_node, $1);
 174         $$ = ast_node;
 175     }
 176     ;
 177
 178 MultiVarDecl:
 179     /* empty */ { $$ = NULL; }
 180     | VarDecl MultiVarDecl
 181     {
 182         ast_node_add_sibling($1, $2);
 183         $$ = $1;
 184     }
 185     ;
 186
 187 VarDecl:
 188     T_VAR IdentifierList T_COLON TYPE_IDENTIFIER T_SEMICOLON
 189     {
 190         struct AstNode *ast_node;
 191         ast_node = ast_node_new("VarDecl", NONE_TYPE, $4,
 192                                 yylloc.last_line, NULL);
 193         ast_node_add_child(ast_node, $2);
 194         ast_node_set_type($2, $4);
 195         $$ = ast_node;
 196     }
 197     ;
 198
 199 IdentifierList:
 200     SingleIdentifier MultiIdentifier
 201     {
 202         struct AstNode *ast_node;
 203         ast_node = ast_node_new("IdentifierList", NONE_KIND, NONE_TYPE,
 204                                 yylloc.last_line, NULL);
 205         ast_node_add_sibling($1, $2);
 206         ast_node_add_child(ast_node, $1);
 207         $$ = ast_node;
 208     }
 209     ;
 210
 211 MultiIdentifier:
 212     /* empty */ { $$ = NULL; }
 213     | T_COMMA SingleIdentifier MultiIdentifier
 214     {
 215         ast_node_add_sibling($2, $3);
 216         $$ = $2;
 217     }
 218     ;
 219
 220 SingleIdentifier:
 221     Identifier { $$ = $1; }
 222     ;
 223
 224
 225 ProcFuncList:
 226     /* empty */ { $$ = NULL; }
 227     | ProcFuncDecl MultiProcFuncDecl
 228     {
 229         struct AstNode *ast_node;
 230         ast_node = ast_node_new("ProcFuncList", NONE_KIND, NONE_TYPE,
 231                                 yylloc.last_line, NULL);
 232         ast_node_add_sibling($1, $2);
 233         ast_node_add_child(ast_node, $1);
 234         $$ = ast_node;
 235     }
 236     ;
 237
 238 MultiProcFuncDecl:
 239     /* empty */ { $$ = NULL; }
 240     | ProcFuncDecl MultiProcFuncDecl
 241     {
 242         ast_node_add_sibling($1, $2);
 243         $$ = $1;
 244     }
 245     ;
 246
 247 ProcFuncDecl:
 248     ProcDecl { $$ = $1; }
 249     | FuncDecl { $$ = $1; }
 250     ;
 251
 252 ProcDecl:
 253     T_PROCEDURE Identifier T_LPAR ParamList T_RPAR T_SEMICOLON VarDeclList
 254     CodeBlock T_SEMICOLON
 255     {
 256         struct AstNode *ast_node;
 257         ast_node = ast_node_new("ProcDecl", PROCEDURE, NONE_TYPE,
 258                                 yylloc.last_line, NULL);
 259         ast_node_add_child(ast_node, $2);  // Identifier
 260         ast_node_add_child(ast_node, $4);  // ParamList
 261         ast_node_add_child(ast_node, $7);  // VarDeclList
 262         ast_node_add_child(ast_node, $8);  // CodeBlock
 263         $$ = ast_node;
 264     }
 265     ;
 266
 267 FuncDecl:
 268     T_FUNCTION Identifier T_LPAR ParamList T_RPAR T_COLON TYPE_IDENTIFIER
 269     T_SEMICOLON VarDeclList CodeBlock T_SEMICOLON
 270     {
 271         struct AstNode *ast_node;
 272         ast_node = ast_node_new("FuncDecl", FUNCTION, $7,
 273                                 yylloc.last_line, NULL);
 274         ast_node_add_child(ast_node, $2);  // Identifier
 275         ast_node_add_child(ast_node, $4);  // ParamList
 276         ast_node_add_child(ast_node, $9);  // VarDeclList
 277         ast_node_add_child(ast_node, $10); // CodeBlock
 278
 279         ast_node_set_type($2, $7);
 280
 281         $$ = ast_node;
 282     }
 283     ;
 284
 285 ParamList:
 286     /* empty */ { $$ = NULL; }
 287     | SingleParam MultiParam
 288     {
 289         struct AstNode *ast_node;
 290         ast_node = ast_node_new("ParamList", NONE_KIND, NONE_TYPE,
 291                                 yylloc.last_line, NULL);
 292         ast_node_add_sibling($1, $2);
 293         ast_node_add_child(ast_node, $1);
 294         $$ = ast_node;
 295     }
 296     ;
 297
 298 MultiParam:
 299     /* empty */ { $$ = NULL; }
 300     | T_COMMA SingleParam MultiParam
 301     {
 302         ast_node_add_sibling($2, $3);
 303         $$ = $2;
 304     }
 305     ;
 306
 307 SingleParam:
 308     Identifier T_COLON TYPE_IDENTIFIER
 309     {
 310         struct AstNode *ast_node;
 311         ast_node = ast_node_new("SingleParam", NONE_KIND, NONE_TYPE,
 312                                 yylloc.last_line, NULL);
 313         ast_node_add_child(ast_node, $1);  // Identifier
 314         ast_node_set_type(ast_node, $3);
 315         $$ = ast_node;
 316     }
 317     ;
 318
 319 MainCodeBlock:
 320     /* empty */ { $$ = NULL; }
 321     | CodeBlock T_DOT { $$ = $1; }
 322     ;
 323
 324 CodeBlock:
 325     T_BEGIN StatementList T_END { $$ = $2; }
 326     ;
 327
 328 StatementList:
 329     Statement MultiStatement
 330     {
 331         struct AstNode *ast_node;
 332         ast_node = ast_node_new("StatementList", NONE_KIND, NONE_TYPE,
 333                                 yylloc.last_line, NULL);
 334         ast_node_add_sibling($1, $2);
 335         ast_node_add_child(ast_node, $1);
 336         $$ = ast_node;
 337     }
 338     ;
 339
 340 MultiStatement:
 341     /* empty */ { $$ = NULL; }
 342     | Statement MultiStatement
 343     {
 344         ast_node_add_sibling($1, $2);
 345         $$ = $1;
 346     }
 347     ;
 348
 349 Statement:
 350     Assignment T_SEMICOLON { $$ = $1; }
 351     | IfStatement { $$ = $1; }
 352     | WhileStatement { $$ = $1; }
 353     | ForStatement { $$ = $1; }
 354     | Call { $$ = $1; }
 355     | PrintStatement { $$ = $1; }
 356     ;
 357
 358 PrintStatement:
 359     PrintIntStatement { $$ = $1; }
 360     | PrintCharStatement { $$ = $1; }
 361     | PrintBoolStatement { $$ = $1; }
 362     | PrintLineStatement { $$ = $1; }
 363     ;
 364
 365 PrintIntStatement:
 366     T_PRINT_INT T_LPAR Expression T_RPAR
 367     {
 368         struct AstNode *ast_node;
 369         ast_node = ast_node_new("PrintIntStatement", NONE_KIND, NONE_TYPE,
 370                                 yylloc.last_line, NULL);
 371         ast_node_add_child(ast_node, $3);
 372         $$ = ast_node;
 373     }
 374     ;
 375
 376 PrintCharStatement:
 377     T_PRINT_CHAR T_LPAR Expression T_RPAR
 378     {
 379         struct AstNode *ast_node;
 380         ast_node = ast_node_new("PrintCharStatement", NONE_KIND, NONE_TYPE,
 381                                 yylloc.last_line, NULL);
 382         ast_node_add_child(ast_node, $3);
 383         $$ = ast_node;
 384     }
 385     ;
 386
 387 PrintBoolStatement:
 388     T_PRINT_BOOL T_LPAR Expression T_RPAR
 389     {
 390         struct AstNode *ast_node;
 391         ast_node = ast_node_new("PrintBoolStatement", NONE_KIND, NONE_TYPE,
 392                                 yylloc.last_line, NULL);
 393         ast_node_add_child(ast_node, $3);
 394         $$ = ast_node;
 395     }
 396     ;
 397
 398 PrintLineStatement:
 399     T_PRINT_LINE T_LPAR Expression T_RPAR
 400     {
 401         struct AstNode *ast_node;
 402         ast_node = ast_node_new("PrintLineStatement", NONE_KIND, NONE_TYPE,
 403                                 yylloc.last_line, NULL);
 404         ast_node_add_child(ast_node, $3);
 405         $$ = ast_node;
 406     }
 407     ;
 408
 409 Assignment:
 410     Identifier T_ASSIGNMENT Expression
 411     {
 412         struct AstNode *ast_node;
 413         ast_node = ast_node_new("Assignment", NONE_KIND, NONE_TYPE,
 414                                 yylloc.last_line, NULL);
 415         ast_node_add_child(ast_node, $1);
 416         ast_node_add_child(ast_node, $3);
 417         $$ = ast_node;
 418     }
 419     ;
 420
 421 IfStatement:
 422     T_IF Expression T_THEN CodeBlock ElseStatement
 423     {
 424         struct AstNode *ast_node;
 425         ast_node = ast_node_new("IfStatement", NONE_KIND, NONE_TYPE,
 426                                 yylloc.last_line, NULL);
 427         ast_node_add_child(ast_node, $2);
 428         ast_node_add_child(ast_node, $4);
 429         ast_node_add_child(ast_node, $5);
 430         $$ = ast_node;
 431     }
 432     ;
 433
 434 ElseStatement:
 435     /* empty */ { $$ = NULL; }
 436     | T_ELSE CodeBlock { $$ = $2; }
 437     ;
 438
 439 WhileStatement:
 440     T_WHILE T_LPAR Expression T_RPAR T_DO CodeBlock
 441     {
 442         struct AstNode *ast_node;
 443         ast_node = ast_node_new("WhileStatement", NONE_KIND, NONE_TYPE,
 444                                 yylloc.last_line, NULL);
 445         ast_node_add_child(ast_node, $3);
 446         ast_node_add_child(ast_node, $6);
 447         $$ = ast_node;
 448     }
 449     ;
 450
 451 ForStatement:
 452     T_FOR Assignment T_TO Expression T_DO CodeBlock
 453     {
 454         struct AstNode *ast_node;
 455         ast_node = ast_node_new("ForStatement", NONE_KIND, NONE_TYPE,
 456                                 yylloc.last_line, NULL);
 457         ast_node_add_child(ast_node, $2);
 458         ast_node_add_child(ast_node, $4);
 459         ast_node_add_child(ast_node, $6);
 460         $$ = ast_node;
 461     }
 462     ;
 463
 464 Expression:
 465     SimpleExpression { $$ = $1; }
 466     | SimpleExpression RelOp SimpleExpression
 467     {
 468         struct AstNode *ast_node;
 469         ast_node = ast_node_new("RelExpression", NONE_KIND, NONE_TYPE,
 470                                 yylloc.last_line, NULL);
 471         ast_node_add_child(ast_node, $1);
 472         ast_node_add_child(ast_node, $2);
 473         ast_node_add_child(ast_node, $3);
 474         $$ = ast_node;
 475     }
 476     ;
 477
 478 SimpleExpression:
 479     Term { $$ = $1; }
 480     | SimpleExpression AddOp Term
 481     {
 482         struct AstNode *ast_node;
 483         ast_node = ast_node_new("AddExpression", NONE_KIND, NONE_TYPE,
 484                                 yylloc.last_line, NULL);
 485         ast_node_add_child(ast_node, $1);
 486         ast_node_add_child(ast_node, $2);
 487         ast_node_add_child(ast_node, $3);
 488         $$ = ast_node;
 489     }
 490     ;
 491
 492 Term:
 493     NotFactor { $$ = $1; }
 494     | Term MulOp NotFactor
 495     {
 496         struct AstNode *ast_node;
 497         ast_node = ast_node_new("MulExpression", NONE_KIND, NONE_TYPE,
 498                                 yylloc.last_line, NULL);
 499         ast_node_add_child(ast_node, $1);
 500         ast_node_add_child(ast_node, $2);
 501         ast_node_add_child(ast_node, $3);
 502         $$ = ast_node;
 503     }
 504     ;
 505
 506 NotFactor:
 507     Factor { $$ = $1; }
 508     | NotOp Factor
 509     {
 510         struct AstNode *ast_node;
 511         struct AstNode *op_ast_node;
 512         ast_node = ast_node_new("NotFactor", NONE_KIND, NONE_TYPE,
 513                                 yylloc.last_line, NULL);
 514         ast_node_add_child(ast_node, $1);
 515         ast_node_add_child(ast_node, $2);
 516         $$ = ast_node;
 517     }
 518     ;
 519
 520 Factor:
 521     Identifier { $$ = $1; }
 522     | Literal { $$ = $1; }
 523     | Call { $$ = $1; }
 524     | T_LPAR Expression T_RPAR { $$ = $2; }
 525     ;
 526
 527 Call:
 528     Identifier T_LPAR CallParamList T_RPAR
 529     {
 530         struct AstNode *ast_node;
 531         ast_node = ast_node_new("Call", NONE_KIND, NONE_TYPE,
 532                                 yylloc.last_line, NULL);
 533         ast_node_add_child(ast_node, $1);
 534         ast_node_add_child(ast_node, $3);
 535         $$ = ast_node;
 536     }
 537     ;
 538
 539 CallParamList:
 540     /* empty */ { $$ = NULL; }
 541     | Expression MultiCallParam
 542     {
 543         struct AstNode *ast_node;
 544         ast_node = ast_node_new("CallParamList", NONE_KIND, NONE_TYPE,
 545                                 yylloc.last_line, NULL);
 546         ast_node_add_sibling($1, $2);
 547         ast_node_add_child(ast_node, $1);
 548         $$ = ast_node;
 549     }
 550     ;
 551
 552 MultiCallParam:
 553     /* empty */ { $$ = NULL; }
 554     | T_COMMA Expression MultiCallParam
 555     {
 556         ast_node_add_sibling($2, $3);
 557         $$ = $2;
 558     }
 559     ;
 560
 561 AddOp:
 562     T_PLUS
 563     {
 564         struct AstNode *ast_node;
 565         ast_node = ast_node_new($1, T_PLUS, NONE_TYPE,
 566                                 yylloc.last_line, NULL);
 567         $$ = ast_node;
 568     }
 569     | T_MINUS
 570     {
 571         struct AstNode *ast_node;
 572         ast_node = ast_node_new($1, T_MINUS, NONE_TYPE,
 573                                 yylloc.last_line, NULL);
 574         $$ = ast_node;
 575     }
 576     | T_OR
 577     {
 578         struct AstNode *ast_node;
 579         ast_node = ast_node_new($1, T_OR, NONE_TYPE,
 580                                 yylloc.last_line, NULL);
 581         $$ = ast_node;
 582     }
 583     ;
 584
 585 MulOp:
 586     T_STAR
 587     {
 588         struct AstNode *ast_node;
 589         ast_node = ast_node_new($1, T_STAR, NONE_TYPE,
 590                                 yylloc.last_line, NULL);
 591         $$ = ast_node;
 592     }
 593     | T_SLASH
 594     {
 595         struct AstNode *ast_node;
 596         ast_node = ast_node_new($1, T_SLASH, NONE_TYPE,
 597                                 yylloc.last_line, NULL);
 598         $$ = ast_node;
 599     }
 600     | T_AND
 601     {
 602         struct AstNode *ast_node;
 603         ast_node = ast_node_new($1, T_AND, NONE_TYPE,
 604                                 yylloc.last_line, NULL);
 605         $$ = ast_node;
 606     }
 607     ;
 608
 609 RelOp:
 610     T_LESSER
 611     {
 612         struct AstNode *ast_node;
 613         ast_node = ast_node_new($1, T_LESSER, NONE_TYPE,
 614                                 yylloc.last_line, NULL);
 615         $$ = ast_node;
 616     }
 617     | T_LESSEREQUAL
 618     {
 619         struct AstNode *ast_node;
 620         ast_node = ast_node_new($1, T_LESSEREQUAL, NONE_TYPE,
 621                                 yylloc.last_line, NULL);
 622         $$ = ast_node;
 623     }
 624     | T_GREATER
 625     {
 626         struct AstNode *ast_node;
 627         ast_node = ast_node_new($1, T_GREATER, NONE_TYPE,
 628                                 yylloc.last_line, NULL);
 629         $$ = ast_node;
 630     }
 631     | T_GREATEREQUAL
 632     {
 633         struct AstNode *ast_node;
 634         ast_node = ast_node_new($1, T_GREATEREQUAL, NONE_TYPE,
 635                                 yylloc.last_line, NULL);
 636         $$ = ast_node;
 637     }
 638     | T_EQUAL
 639     {
 640         struct AstNode *ast_node;
 641         ast_node = ast_node_new($1, T_EQUAL, NONE_TYPE,
 642                                 yylloc.last_line, NULL);
 643         $$ = ast_node;
 644     }
 645     | T_NOTEQUAL
 646     {
 647         struct AstNode *ast_node;
 648         ast_node = ast_node_new($1, T_NOTEQUAL, NONE_TYPE,
 649                                 yylloc.last_line, NULL);
 650         $$ = ast_node;
 651     }
 652     ;
 653
 654 NotOp:
 655     T_NOT
 656     {
 657         struct AstNode *ast_node;
 658         ast_node = ast_node_new($1, T_NOT, NONE_TYPE,
 659                                 yylloc.last_line, NULL);
 660         $$ = ast_node;
 661     }
 662     ;
 663
 664 Identifier:
 665     IDENTIFIER
 666     {
 667         Symbol *symbol;
 668         struct AstNode *ast_node;
 669
 670         ast_node = ast_node_new("Identifier", IDENTIFIER, NONE_TYPE,
 671                                 yylloc.last_line, NULL);
 672         ast_node->symbol = symbol_new($1);
 673         $$ = ast_node;
 674     }
 675     ;
 676
 677 Literal:
 678     INT_LITERAL
 679     {
 680         struct AstNode *ast_node;
 681         ast_node = ast_node_new("IntLiteral", INT_LITERAL, INTEGER,
 682                                 yylloc.last_line, NULL);
 683         value_set_from_int(&ast_node->value, $1);
 684         $$ = ast_node;
 685     }
 686     | BOOL_LITERAL
 687     {
 688         struct AstNode *ast_node;
 689         ast_node = ast_node_new("BoolLiteral", BOOL_LITERAL, BOOLEAN,
 690                                 yylloc.last_line, NULL);
 691         value_set_from_bool(&ast_node->value, $1);
 692         $$ = ast_node;
 693     }
 694     | CHAR_LITERAL
 695     {
 696         struct AstNode *ast_node;
 697         ast_node = ast_node_new("CharLiteral", CHAR_LITERAL, CHAR,
 698                                 yylloc.last_line, NULL);
 699         value_set_from_char(&ast_node->value, $1);
 700         $$ = ast_node;
 701     }
 702     ;
 703
 704 %%
 705
 706 static void
 707 yyerror (/*YYLTYPE *locp,*/ const char *msg)
 708 {
 709     fprintf(stderr, "[Error] line %d: %s\n", yyget_lineno(), msg);
 710 }
 711
 712 int
 713 main(int argc, char **argv)
 714 {
 715     if (argc > 1)
 716         yyin = fopen(argv[1], "r");
 717     else
 718         yyin = stdin;
 719
 720     /*yylloc.first_line = yylloc.last_line = 1;
 721     yylloc.first_column = yylloc.last_column = 0;*/
 722
 723     return yyparse();
 724 }
 725