COP3402Fall2011: KoolRefParser.c

#include "KoolRefCommon.h"
#include "KoolRefParser.h"

/**
 * Basic initialization of all variables and data structures.
 */
void basicinit(void) {
   symtab[0].nesting=NONE;                                              /* fake to not match current level */
   nesting = GLOBAL;                                                    /* nesting of global declarations is global */
   
   /* Enter main slot for pseudo class that encompasses main body of code and global declarations */
   strcpy(symtab[MAINSLOT].name, "*MAIN*");
   symtab[MAINSLOT].nesting = nesting;                  /* global */
   symtab[MAINSLOT].type = CLASS_TYPE;                  /* main entry is pseudo class */
   symtab[MAINSLOT].cls = MAINSLOT;                             /* class of main slot is self */
   symtab[MAINSLOT].sym.clazz.num_args = 0;             /* no arguments to main body */
   symtab[MAINSLOT].sym.clazz.base = 1;                 /* class of main slot is self */
   
   /* Enter int slot for pseudo class used presently by all varaibles */
   strcpy(symtab[INTSLOT].name, "INT"); 
   symtab[INTSLOT].nesting = nesting;                   /* global */
   symtab[INTSLOT].type = CLASS_TYPE;                   /* int entry is pseudo class */
   symtab[INTSLOT].cls = INTSLOT;                               /* INT class is self */
   symtab[INTSLOT].sym.clazz.num_args = 0;              /* no arguments; actually no method */
   symtab[INTSLOT].sym.clazz.base = 1;
   
   symsize = INTSLOT;                                                   /* Index of last symbol table slot (some reserved) */
   code[0].opcode[0] = '\0';                                    /* null entry for first triple */
   showStart = 2;                                                               /* Index of next code slot that has yet to be dumped */
   triple = 1;                                                                  /* Index of first available code slot */
   constSize = 0;                                                               /* index of next available constant pool slot */
   decl_size = 0;                                                               /* space for variable section */
   errorNo = 0;                                                                 /* Number of errors detected */
   warnNo = 0;                                                                  /* Number of warnings given */
}


/**
 * Enter new identifier into symbol table (can be of any type).
 */
void enter(void) {
   if (++symsize < SYM_MAX) {
      strcpy(symtab[symsize].name, idname); 
      symtab[symsize].nesting = nesting;
      symtab[symsize].cls = INTSLOT;
      yylval.ival = symsize;
   }
   else fatal("Symbol table overflow");
}


/**
 * Store class in symbol table.
 */
void store_class(void) {
   enter();
   symtab[symsize].type = CLASS_TYPE;
   symtab[symsize].cls = symsize;
   symtab[symsize].sym.clazz.num_args = 0;
   symtab[symsize].sym.clazz.base = triple;
   currclass = symsize;
   decl_size = 0;
}

/**
 * Store variable in symbol table.
 */

void store_var(int size) {
   enter();
   symtab[symsize].type = VAR_TYPE;
   symtab[symsize].nesting = nesting;
   symtab[symsize].sym.var.base = ++decl_size;
   symtab[symsize].sym.var.size = size;
   if (size>1) decl_size += size-1;
}


/**
 * Store formal parameter in symbol table.
 */
void store_formal(void) {
   enter();
   symtab[symsize].type = FORMAL_TYPE;
   symtab[symsize].cls = INTSLOT;
   symtab[currclass].sym.clazz.num_args++;
   symtab[symsize].sym.var.base = ++decl_size;
   symtab[symsize].sym.var.size = 0;
}


/**
 * Backpatch second operand of triple stored in code table.
 * This would be used to modify jump instructions for while/for/if constructs.
 * 
 * @param triple Triple location in code table that should be modified.
 * @param val New value for second operand.
 */
 void backpatch(int trip, int val) {
  code[trip].second = val;
}


/**
 * Backpatch first operand of triple stored in code table.
 * This is used for jump statements in else case.
 * 
 * @param triple Triple location in code table that should be modified.
 * @param val New value for first operand.
 */
 void backpatch1(int trip, int val) { /* for backpatch the first field */
  code[trip].first = val;
}

