compiler-the-translators/src/grammar.y

%{
  #include <stdio.h>
  #include "../src/symbol_table.c"
  extern int yylex(void);
  void yyerror(const char *err);
  extern char* yytext;
  extern int yyleng;
  extern int yychar;
  extern SymbolTable * cur;
  //char* cur_value;
  //char* cur_type;
  int token_tracker;
  extern int line_number;
  extern int column_number;
  extern FILE * yyin;
%}
//%define api.location.type {location_t}
%locations
%union {
        int integ;
        char * words;
}

//need subtraction only here
%type <words> id_or_types
%type <words> types
%token <words> ID       101
%token <words> T_INTEGER        201
%token <words> T_ADDRESS        202
%token <words> T_BOOLEAN        203
%token <words> T_CHARACTER      204
%token <words> T_STRING         205
%token C_INTEGER        301
%token C_NULL           302
%token C_CHARACTER      303
%token C_STRING         304
%token C_TRUE           305
%token C_FALSE          306
%token WHILE            401
%token IF               402
%token THEN             403
%token ELSE             404
%token TYPE             405
%token FUNCTION         406
%token RETURN           407
%token EXTERNAL         408
%token AS               409
%token L_PAREN          501
%token R_PAREN          502
%token L_BRACKET        503
%token R_BRACKET        504
%token L_BRACE          505
%token R_BRACE          506
%token SEMI_COLON       507
%token COLON            508
%token COMMA            509
%token ARROW            510
%token MUL              603
%token DIV              604
%token REM              605
%token ADD              601
%token LESS_THAN        606
%token EQUAL_TO         607
%token AND              610
%token OR               611
%token ASSIGN           608
%token SUB_OR_NEG       602
%token NOT              609
%token DOT              612
%token RESERVE          613
%token RELEASE          614
%token COMMENT          700

//precedence order
%precedence RESERVE RELEASE
%precedence DOT
%precedence UMINUS
%precedence NOT
%left MUL DIV REM
%left ADD SUB_OR_NEG
%left LESS_THAN
%left EQUAL_TO
%left AND
%left OR
%left ASSIGN

%%

program:
          prototype_or_definition_list
        ;

prototype_or_definition_list:
          prototype prototype_or_definition_list
        | definition prototype_or_definition_list
        | prototype
        | definition
        ;

prototype:
          L_PAREN EXTERNAL R_PAREN FUNCTION ID COLON ID;

definition:
          TYPE ID COLON dblock
        | TYPE ID COLON constant ARROW ID
        | function_declaration
        | TYPE ID COLON id_or_types ARROW id_or_types
        | ID parameter ASSIGN sblock
        ;

function_declaration:
          FUNCTION ID COLON ID
        | EXTERNAL FUNCTION ID COLON ID
        ;

parameter:
          L_PAREN ID R_PAREN
        | AS L_PAREN idlist R_PAREN
        ;

idlist:
          ID COMMA idlist
        | ID
        ;

sblock:
          L_BRACE {cur = CreateScope(cur,@1.first_line,@1.first_column);} statement_list {cur = getParent(cur);} R_BRACE
        | L_BRACE {cur = CreateScope(cur,@1.first_line,@1.first_column);} dblock statement_list {cur = getParent(cur);} R_BRACE
        ;

dblock:
          L_BRACKET declaration_list R_BRACKET;

declaration_list:
          declaration SEMI_COLON declaration_list
        | declaration
        ;

declaration:
          id_or_types COLON ID {CreateEntry(cur,$1,$3); }
        ;

id_or_types:
          ID
        | types
        ;

statement_list:
          compound_statement statement_list
        | compound_statement
        | simple_statement SEMI_COLON statement_list
        | simple_statement SEMI_COLON
        ;

compound_statement:
          WHILE L_PAREN expression R_PAREN sblock
        | IF L_PAREN expression R_PAREN THEN sblock ELSE sblock
        | sblock
        ;

simple_statement:
          assignable ASSIGN expression
        | RETURN expression
        ;

assignable:
          ID
        | assignable ablock
        | assignable rec_op ID
        ;

rec_op :
          DOT

expression:
          constant
        | SUB_OR_NEG expression %prec UMINUS
        | NOT expression
        | expression ADD expression
        | expression SUB_OR_NEG expression
        | expression MUL expression
        | expression DIV expression
        | expression REM expression
        | expression AND expression
        | expression OR expression
        | expression LESS_THAN expression
        | expression EQUAL_TO expression
        | assignable
        | L_PAREN expression R_PAREN
        | memOp assignable
        ;

ablock:
          L_PAREN argument_list R_PAREN
        ;

argument_list:
          expression COMMA argument_list
        | expression
        ;


memOp:
          RESERVE
        | RELEASE
        ;


constant:
          C_STRING
        | C_INTEGER
        | C_NULL
        | C_CHARACTER
        | C_TRUE
        | C_FALSE
        ;

types:
          T_STRING
        | T_INTEGER
        | T_ADDRESS
        | T_CHARACTER
        | T_BOOLEAN
        ;

%%

void yyerror(const char *err) {
   fprintf(stderr, "ERROR: %s at token %s at line number %d,column number %d\n", err,yytext,yylloc.first_line,yylloc.first_column);
}
/*
int main(int argc, char * argv[]) {
        token_tracker = 1;
        cur=CreateScope(NULL,1,1);
        //int a;
        FILE * fp;
        if(argc > 1){
                fp = fopen(argv[1], "r");
                yyin = fp;
        } else {
                fp = stdin;
                yyin = fp;
        }
        yyparse();
        //while ((a = yyparse() != EOF){
        //      token_tracker++;
                //printf("%d = a: yytext = %s: yychar = %d, token number: %d\n", a, yytext, yychar,token_tracker);
                 //if(yytext[0] == '\n'){
                        FILE* f = fdopen(1,"w");
                        print_symbol_table(getAncestor(cur),f);
                        fclose(f);
                //      break;
                //}
        //}
        return 0;
} */