%{
#include <malloc.h>
#include <string.h>
#include "attr.h"
int yylex();
void yyerror(char* s);
#include "symtab.h"
/* Global variables */
scopeEntry current = NULL;  /* Points to current scope */
scopeEntry temp = NULL;     /* Used temporarily for adding and/or
			       removing scopes */
%}

%union { int number;
	 tokentype token;
	 BaseType basetype;
	 typeinfo totaltype;
	 namelist names;
	 expnode exps;
	 explist elist;}

%token PROG PERIOD PROC FUNC VAR ARRAY RANGE OF
%token INT CHAR BOOL WRITELN THEN ELSE IF DO WHILE
%token BEG END ASG NOT TRUE_TOK FALSE_TOK
%token <token> ID CCONST ICONST

%type <basetype> stype
%type <totaltype> type exp constant lhs var
%type <names> idlist vardcl vardcls parmlist parms parm variables
%type <elist> explist optexplist

%start program
%nonassoc '=' NEQ LT LEQ GEQ GT
%left '+' '-' OR
%left '*' AND DIV
%right NOT

%%
program : PROG ID
        { enterblock(); }
        ';' block PERIOD 
        {leaveblock();};

block : variables
      {
      /* Seen all the variables so declare them in the current scope */
	 symTabEntry s;
         namenode tmpnode;

	 tmpnode = $1.firstname;
	 while ( tmpnode != NULL )
	 {
            if ( lookup( tmpnode -> name , current ) == NULL )
	    {
 	       s = declare(tmpnode -> name,tmpnode -> idtype.basetype,
		       tmpnode -> idtype.gentype,tmpnode -> ptype,
                       tmpnode -> idtype.number, tmpnode -> idtype.endnum);
	    }
            else
	       printf("\n***Error: duplicate declaration of %s\n", tmpnode ->
		      name);
	    tmpnode = tmpnode -> next;
	 }
      }
      procdcls cmpdstmt;

procdcls : procdcls procdcl | /* empty */ ;

procdcl : PROC ID 
        {  
	   symTabEntry find;

	   if (lookup($2.str,current) == NULL)
	      find = declare($2.str,VOIDTYPE,PROCTYPE,NOTPARM,-1,-1);
	   /* Just make a spot in the outerscope to hold the name of the */
	   /* procedure */
	   else
	      printf("\n***Error: duplicate declaration of %s\n",$2.str);
	   enterblock();
           procentry($2.str,PROCTYPE);
	} 
        parmlist
        {           /* After we have seen the parmlist, install it and */
           int n;   /* update the number field */
	   
	   n = installparms($4);
	   current -> procedure -> number = n;
        }
        ';' block ';'
        {
	   symTabEntry find;
	   
	   find = lookup($2.str, current -> outerscope);  /* Before we leave the block */
	   if ( find != NULL )                            /* We must transfer the link */
	   {                                              /* to the outer scope        */
	      find -> number = current -> procedure -> number;
	      find -> formals = current -> procedure -> formals;
	   }
           leaveblock();
	}
	| FUNC ID
        {   /* Same as above up until where 'stype' is */
	   symTabEntry find;
	   if (lookup($2.str,current) == NULL)
	      find = declare($2.str,VOIDTYPE,FUNCTYPE,NOTPARM,-1,-1);
	   else
	      printf("\n***Error: duplicate declaration of %s\n",$2.str);
	   enterblock();
           procentry($2.str,FUNCTYPE);
        } 
        parmlist
        {
	   int n;
	   
	   n = installparms($4);
	   current -> procedure -> number = n;
	}
        ':' stype ';'
         { finishfunc($7);
	   /* We NOW know what type it returns so record it */}  
	block ';'
        {
	   symTabEntry find;
	  
	   find = lookup($2.str, current -> outerscope );
	   if ( find != NULL )
	   {   /* Before we leave the block, we must make the link in the outer scope */
	      find -> number = current -> procedure -> number;
	      find -> basetype = current -> procedure -> basetype;
	      find -> formals = current -> procedure -> formals;
	   }
           leaveblock(); 
	}
	;
parmlist : '(' parms ')'
         { $$ = $2; }    /* Pass up the list of params */
	 | /* empty */
         { $$.firstname = NULL;   /* There are no params so the list is NULL */
	   $$.lastname = NULL; };

parms : parms ';' parm
        {  /* Link the current list to the new parmlist and send it up */
	   $1.lastname -> next = $3.firstname;
	   $$.firstname = $1.firstname;
	   $$.lastname = $3.lastname;
	}
	| parm   
        { $$ = $1; }; /* Send up the base case */