/**
 * Check if triple is already available (for code optimization).
 * 
 * @param opcode Triple operation mnemonic.
 * @param first First operand.
 * @param second Second operand.
 * @return 0 if new triple, otherwise location of existing triple in code table.
 */
int redundant(char *opcode, int first, int second) { /* checks if triple already available */
   int i;
   if (strcmp(opcode, "CON") == 0) { /* just doing CON as an example */
      for (i=0; i<constSize; i++)
         if (first == const_pool[i].value) return(const_pool[i].triple);

      if (constSize<CONST_MAX) {
         const_pool[constSize].value = first;
         const_pool[constSize].triple = triple;
         constSize++;
      }
      return(0);
   }
   return(0);
}


/**
 * Generates code and handles variable read/write reference count.
 * 
 * @param opcode Triple operation mnemonic.
 * @param prefix1 Memory('M') or Stack('S') location of first operand.
 * @param first First operand.
 * @param prefix2 Memory('M') or Stack('S') location of second operand.
 * @param second Second operand.
 * @return 0 if code table is full, otherwise the location of generated code triple.
 */
 int emit(char *opcode, char prefix1, int first, char prefix2, int second) { /* generates code and handles var count */
   int old_triple;
   old_triple = redundant(opcode, first, second); 
   if (old_triple>0) return(old_triple);
   if (triple<CODE_MAX) {
      code[triple].prefix1 = prefix1;
      code[triple].first = first;
      code[triple].prefix2 = prefix2;
      code[triple].second = second;
      strcpy(code[triple].opcode, opcode);
      return(triple++);
   }
   else {
      fatal("code table is too large\n");
      return(NONE);
   }
}


void ok(int extra) {
   while ((nextToken!=WHILE) && (nextToken!=FOR) && 
                  (nextToken!=IF) && (nextToken!=SEMICOLON) && 
                  (nextToken!=extra) && (nextToken!=ENDOFFILE) ) nextToken = yylex();
}


/**
 * Print symbol table.
 */
 void dump_sym(void) {
   int i;
   printf("\n\nSYMBOL TABLE (size = %d)", symsize);
   for(i=1; i<=symsize;i++) {
      printf("\n%3d: ", i);
      printf("\t%8s",symtab[i].name);
      printf("\t%s ",type_names[symtab[i].type]);
      printf("\t%s ",nest_names[symtab[i].nesting]);
      if (symtab[i].type == NONE)
         printf("\t\tBase=%d", symtab[i].sym.clazz.base);       
      else if (symtab[i].type == CLASS_TYPE) { 
                 printf("\t\tBase=%d", symtab[i].sym.clazz.base);
                 printf(", Args=%d", symtab[i].sym.clazz.num_args);
                 printf(", Locals=%d", symtab[i].sym.clazz.local_space);
      }
      else { /* var or parm */
         printf("\tClass=%s",symtab[symtab[i].cls].name);
         printf("\tBase=%d",symtab[i].sym.var.base);
         printf(", Size=%d",symtab[i].sym.var.size);
      }
   }
   printf("\n\n");
}


/**
 * Print code table.
 * @param final If set, this means to produc output file for interpreter
 */
 void dumpcode(int final) {
  int i, p1, p2;
  final = final && (interp != NULL);
  /* header record is first instruction, number of instructions, size of globals, size of stack */
  if (final) 
    fprintf(interp, "%d %d %d %d\n", symtab[MAINSLOT].sym.clazz.base, triple-1, globals, DEFAULT_STACK); 
  printf("\n");
  for (i=showStart;i<triple;i++) {
    printf("%4d: %-8s %c%-3d %c%-3d\n",i,code[i].opcode,p1=code[i].prefix1,code[i].first,p2=code[i].prefix2,code[i].second);
    if (final) 
      fprintf(interp, "%-8s %c%-3d %c%-3d\n",code[i].opcode,p1==' ' ? '#':p1,code[i].first,p2==' ' ? '#':p2,code[i].second);
  }
  showStart = triple;
}