parm :  VAR vardcl	                  
        {  /* We know that these are pass by reference so record
	      it in all the nodes */
	   namenode tmpnode;
	   
	   tmpnode = $2.firstname;
	   while ( tmpnode != NULL )
	   {
	      tmpnode -> ptype = REFPARM;
	      tmpnode = tmpnode -> next;
	   }
	   $$ = $2; /* Send up the new list */
	}
	| vardcl                          
        {  /* We know that these are pass by value so record
	      it in all the nodes */
	   namenode tmpnode;
	   
	   tmpnode = $1.firstname;
	   while ( tmpnode != NULL )
	   {
	      tmpnode -> ptype = VALPARM;
	      tmpnode = tmpnode -> next;
	   }
	   $$ = $1; /* Send up the new list */
	};

variables: /* empty */ 
        { $$.firstname = NULL;  /* No variables = no list */
	  $$.lastname = NULL; }
	| VAR vardcls           /* Pass up the list of variables */
        { $$ = $2; };

vardcls	: vardcls vardcl ';'
        {  /* Concatenates the 2 namelists */
           $1.lastname -> next = $2.firstname;
	   $$.firstname = $1.firstname;
	   $$.lastname = $2.lastname;
        }
	| vardcl ';'
        { $$ = $1; };
vardcl	: idlist ':' type
        {  /* We have a list of IDs and we have their type so
	      we can now record them to be all of the same type */
	   namenode tmpnode;

	   tmpnode = $1.firstname;
	   while ( tmpnode != NULL )
	   {
	      tmpnode->idtype.basetype = $3.basetype;
	      tmpnode->idtype.gentype = $3.gentype;
	      tmpnode->idtype.number = $3.number;
	      tmpnode->idtype.endnum = $3.endnum;
	      tmpnode->ptype = NOTPARM;
              tmpnode = tmpnode -> next;
	   }
           $$ = $1; /* Send up the new list */
        };
idlist	: idlist ',' ID
        {  /* Hook the new ID to the current list of IDs */
	   namenode tmpname1 = NULL;

	   tmpname1 = (namenode) malloc(sizeof(struct _namenode));
	   tmpname1 -> name = $3.str;
	   tmpname1 -> next = NULL;
           $1.lastname -> next = tmpname1;
           $$.firstname = $1.firstname;
	   $$.lastname = tmpname1;
        }
        | ID
        {  /* Start the linked list with the first ID */
	   namenode tmpname1 = NULL;
	
	   tmpname1 = (namenode) malloc(sizeof(struct _namenode));
	   tmpname1 -> name = $1.str;
	   tmpname1 -> next = NULL;
	   $$.firstname = tmpname1;
	   $$.lastname = tmpname1;
        }
	;
type	: ARRAY '[' ICONST RANGE ICONST ']' OF stype
        { if ($3.num > $5.num)
	  {
	     printf("\n***Error: lower bound exceeds upper bound\n");
	     $$.basetype = $8;   /* Basetype is whatever 'stype' was */
	     $$.gentype = ARRAYTYPE;
	     $$.number = $5.num;
	     $$.endnum = $3.num;
	  }
          else
	  {
             $$.basetype = $8;   /* Basetype is whatever 'stype' was */
             $$.gentype = ARRAYTYPE;
	     $$.number = $3.num;
	     $$.endnum = $5.num;
          }
	}
	| stype
        {   
           $$.basetype = $1;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
        };

stype	: INT	                    { $$ = INTTYPE; /* Send up the basetypes */ }
	| CHAR	                    { $$ = CHARTYPE;                            }
	| BOOL	                    { $$ = BOOLTYPE;                            };

stmtlist : stmtlist ';' stmt      {   }
	| stmt                    {   };

stmt	: ifstmt                  {   }
	| wstmt                   {   }
	| astmt                   {   }
	| procstmt                {   }
	| cmpdstmt                {   }
	| writestmt               {   };

writestmt: WRITELN '(' exp ')'
        { if (( $3.basetype == INTTYPE ) || ( $3.basetype == STRINGTYPE ))
	  {  /* Must be a string or int */
	     if ( $3.gentype != NOTYPE )
	        printf("\n***Error: illegal type for writeln\n"); /* No arrays or such */
	  }
	  else
	     printf("\n***Error: illegal type for writeln\n"); /* Only ints and strings */
	};

procstmt: ID optexplist
        {
           symTabEntry s;
	   
	   s = lookupALL($1.str);
	   if ( s == NULL )       /* ID not found */
	      printf("\n***Error: undeclared identifier %s\n",$1.str);
	   else
	   {
	      if ( s -> gentype != PROCTYPE ) /* Found, but not a procedure */
	         printf("\n***Error: id %s is not a procedure\n",$1.str);
	      else
	      {  /* Found and it is a procedure so check the parameters */
		 int check;
		 check = checkparams( s -> formals , $2 );
	      }
	   }
        }
	;
ifstmt	: ifhead THEN stmt ELSE stmt
	| ifhead THEN stmt
	;
ifhead	: IF exp
        {  /* only booleans */
	   if ($2.basetype != BOOLTYPE)
	      printf("\n***Error: exp in if stmt must be boolean\n");
	}
	;
wstmt	: whead DO stmt
	;
whead	: WHILE exp
        {  /* only booleans */
	   if ($2.basetype != BOOLTYPE)
	      printf("\n***Error: exp in while stmt must be boolean\n");
	};

cmpdstmt: BEG stmtlist END;

astmt : lhs exp
        {  /* Make sure the assignment types match */
           if (!(match($1,$2)))
	      printf("\n***Error: assignment types do not match\n");
        };

lhs	: var ASG
        { $$ = $1; };

optexplist: /* empty */
        { $$.firstexp = NULL;   /* No optexplist = NULL list */
	  $$.lastexp = NULL; }
	| '(' explist ')'
        { $$ = $2; };

explist : explist ',' exp
        {  /* Hook the new expression type to the current list */
	   expnode tmpnode;
	   
	   tmpnode = makeexp($3);
	   $1.lastexp -> next = tmpnode;
	   $$.firstexp = $1.firstexp;
	   $$.lastexp = tmpnode;
        }
	| exp
        {  /* Start the list with the first expression */
	   expnode tmpnode;
	   
	   tmpnode = makeexp($1);
	   $$.firstexp = tmpnode;
	   $$.lastexp = tmpnode;
        };