/**
 * Some fatal error occured (when data structures are full).
 * @param s String describing fatal error.
 */
 void fatal(char const *s) {
  printf("nFatal Error: %s\n",s);
  dumpcode(0);
}



 /**
 * Some error occured.
 * @param s String describing error.
 */
 void error(char const *s) {
  printf("\nError: %s\n", s);
  errorNo++; 
}


/**
 * Some warning occured.
 * @param s String describing warning.
 */
 void warning(char const *s) {
  printf("\nWarning: %s\n", s);
  warnNo++; 
}


/**
 * Bison error function. Simply prints error message.
 * @param s Error string to print.
 */
 void yyerror(char const *s) {
  printf("%s\n", s);
}

/**
 * Main function of your recursive descent parser.
 *
 * Read token by token here and implement a recursive-descent parser based on that information.
 * In essence, you should have one function per non-terminal and parse the input token by token.
 * Based on the currently applied grammar production rule, match the input and call the appropriate
 * functions if non-terminals are encountered.
 * This function only reads token-by-token from the lexical analyzer and prints it right now. You have
 * to write the rest of the parsing algorithm.
 *
 * @param argc Number of command-line parameters.
 * @param argv Command-line arguments as strings.
 */
int main(int argc, char **argv ) 
{
        ++argv, --argc; /* skip over program name */

        /* This should be the code you use when you actually write a parser
        if ( argc > 0 ) { 
                yyin = fopen(argv[0], "r"); interp = fopen(strcat(argv[0],".interp"), "w"); 
        } else { 
                yyin = stdin; interp = fopen("kbinput.interp", "w"); 
        }
        yyparse();
        */
        if ( argc > 0 ) 
                yyin = fopen( argv[0], "r" );
        else 
                yyin = stdin;

        /* Simply read token-by-token and print it out */
        program ();
        /*
        while(nextToken = yylex()) {
                printf(" {%s", yytokenstring[nextToken]);
                if (nextToken == NUMBER) 
                        printf(" = %d", yylval.ival);
                else if (nextToken == IDENT) 
                        printf(" = %s", idname);
                printf("}");
        }
        */

        system("pause()");
        return(0);
}

int accept (int symbol) {
        if (nextToken == symbol) {
                nextToken = yylex ();
                return 1;
        }
        return 0;
}

int expect (int symbol) {
        if (accept (symbol)) return 1;
        error ("expect: unexpected symbol");
        return 0;
}

void program (void) {
        startup ();
        declsection ();
        classes ();
        expect (LBRACE);
        statementlist ();
        expect (RBRACE);
}

void startup (void) {
        basicinit ();
}

void declsection (void) {
        if (nextToken == INT || nextToken == error) {
                decl ();
                declsection ();
        }
}

void decl (void) {
        var_start = symsize + 1;
        if (nextToken == INT) {
                type ();
                varlist ();
                expect (SEMICOLON);
                for (int i = var_start; i <= symsize; i++) {
                        /* update symbol table with value */
                }
        } else {
                error ("Message");
        }
}

void type (void) {
        if (accept (INT)) {
                /* set cval */
        }
        else {
                error ("Message");
        }
}

void varlist (void) {
        vardef ();
        if (accept (COMMA)) {
                varlist ();
        }
}

void vardef (void) {
        if (accept (IDENT)) {
                if (accept (LBRACK)) {
                        expect (NUMBER);
                        expect (RBRACK);
                        /* Update symbol table and store var number */
                } else if (accept (IDENT)) {
                        /* update symbol table */
                } else {
                        error ("Message");
                }
        }
}

void classes (void) {
        if (nextToken == CLASS) {
                classdef ();
                classes ();
        }
}

void classdef (void) {
        if (nextToken == CLASS) {
                classheader ();
                expect (LBRACE);
                methodsection ();
                expect (RBRACE);
        } else {
                error ("Message");
                expect (RBRACE);
        }
}

void classheader (void) {
        expect (CLASS);
        expect (IDENT);
        /* update nesting and tables */
}