exp	: exp '+' exp
        {  /* '+' requires integers */

	   if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
               ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
              printf("\n***Error: operands of '+' must be integers\n");
           $$.basetype = INTTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
        }
	| exp '-' exp
	{  /* '-' requires integers */

	   if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
               ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
              printf("\n***Error: operands of '-' must be integers\n");
           $$.basetype = INTTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
	}
	| '-' exp %prec NOT
        {  /* unary '-' requires an integer */

           if (( $2.basetype != INTTYPE ) || ( $2.gentype != NOTYPE ))
	      printf("\n***Error: right operand of '-' must be an integer\n");
	   $$.basetype = INTTYPE;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
	}
	| exp '*' exp
        {  /* '*' requires integers */

           if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
               ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
              printf("\n***Error: operands of '*' must be integers\n");
           $$.basetype = INTTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
        }
	| exp DIV exp
        {  /* DIV requires integers */

	   if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
	       ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
	      printf("\n***Error: operands of div must be integers\n");
	   $$.basetype = INTTYPE;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
        }
	| exp NEQ exp
        {  /* '<>' requires the same types AND only base types */

	   if ( $1.basetype != $3.basetype )
              printf("\n***Error: operands of '<>' have different types\n");
           if (( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
	      printf("\n***Error: operands of '<>' must be base types\n");
           $$.basetype = BOOLTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
        }
	| exp '=' exp                    
        {  /* '=' requires the same types AND only base types */

           if (($1.basetype != $3.basetype ) || ( $1.gentype != NOTYPE ) ||
               ( $3.gentype != NOTYPE ))
	      printf("\n***Error: operands of '=' have different types\n");
	   $$.basetype = BOOLTYPE;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
        }
	| exp GEQ exp                    
        {  /* '>=' requires integers */

	   if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
               ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
              printf("\n***Error: operands of '>=' must be integers\n");
           $$.basetype = BOOLTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
        }
	| exp GT exp	                 
        {  /* '>' requires integers */

	   if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
               ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
              printf("\n***Error: operands of '>' must be integers\n");
           $$.basetype = BOOLTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
        }
	| exp LT exp
        {  /* '<' requires integers */

           if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
               ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
              printf("\n***Error: operands of '<' must be integers\n");
           $$.basetype = BOOLTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1;
        }
	| exp LEQ exp
        {  /* '<=' requires integers */

	   if (( $1.basetype != INTTYPE ) || ( $3.basetype != INTTYPE ) ||
	       ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
	      printf("\n***Error: operands of '<=' must be integers\n");
	   $$.basetype = BOOLTYPE;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
        }
        | exp AND exp
        {  /* AND requires booleans */

	   if (( $1.basetype != BOOLTYPE ) || ( $3.basetype != BOOLTYPE ) ||
	       ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
	      printf("\n***Error: operands of AND must be boolean\n");
           $$.basetype = BOOLTYPE;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
        }
	| exp OR exp
        {  /* OR requires booleans */

	   if (( $1.basetype != BOOLTYPE ) || ( $3.basetype != BOOLTYPE ) ||
	       ( $1.gentype != NOTYPE ) || ( $3.gentype != NOTYPE ))
	      printf("\n***Error: operands of OR must be boolean\n");
	   $$.basetype = BOOLTYPE;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
	}
        | NOT exp
        {  /* NOT requires a boolean */

	   if (( $2.basetype != BOOLTYPE ) || ( $2.gentype != NOTYPE ))
	      printf("\n***Error: right operand of NOT must be boolean\n");
	   $$.basetype = $2.basetype;
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1;
        }
	| '(' exp ')'                    
        {  /* Simply pass up the type of the expression within the
	      parentheses */

           $$.basetype = $2.basetype;
	   $$.gentype = $2.gentype;
	   $$.number = $2.number;
	   $$.endnum = $2.endnum;
        }
	| ID '(' explist ')'                    
        {  /* This should be a function in an expression */

           symTabEntry s;     
 
           s = lookupALL($1.str);
	   if ( s == NULL )
	   {
	      printf("\n***Error: undeclared identifier: %s\n",$1.str);
	      $$.basetype = VOIDTYPE;
	      $$.gentype = NOTYPE;
	      $$.number = -1;
	      $$.endnum = -1;
	   }
	   else
	   {
	      if ( s -> gentype == FUNCTYPE ) /* Make sure it is a function */
	      {
	         int check;
		 
		 check = checkparams( s -> formals , $3 );
		 $$.basetype = s -> basetype;  /* Take the return type */
		 $$.gentype = NOTYPE;          /* of the function      */
		 $$.number = -1;
		 $$.endnum = -1;
	      }
	      else
	      {  /* Not a function : ERROR !!  */

		 printf("\n***Error: id %s is not a function\n",$1.str);
		 $$.basetype = VOIDTYPE;
		 $$.gentype = NOTYPE;
		 $$.number = -1;
		 $$.endnum = -1;
	      }
	   }
        }
	| ID                    
        {  /* This can be a variable or a function with no parameters */
 
	   symTabEntry s;

	   s = lookupALL($1.str);
	   if ( s == NULL)
	   {
	      printf("\n***Error: undeclared identifier: %s\n",$1.str);
	      $$.basetype = VOIDTYPE;
	      $$.gentype = NOTYPE;
	      $$.number = -1;
	      $$.endnum = -1;
	   }
	   else
	   {  /* No procedures allowed in expressions */

	      if (s -> gentype == PROCTYPE )
	      {
	         printf("\n***Error: illegal type for expression\n");
		 $$.basetype = VOIDTYPE;
		 $$.gentype = NOTYPE;
		 $$.number = -1;
		 $$.endnum = 1;
	      }
	      if ( s -> gentype == ARRAYTYPE )
	      {
		 $$.basetype = s -> basetype;
		 $$.gentype = ARRAYTYPE;
		 $$.number = s -> number;
		 $$.endnum = s -> endnum;
	      }
	      if ( s -> gentype == FUNCTYPE )
	      {  /* Can be a function ONLY if there are no formal parameters */

		 if ( s -> formals != NULL )
		    printf("\n***Error: too few actual parameters\n");
		 $$.basetype = s -> basetype;
		 $$.gentype = NOTYPE;
		 $$.number = -1;
		 $$.endnum = -1;
	      }
	      if ( s -> gentype == NOTYPE )
	      {
		 $$.basetype = s -> basetype;
		 $$.gentype = NOTYPE;
		 $$.number = -1;
		 $$.endnum = -1;
	      }
	   }
	}
	| ID '[' exp ']'                    
        {  /* This should be an array only */
  
	   symTabEntry s;

           s = lookupALL($1.str);
	   if ( s == NULL)
	   {
	      printf("\n***Error: undeclared identifier: %s\n",$1.str);
	      $$.basetype = VOIDTYPE;
	      $$.gentype = NOTYPE;
	      $$.number = -1;
	      $$.endnum = -1;
	   }
	   else
	   {  /* Check variable AND the subscript */

              if ( s -> gentype != ARRAYTYPE )
	         printf("\n***Error: id %s is not an array\n",$1.str);
	      if (( $3.basetype != INTTYPE ) || ( $3.gentype != NOTYPE ))
		 printf("\n***Error: subscript exp not type integer\n");
	      $$.basetype = s -> basetype;
	      $$.gentype = NOTYPE;
	      $$.number = -1;
	      $$.endnum = -1;
	   }
        }
	| constant { $$ = $1; /* Simply send up the constant's type */ };

var	: ID
        {  /* Left hand side without '[' and ']' can ONLY be a variable OR
	      the function from the CURRENT scope */

	   symTabEntry s;
	   
	   s = lookupALL($1.str);
	   if ( s == NULL)
	   {
	      printf("\n***Error: undeclared identifier: %s\n",$1.str);
	      $$.basetype = VOIDTYPE;
	      $$.gentype = NOTYPE;
	      $$.number = -1;
	      $$.endnum = -1;
	   }
	   else
	   {  /* Function can only be on the left side if it is
		 defining the current function */

	      if ( s -> gentype == FUNCTYPE )
	      {
		 if ( s == current -> procedure )
		 {
		    $$.basetype = s -> basetype;
		    $$.gentype = NOTYPE;
		    $$.number = -1;
		    $$.endnum = -1;
		 }
		 else
		 {  /* Otherwise, it is an error */

	            printf("\n***Error: function name on left side of :=\n");
		    $$.basetype = VOIDTYPE;
		    $$.gentype = NOTYPE;
		    $$.number = -1;
		    $$.number = -1;
		 }
	      }
	      else
	      {
	         if ( s -> gentype == NOTYPE )
	         {
	            $$.basetype = s -> basetype;
		    $$.gentype = NOTYPE;
		    $$.number = s -> number;
                    $$.endnum = s -> endnum;
	         }
	         else
		 {  /* No arrays or procedures on the left side */

		    printf("\n***Error: assignment to nonscalar\n");
		    $$.basetype = VOIDTYPE;
		    $$.gentype = NOTYPE;
		    $$.number = -1;
		    $$.endnum = -1;
		 }
	      }
	   }
	}
	| ID '[' exp ']'
        {  /* This should be an array AND an index */

	   symTabEntry s;

	   s = lookupALL($1.str);
	   if ( s == NULL )
	   {
	      printf("\n***Error: undeclared identifier: %s\n",$1.str);
	      $$.basetype = VOIDTYPE;
	      $$.gentype = NOTYPE;
	      $$.number = -1;
	      $$.endnum = -1;
	   }
           else
	   {  /* Check to make sure it IS an array and the index is
		 an integer */

	      if ( s -> gentype == ARRAYTYPE )
	      {
	         if (( $3.basetype != INTTYPE ) || ( $3.gentype != NOTYPE ))
		    printf("\n***Error: subscript exp is not type integer\n");
                 $$.basetype = s -> basetype;
		 $$.gentype = NOTYPE;
		 $$.number = -1;
		 $$.endnum = -1;
	      }
	      else
	      {  /* This is not an array */
		 printf("\n***Error: id %s is not an array\n",$1.str);
		 $$.basetype = VOIDTYPE;
		 $$.gentype = NOTYPE;
		 $$.number = -1;
		 $$.endnum = -1;
	      }
	   }
        };

constant: ICONST
        {  $$.basetype = INTTYPE; /* Basic integer */
	   $$.gentype = NOTYPE;
	   $$.number = -1;
           $$.endnum = -1; }
	| CCONST
        {  
	   if ( strlen($1.str) == 3 )  /* Single character */
	      $$.basetype = CHARTYPE;
	   else
	      $$.basetype = STRINGTYPE; /* String */
	   $$.gentype = NOTYPE;
	   $$.number = -1;
           $$.endnum = -1; }
	| TRUE_TOK
        { $$.basetype = BOOLTYPE;  /* TRUE and FALSE are both booleans */
	   $$.gentype = NOTYPE;
	   $$.number = -1;
	   $$.endnum = -1; }
	| FALSE_TOK
        {  $$.basetype = BOOLTYPE;
           $$.gentype = NOTYPE;
           $$.number = -1;
           $$.endnum = -1; };

%%

void
yyerror(char* s) {
    fprintf(stderr,"%s\n",s);
    }

int
main() {
    printf("1\t");
    yyparse();
    return 1;
    }