/****  parser.c  ***************************************************/

#include "global.h"

extern void emit(int t, int tval, float rval);
extern void error(char *m);
extern int lexan(void);
extern int GlobalInsert(char s[], int tok, int type, int size, int function,
                        int functionlabel);
extern void CheckMain(void);
extern void AllBodsParsed(void);
extern void LocalReset(void);
extern int LocalInsert(char s[], int tok, int type, int size,int function,
		       int functionlabel);
extern void ParamInt(void);
 
int term(void);
void match(int t);
int expr(void);
void PushArrayCellAddr(void);
void DeclOrF(void);
void GlobalScopeAndInsert(int type);
void GlobalVarList(int type);
void exprTest(void);
void exprAssg(void);
void parseAStmt(void);
void parse(void);
int factor(void);
void ExprList(void);
void FunctionList(void);
void FunctionDef(int type);
void MoreParams(void);
void ParamList(void);
void DecList(void);
void VarList(int type);
void FstmtList(void);

int term(void)
{
  int t; /* temporary holder of tokens */
  int leftExpr, rightExpr;

  leftExpr = factor();
  if (ErrorFlag)
    return -99;
  while(lookahead == '*' || lookahead == '/')
  {
      t = lookahead;
      match(lookahead); 
      if (ErrorFlag)
        return -99;
      rightExpr = factor(); 
      if (ErrorFlag)
        return -99;
      if (leftExpr == rightExpr)
      {
        if (leftExpr)
        {
          if (t == '*')
            emit(RMUL, 0, 0.0);
          else 
            emit(RDIV, 0, 0.0);
          leftExpr = 1;
        }
        else
        {
          if (t == '*')
            emit(MUL, 0, 0.0);
          else
            emit(DIV, 0, 0.0);         
          leftExpr = 0;
        }
      }
      else
      {
        if (leftExpr)
        {
          emit(FLOAT, 0, 0.0);
          if (t == '*')
            emit(RMUL, 0, 0.0);
          else
            emit(RDIV, 0, 0.0);
        }
        else
        {
          emit(NUM, 1, 0.0);
          emit(IST, 0, 0.0);
          emit(FLOAT, 0, 0.0);
          emit(NUM, 1, 0.0);
          emit(VAL, 0, 0.0);
          if (t == '*')
            emit(RMUL, 0, 0.0);
          else
            emit(RDIV, 0, 0.0);
        }
        leftExpr = 1;
      } /* end else leftExpr == rightExpr */
  }
  if (FloatFlag)
    return(1);
  else
    return (leftExpr);
}
/* ========================================================================= */

void match(int t) /* verify that t was the last token, then get next token */
             /* token to verify as last found */
{
  if (lookahead == t)
  {
    PreviousLookahead = lookahead;
    PreviousTokenval = tokenval;
    PreviousFtokenval = ftokenval;

    lookahead = NextLookahead;
    tokenval = NextTokenval;
    ftokenval = NextFtokenval;

    if (NextLookahead != DONE)
      NextLookahead = lexan();
  }
  else 
  {
    switch (lookahead)
    {
      case WHILE:
      case IF:
        error("Missing ; at end of previous statement");
        break;
    }
    if (ErrorFlag)
      return;
    switch (t)
    {
      case ')':
        error("Missing right parenthesis or illegal operator");
        break;
      default:
        printf("\n In default of match lookahead = %d",lookahead);
        error("syntax error");
        break;
    } /* end switch */
  }   /* else */  
}

/* ------------------------------------------------------------------- */

int expr(void)
{
  int t;  /* temporary holder of tokens */
  int leftExpr, rightExpr;

  leftExpr = term();
  if (ErrorFlag)
    return -99;
  while(lookahead == '+' || lookahead == '-')
  {
      t = lookahead;
      match(lookahead);
      if (ErrorFlag)
        return -99;
      rightExpr = term();
      if (ErrorFlag)
        return -99;
      if (leftExpr == rightExpr)
      {
        if (leftExpr)
        {
          if (t == '+')
            emit(RADD, 0, 0.0);
          else
            emit(RSUB, 0, 0.0);
          leftExpr = 1;
        }
        else
        {
          if (t == '+')
            emit(ADD, 0, 0.0);
          else
            emit(SUB, 0, 0.0);
          leftExpr = 0;
        }
      }
      else
      {
        if (leftExpr)
        {
          emit(FLOAT, 0, 0.0);
          if (t == '+')
            emit(RADD, 0, 0.0);
          else
            emit(RSUB, 0, 0.0);
        }
        else
        {
          emit(NUM, 1, 0.0);
          emit(IST, 0, 0.0);
          emit(FLOAT, 0, 0.0);
          emit(NUM, 1, 0.0);
          emit(VAL, 0, 0.0);
          if (t == '+')
            emit(RADD, 0, 0.0);
          else
            emit(RSUB, 0, 0.0);
        }
        leftExpr = 1;
      } /* end else leftExpr == rightExpr */
  }
  if (FloatFlag)
    return(1);
  else
    return(leftExpr);

}
/* ========================================================================= */


void PushArrayCellAddr(void) /* calculate address of array cell on stack */
{
  int tempTokenval;

  if ( !(ArrayParsed))
  {
    ArrayParsed = 1;
    tempTokenval = tokenval;
    if (LocalIndex)
      emit(PUSH_LOC_VAR_ADDR, LocalIndex, 0.0);
    else if (GlobalIndex)
      emit(PUSH_GLO_VAR_ADDR, GlobalIndex, 0.0);
    else
    {
      error("Compiler error, array lexeme not found in any table");
      return;
    }
    match(ARRAY);
    if (ErrorFlag)
      return;
    match('[');
    if (ErrorFlag)
      return;
    FloatFlag = 0;
    FloatFlag = expr();
    if (ErrorFlag)
      return;
    if (lookahead != ']')
    {
      error("Missing ']'");
      return;
    }
    if (FloatFlag)
    {
      error("Array index must be an integer value");
      return;
    }
    emit(ADD, 0, 0.0);
    lookahead = ARRAY;
    tokenval = tempTokenval;
  } /* end if !ArrayParsed */
  else
    ArrayParsed = 0;
} /* end PushArrayCellAddr */

/* ============================================================= */

void DeclOrF(void)
{
  int type;   /* stores type to call other functions with */
  int temp;  

  Scope = 0;  /* set scope to zero to mean global variables */
   
  while(1)
  {
    if (lookahead == ID)
    {
      emit(BEGIN, 0, 0.0);
      LabelCounter = 4; /* first 3 label used by emit BEGIN */
      /* insert an implicit call to main into the symbol tabel */
      temp = GlobalInsert ("main",ID,INT,0,1,1);
      if (ErrorFlag)
        return;
      if (strcmp("main", lexbuf) == 0)
         GlobalIndex = temp;
      FunctionDef (INT);
      if (ErrorFlag)
        return;
      return;
    }
    else if (lookahead == INT)
    {
      match (INT);
      if (ErrorFlag)
        return;
    }
    else
    {
      match (FLOAT);
      if (ErrorFlag)
        return;
    }
 
    if (NextLookahead == '(')
    {
      emit(BEGIN, 0, 0.0);
      LabelCounter = 4; /* first 3 labels used by emit BAGIN */
      /* insert an implicit call to main into the symbol tabel */
      temp = GlobalInsert ("main",ID,INT,0,1,1);
      if (ErrorFlag)
        return;
      if (strcmp("main", lexbuf) == 0)
        GlobalIndex = temp;
      FunctionDef(PreviousLookahead);
      if (ErrorFlag)
        return;
      return;
    }
    else
    {
      type = PreviousLookahead;
      GlobalScopeAndInsert (type);
      if (ErrorFlag)
        return;
      GlobalVarList (type);
      if (ErrorFlag)
        return;
      match(';');
      if (ErrorFlag)
        return;
    } /* end if != '(' */
  } /* end while(1) */
} /* end DeclOrF */

/* ============================================================= */

void GlobalScopeAndInsert(int type)
{
  int tempGlobalIndex;

  if (LocalIndex)
  {
    error("Compiler error! global lexeme found in local symbol table");
    return;
  } /* end LocalIndex */
  else if (GlobalIndex)
  {
    if (GlobalTable[GlobalIndex].function)
    {
      error("Attempting to define a function name as an identifier");
      return;
    } /* end if */

    else
    {
      error("Attempting to define a global variable twice");
      return;
    } /* end else */
  } /* end else ifGlobalIndex */
  else
  {
    if (NextLookahead == '[')
    {
      tempGlobalIndex = GlobalIndex = GlobalInsert(lexbuf, ARRAY, type,0,0,0);
      if (ErrorFlag)
        return;
      match(ID);
      if (ErrorFlag)
        return;
      match('[');
      if (ErrorFlag)
        return;
      if (lookahead == NUM)
      {
        GlobalTable[tempGlobalIndex].size = tokenval;
        match(NUM);
      }  /* end if (lookahead == num) */
      else
      {
        error("Improperly formed array definition");
        return;
      } /* end else */
      match(']');
      if (ErrorFlag)
        return;
      emit(GLO_DECL, tempGlobalIndex, 0.0);
      DecCount += GlobalTable[tempGlobalIndex].size;
    } /* end if next == '[' */
    else  /* regular ID */
    {
      GlobalIndex = GlobalInsert(lexbuf, ID, type, 1, 0, 0);
      if (ErrorFlag)
        return;
      emit(GLO_DECL, GlobalIndex, 0.0);
      ++DecCount;
      match(ID);
      if (ErrorFlag)
        return;
    } /* end else */
  } /* end else */
} /* end GlobalScopeAndInsert */

/* ============================================================= */

void GlobalVarList(int type)
{
  while (lookahead == ',')
  {
    match(',');
    if (ErrorFlag)
      return;
    if (lookahead == ID || lookahead == ARRAY)
    {
      GlobalScopeAndInsert (type);
      if (ErrorFlag)
        return;
    } /* end if ID or ARRAY */
    else
    {
      error("Expected an identifier or array");
      return;
    } /* end else */
  } /* end while loop */
} /* end GlobalVarList */

/* ============================================================= */

void exprTest(void)
{
  int tempTrue, tempDone;
  int tempOperation;
  int TempFloatFlag;

  FloatFlag = 0;
  FloatFlag = expr();
  if (ErrorFlag)
    return;

  while ((lookahead == EQUAL) || (lookahead == NEQUAL))
  {
    tempOperation = lookahead;
    if (lookahead == EQUAL)
      match(EQUAL);
    else
      match(NEQUAL);
    if (ErrorFlag)
      return;
    TempFloatFlag = FloatFlag;
    if (TempFloatFlag)
    {
      FloatFlag = 0;
      FloatFlag = expr();
      if (!(FloatFlag))
      { emit(FLOAT, 0, 0.0);
        FloatFlag = 1;
      }
    }
    else
    {
      FloatFlag = expr();
      if (FloatFlag)
      {
        emit(NUM, 1, 0.0);
        emit(IST, 0, 0.0);
        emit(FLOAT, 0, 0.0);
        emit(NUM, 1, 0.0);
        emit(VAL, 0, 0.0);
      }
    } 
    if (ErrorFlag)
      return;
    emit(COMP, 0, 0.0);
    tempTrue = LabelCounter;
    ++LabelCounter;
    tempDone = LabelCounter;
    ++LabelCounter;
    emit(PUSH_CODE_LABEL, tempTrue, 0.0);
    if (tempOperation == EQUAL)
      emit(BEQ, 0, 0.0);
    else
      emit(BNE, 0, 0.0);
    emit(NUM, 0, 0.0);
    emit(PUSH_CODE_LABEL, tempDone, 0.0);
    emit(B, 0, 0.0);
    emit(LABEL_CODE, tempTrue, 0.0);
    emit(NUM, 1, 0.0);
    emit(LABEL_CODE, tempDone, 0.0);
  } /* end if */
} /* end exprTest */

/* ========================================================================= */

void exprAssg(void)
{
  int  tempLocalIndex, tempGlobalIndex; /* temp indices during recursion */

  switch (lookahead)
  {
    case ARRAY:
      tempLocalIndex = LocalIndex;
      tempGlobalIndex = GlobalIndex;
      PushArrayCellAddr();
      if (ErrorFlag)
        return;
      if (NextLookahead == '=')
      {
        ArrayParsed = 0;
        match(ARRAY);
        if (ErrorFlag)
          return;
        match('=');
        if (ErrorFlag)
          return;
        FloatFlag = 0;
        exprAssg();
        if (ErrorFlag)
          return;
        if (tempLocalIndex)
        {
          if ((LocalTable[tempLocalIndex].type == INT) && (FloatFlag))
          {
            emit(INT, 0, 0.0);
            FloatFlag = 0;
          }
          else if ((LocalTable[tempLocalIndex].type == FLOAT) && ( !FloatFlag))
          {
            emit(FLOAT, 0, 0.0);
            FloatFlag = 1;
          }
          emit(STHB ,0 ,0.0);
        }
        else if (tempGlobalIndex)
        {
          if ((GlobalTable[tempGlobalIndex].type == INT) && (FloatFlag))
          {
            emit(INT, 0, 0.0);
            FloatFlag = 0;
          }
          else if((GlobalTable[tempGlobalIndex].type == FLOAT) && (!FloatFlag))
          {
            emit(FLOAT, 0, 0.0);
            FloatFlag = 1;
          }
          emit(STH, 0, 0.0);
        }
        emit(SWAP, 0, 0.0);
        emit(POP, 0, 0.0);
      } /* end if NextLookahead == '=' */
      else
      {
        exprTest();
        if (ErrorFlag)
          return;
      } /* end else of if lookahead == '=' */
      break;
    case ID:
      tempLocalIndex = LocalIndex;
      tempGlobalIndex = GlobalIndex;

      if (NextLookahead == '=')
      {
        if (LocalIndex)
          emit(PUSH_LOC_VAR_ADDR, LocalIndex, 0.0);
        else if (GlobalIndex)
          emit(PUSH_GLO_VAR_ADDR, GlobalIndex, 0.0);
        else
        {
          error("Compiler error, variable lexeme not found in any table");
          return;
        }
        match(ID);
        if (ErrorFlag)
          return;
        match('=');
        if (ErrorFlag)
          return;
        FloatFlag = 0;
        exprAssg();
        if (ErrorFlag) 
          return;
        if (tempLocalIndex)
        {
          if ((LocalTable[tempLocalIndex].type == INT) && (FloatFlag))
          {
            emit(INT, 0, 0.0);
            FloatFlag = 0;
          }
          else if ((LocalTable[tempLocalIndex].type == FLOAT) && ( !FloatFlag))
          {
            emit(FLOAT, 0, 0.0);
            FloatFlag = 1;
          }
          emit(STHB, 0, 0.0);
        }
        else if (tempGlobalIndex)
        {
          if ((GlobalTable[tempGlobalIndex].type == INT) && (FloatFlag))
          {
            emit(INT, 0, 0.0);
            FloatFlag = 0;
          }
          else if((GlobalTable[tempGlobalIndex].type == FLOAT) && (!FloatFlag))
          {
            emit(FLOAT, 0, 0.0);
            FloatFlag = 1;
          }
          emit(STH, 0, 0.0);
        }
        emit(SWAP, 0, 0.0);
        emit(POP, 0, 0.0);
      }
      else
      {
        exprTest();
        if (ErrorFlag)
          return;
      }
      break;
    default:
      exprTest();
      if (ErrorFlag)
        return;
  } /* end switch */
  return;
} /* end exprAssg */

/* ========================================================================= */

void parseAStmt(void) /* parse a single statement */
{
  int tempLabel1, tempLabel2;

  switch (lookahead)
  {
    case WHILE:
      match(WHILE);
      if (ErrorFlag)
        return;
      tempLabel1 = LabelCounter;
      ++LabelCounter;
      tempLabel2 = LabelCounter;
      ++LabelCounter;
      emit(LABEL_CODE, tempLabel1, 0.0);
      emit(PUSH_CODE_LABEL, tempLabel2, 0.0);
      match('(');
      if (ErrorFlag)
        return;
      FloatFlag = 0;
      exprAssg();
      if (ErrorFlag)
        return;
      match(')');
      if (ErrorFlag)
        return;
      if (FloatFlag)
        emit(RNUM, 0, 0.0); /* push 0.0  */
      else
        emit(NUM, 0 ,0.0); /* push 0 */
      emit(COMP, 0, 0.0);
      emit(BEQ, 0, 0.0);
      parseAStmt();
      if (ErrorFlag)
        return;
      emit(PUSH_CODE_LABEL, tempLabel1, 0.0);
      emit(B, 0, 0.0);
      emit(LABEL_CODE, tempLabel2, 0.0);
      break;
    case IF:
      match(IF);
      if (ErrorFlag)
        return;
      tempLabel1 = LabelCounter;
      ++LabelCounter;
      emit(PUSH_CODE_LABEL, tempLabel1, 0.0);
      match('(');
      if (ErrorFlag)
        return;
      FloatFlag = 0;
      exprAssg();
      if (ErrorFlag)
        return;
      match(')');
      if (ErrorFlag)
        return;
      if (FloatFlag)
        emit(RNUM, 0, 0.0);  /* push 0.0 */
      else
        emit(NUM, 0, 0.0);  /* push 0 */
      emit(COMP, 0, 0.0);
      emit(BEQ, 0, 0.0);
      parseAStmt();
      if (ErrorFlag)
        return;
      if (lookahead == ELSE)
      {
        match (ELSE);
        if (ErrorFlag)
          return;
        tempLabel2 = LabelCounter;
	++LabelCounter;
        emit(PUSH_CODE_LABEL, tempLabel2, 0.0);
        emit(B, 0, 0.0);
        emit(LABEL_CODE, tempLabel1, 0.0);
        parseAStmt();
        if (ErrorFlag)
          return;
        emit(LABEL_CODE, tempLabel2, 0.0);
      } /* end if lookahead == ELSE */
      else
      {
        emit(LABEL_CODE, tempLabel1, 0.0);
      } /* end else lookahead == ELSE */
      break;
    case '{':
      match('{');
      do
      {
        parseAStmt();
        if (ErrorFlag)
          ErrorFlag = 0;
      } while ((lookahead != '}') && (lookahead != DONE));
      match('}');
      if (ErrorFlag)
        return;
      break;
    case RETURN:
      if (NextLookahead == ';')
      {
        match(RETURN);
        if (ErrorFlag)
          return;
        match(';');
        if (ErrorFlag)
          return;
        if (GlobalTable[FuncNameIndex].type == INT)
          emit(NUM, 1, 0.0);
	else
          emit(RNUM, 0, 1.0);
      } /* end if */
      else
      {
        match(RETURN);
        if (ErrorFlag)
          return;
        exprAssg();
        if (ErrorFlag)
          return;
        match(';');
        if (ErrorFlag)
          return;
      } /* end else */
      emit(PUSH_CODE_LABEL, ReturnLabel, 0.0);
      emit(B, 0, 0.0);
      break;
    default:  /* assignment statement */
      exprAssg();
      if (ErrorFlag)
        return;
      emit(POP, 0, 0.0);
      match(';');
      return;
  } /* end switch */
  return;
} /* end parseAStmt */

/* ========================================================================= */

void parse(void) /* parse a list of functions */
{
  /* prime NextLookahead */
  lookahead = 1;
  match (lookahead);
  if (ErrorFlag)
    ErrorFlag = 0;

  /* prime lookahead */
  lookahead = 1;
  match (lookahead);
  if (ErrorFlag)
    ErrorFlag = 0;

  DeclOrF(); /* parses the global var. declarations and the first function */
  if (ErrorFlag)
    return;
  FunctionList();
  if (ErrorFlag)
    return;
  CheckMain();
  AllBodsParsed();
  if (ErrorFlag)
    return;
  emit(END, 0, 0.0);
  return;
} /* end parse */
/* ========================================================================= */


int factor(void)
{
  int temp;
  int tempLocalIndex, tempGlobalIndex;
  char templexbuf[30];
  
  switch(lookahead) {
  case '(':
    match('('); 
    if (ErrorFlag)
      return -99;
    switch (lookahead)
    {
      case INT:
        match (INT);
        if (ErrorFlag)
          return -99;
        match (')');
        if (ErrorFlag)
          return -99;

        temp = factor();
        if (ErrorFlag)
          return -99;
        if (temp)
          emit(INT, 0, 0.0);
        return(0);
        break;

      case FLOAT:
        match (FLOAT);
        if (ErrorFlag)
          return -99;
        match (')');
        if (ErrorFlag)
          return -99;

        temp = factor();
        if (ErrorFlag)
          return -99;
        if ( !temp)
          emit(FLOAT, 0, 0.0);
        return(1); 
        break;

      default:
        FloatFlag = 0;
        exprAssg();
        if (ErrorFlag)
          return -99;
        match(')');
        if (ErrorFlag)
          return -99;
        if (FloatFlag)
          return(1);
        else
          return(0);
        break;
    } /* end switch */
    break;

  case NUM:
    emit(NUM, tokenval, 0.0);
    match(NUM);
    if (ErrorFlag)
      return -99;
    return(0); /* meaning false float flag */
    break;

  case RNUM:
    emit(RNUM, tokenval, ftokenval);
    match(RNUM);
    if (ErrorFlag)
      return -99;
    return(1); /* meaning true float flag */
    break;

  case ID:
    if (NextLookahead == '(')
    {
      /* function call */
      tempLocalIndex = LocalIndex;
      tempGlobalIndex = GlobalIndex;
      strcpy (templexbuf, lexbuf);
      match(ID);
      if (ErrorFlag)
        return -99;
      match('(');
      if (ErrorFlag)
        return -99;
      ExprList();
      if (ErrorFlag)
        return -99;
      match(')');
      if (ErrorFlag)
        return -99;

      /* prepare to branch to function */
      CallReturnAddr = LabelCounter;
      ++LabelCounter;
      emit(PUSH_CODE_LABEL, CallReturnAddr, 0.0);
      emit(PUSH_FRAMESIZE, FuncNameIndex, 0.0);
      emit(IB, 0, 0.0);

      /* branch to function */
      if (tempLocalIndex)
      {
        error("Function called is to a local variable");
        return -99;
      } /* end LocalIndex */
      else if (tempGlobalIndex)
      {
        if (!(GlobalTable[tempGlobalIndex].function))
        {
          error("Function called is to a global variable");
          return -99;
        } /* end if !function */
        else
        {
          emit(PUSH_CODE_LABEL,GlobalTable[tempGlobalIndex].functionlabel,0.0);
        } /* end else !function */
      } /* end GlobalIndex */
      else /* lexeme not in any symbol table */
      {
        tempGlobalIndex = GlobalInsert (templexbuf,ID,INT,0,1,LabelCounter);
        if (ErrorFlag)
          ErrorFlag = 0;
        ++LabelCounter;
        emit(PUSH_CODE_LABEL, GlobalTable[tempGlobalIndex].functionlabel, 0.0);
      } /* end insert function name */
      emit(B, 0, 0.0);

      /* return sequence */
      emit(LABEL_CODE, CallReturnAddr, 0.0);
      emit(PUSH_FRAMESIZE, FuncNameIndex, 0.0);
      emit(DB, 0, 0.0);
      if (GlobalTable[tempGlobalIndex].function < 0) /* function defined */
      {
        if (GlobalTable[tempGlobalIndex].type == INT)
          return(0);
        else
          return(1);
      }
      else /* default return type of undefined function is INT */
        return(0);
    } /* end if NextLookahead == ')' */
    else if ( !(LocalIndex || GlobalIndex))
    {
      error("attempting to use an undefined variable");
      return -99;
    }

    if (LocalIndex)
      emit(PUSH_LOC_VAR_VALUE, LocalIndex, 0.0);
    else if (GlobalIndex)
      emit(PUSH_GLO_VAR_VALUE, GlobalIndex, 0.0);
    else
    {
      error("Compiler error, lexeme was not found in any table");
      break;
    }
    tempLocalIndex = LocalIndex;
    tempGlobalIndex = GlobalIndex;
    match(ID);
    if (ErrorFlag)
      return -99;
    if (tempLocalIndex)
    {
      if (LocalTable[tempLocalIndex].type == FLOAT)
        return(1);
      else
        return(0);
    }
    else
    {
      if (GlobalTable[tempGlobalIndex].type == FLOAT)
        return(1);
      else
        return(0);
    }
    break;
  case ARRAY:
    tempLocalIndex = LocalIndex;
    tempGlobalIndex = GlobalIndex;
    PushArrayCellAddr();
    if (ErrorFlag)
      return -99;
    ArrayParsed = 0;
    match(ARRAY);
    if (ErrorFlag)
      return -99;
    if (tempLocalIndex)
      emit(VALB, 0, 0.0);
    else if (tempGlobalIndex)
      emit(VAL, 0, 0.0);
    else
    {
      error("using an undefined array referance");
      return -99;
    }

    if (tempLocalIndex)
    {
      if (LocalTable[tempLocalIndex].type == FLOAT)
        return(1);
      else
        return(0);
    }
    else
    {
      if (GlobalTable[tempGlobalIndex].type == FLOAT)
        return(1);
      else
        return(0);
    }
    break;
  case '-':
    match('-'); 
    if (ErrorFlag)
      return -99;
    temp=factor(); 
    if (ErrorFlag)
      return -99;
    if (temp)
      emit(RNEG, 0, 0.0);
    else
      emit(NEG, 0, 0.0);
    return(temp);
    break;
  case READF:
    match(READF);
    if (ErrorFlag)
      return -99;
    match ('(');
    if (ErrorFlag)
      return -99;
    match (')');
    if (ErrorFlag)
      return -99;
    emit(READ, 0, 0.0);
    emit(FLOAT, 0, 0.0);
    return(1);
    break;
  case READI:
    match(READI);
    if (ErrorFlag)
      return -99;
    match('(');
    if (ErrorFlag)
      return -99;
    match(')');
    if (ErrorFlag)
      return -99;
    emit(READ, 0, 0.0);
    emit(INT, 0, 0.0);
    return(0);
    break;
  case WRITEF:
    match (WRITEF);
    if (ErrorFlag)
      return -99;
    match('(');
    if (ErrorFlag)
      return -99;
    FloatFlag = 0;
    exprAssg();
    if (ErrorFlag)
      return -99;
    if ( !(FloatFlag))
    {
      emit(FLOAT, 0, 0.0);
      FloatFlag = 1;
    }
    match(')');
    if (ErrorFlag)
      return -99;
    emit(WRITEF, 0, 0.0);
    emit(RNUM, 1, 1.0);
    return(1);
    break;
  case WRITEI:
    match(WRITEI);
    if (ErrorFlag)
      return -99;
    match('(');
    if (ErrorFlag)
      return -99;
    FloatFlag = 0;
    exprAssg();
    if (ErrorFlag)
      return -99;
    if (FloatFlag)
    {
      emit(INT, 0, 0.0);
      FloatFlag = 0;
    }
    match(')');
    if (ErrorFlag)
      return -99;
    emit(WRITEI, 0, 0.0);
    emit(NUM, 1, 0.0);
    return(0);
    break;
  case WRITELN:
    match(WRITELN);
    if (ErrorFlag)
      return -99;
    match('(');
    if (ErrorFlag)
      return -99;
    match(')');
    if (ErrorFlag)
      return -99;
    emit(WRITELN, 0, 0.0);
    emit(NUM, 1, 0.0);
    return(0);
    break;
  default:
    /* error used to be called from here */
    error("Illegal operator");
    return(0);
  }
  return -99;
}

/* ------------------------------------------------------------------ */

void ExprList(void)
{
  if (lookahead != ')') 
  {
    exprAssg();
    if (ErrorFlag)
      return;
  
    while (lookahead == ',')
    {
      match(',');
      if (ErrorFlag)
        return;
      exprAssg();
      if (ErrorFlag)
        return;
    } /* end while */
  } /* end if ) */
} /* end ExprList */

/* ========================================================================= */


void FunctionList(void)
{
  do
  {
    ErrorFlag = 0;
    FloatFlag = 0;
    LocalReset();
    switch(lookahead)
    {
      case ID:
       FunctionDef(INT);
       if (ErrorFlag)
         return;
       break;
      case INT:
       match(INT);
       if (ErrorFlag)
         return;
       FunctionDef(INT);
       if (ErrorFlag)
         return;
       break;
      case FLOAT:
       match(FLOAT);
       if (ErrorFlag)
         return;
       FunctionDef(FLOAT);
       if (ErrorFlag)
         return;
      case DONE:
       break;
      default:
       error("Unexpected token found");
       return;
       break;
    }  /*  end for switch statement */
  } 
  while (lookahead != DONE);
}  /* end FunctionList */

/* ----------------------------------------------------------------------- */

void FunctionDef(int type)
{
  offset = 1;
  if (lookahead != ID)
  {
    error("Invalid function defintion structure. Expected ID");
    return;
  }  /*  end if lookahead  */
  
  if (LocalIndex)
  {
    error("Compiler error, function name in local symbol table");
    return;
  }  /* end if LocalIndex */
  else if (GlobalIndex)
  {
    if (!(GlobalTable[GlobalIndex].function))
    {
      error("Attempting to redefine a global variable as a function name");
      return;
    }   /* end if GlobalTable */
    else if (GlobalTable[GlobalIndex].function < 0)
    {
      error("Redefining a function.");
      return;
    }    /*  end else if GlobalTable */
    else if (GlobalTable[GlobalIndex].function > 0)
    /* function is a postive value, already called not defined */
    {
      GlobalTable[GlobalIndex].type = type;
      FuncNameIndex = GlobalIndex;
      GlobalTable[GlobalIndex].function = -1;
    }   /* end else if function > 0 */
    else
    {
      error("Compiler error, functiondef is confused");
      return;
    }
  } /* end else if (GlobalIndex) */
  else /* ID not in any tabel */
  {
    GlobalIndex = GlobalInsert (lexbuf,ID,type,0,-1,LabelCounter);
    if (ErrorFlag)
      ErrorFlag = 0;
    FuncNameIndex = GlobalIndex;
    ++LabelCounter;
  }  /* end else */

  Scope = GlobalTable[GlobalIndex].functionlabel;

  /* label function */
  emit(LABEL_FUNC, GlobalIndex, 0.0);
  emit(LABEL_CODE, Scope, 0.0);

  /* store return address */
  emit(STORE_RA, FuncNameIndex, 0.0);

  ReturnLabel = LabelCounter;
  ++LabelCounter;

  match(ID);
  if (ErrorFlag)
    ErrorFlag = 0;
  match('(');
  if (ErrorFlag)
    ErrorFlag = 0;
  if ( strcmp(GlobalTable[FuncNameIndex].lexptr, "main") == 0)
  {
    if (lookahead == ')')
    {
      match(')');
      if (ErrorFlag)
        return;
    } /* end if lookahead == ')' */
    else
    {
      error("Function main cannot have parameters.");
      return;
    } /* end else */
  } /* end if function is main */
  else
  {
    ParamList();
    if (ErrorFlag)
      ErrorFlag = 0;
    match(')');
    if (ErrorFlag)
      ErrorFlag = 0;
  } /* end else (function is something other than main) */
  DecList();
  if (ErrorFlag)
    ErrorFlag = 0;
  emit(SAVE_FRAMESIZE, FuncNameIndex, 0.0);
  FstmtList();
  if (ErrorFlag)
    return;
  if (GlobalTable[FuncNameIndex].type == INT)
    emit(NUM, 1, 0.0);
  else
    emit(RNUM, 0, 1.0);
  emit(LABEL_CODE, ReturnLabel, 0.0);
  emit(PUSH_RA, FuncNameIndex, 0.0);
  emit(B, 0, 0.0);
} /* end function Def */

/* ---------------------------------------------------------------------- */

void MoreParams(void)
{
  int tempLocalIndex;

  if (lookahead == ',')
  {
    match(',');
    if (ErrorFlag)
      return;
    if (lookahead != ID)
    {
      error("Improperly formed parameter list");
      return;
    }
    if (GlobalIndex)
    {

      if (GlobalTable[GlobalIndex].function)
      {
        error("Cannot use a function name as parameter");
        return;
      }  /* end if GlobalTable */
    }   /* GlobalIndex */

    if (LocalIndex)
    {
      error("Trying to use a prameter twice");
      return;
    }  /* end else if (LocalIndex) */

    else
    {
      tempLocalIndex = LocalIndex = LocalInsert (lexbuf,ID,PARAM,1,0,0);
      if (ErrorFlag)
        return;
    }  /* end else */
    match (ID);
    if (ErrorFlag)
      return;
    MoreParams();
    if (ErrorFlag)
      return;
    emit(LOC_DECL, tempLocalIndex, 0.0);
    emit(PUSH_LOC_VAR_ADDR, tempLocalIndex, 0.0);
    emit(ISTB, 0, 0.0);
    ++offset;
  } /* end if lookahead == ',' */
} /* end MoreParams() */


/* ---------------------------------------------------------------------- */

void ParamList(void)
{
  int tempLocalIndex;

  if (lookahead == ID)
  {
    if (GlobalIndex)
    {

      if (GlobalTable[GlobalIndex].function)
      {
        error("Cannot use a function name as parameter");
        return;
      }  /* end if GlobalTable */
    }   /* GlobalIndex */

    if (LocalIndex)
    {
      error("Trying to use a parameter twice");
      return;
    }  /* end else if (LocalIndex) */

    else
    {
      tempLocalIndex = LocalIndex = LocalInsert (lexbuf,ID,PARAM,1,0,0);
      if (ErrorFlag)
        return;
    }  /* end else */
    match (ID);
    if (ErrorFlag)
      return;
    MoreParams();
    if (ErrorFlag)
      return;
    emit(LOC_DECL, tempLocalIndex, 0.0);
    emit(PUSH_LOC_VAR_ADDR, tempLocalIndex, 0.0);
    emit(ISTB, 0, 0.0);
    ++offset;
  } /* end if lookahead == ID */
} /* end paramlist() */

/* ------------------------------------------------------------------ */

void DecList(void)
{
  while ((lookahead == INT) || (lookahead == FLOAT))
  {
    match (lookahead); /* obviously must be INT or FLOAT */
    if (ErrorFlag)
      return;
    VarList (PreviousLookahead);
    if (ErrorFlag)
      return;
  }  /* end while ((lookahead == INT) || (loookahead == FLOAT)) */
  ParamInt();
}  /* end function DecList */

/* --------------------------------------------------------------------- */

void VarList(int type)
{
  int tempLocalIndex;

  do
  {
    if (GlobalIndex)
    {
  
      if (GlobalTable[GlobalIndex].function)
      {
        error ("Cannot use a function name as a parameter");
        return;
      }  /* end if GlogalTable */
    }  /* end if (GlobalIndex) */

    if (LocalIndex)
    {

      if (LocalTable[LocalIndex].type == PARAM)
      {
        if (NextLookahead == '[')
          error ("Cannot pass an array as a parameter");
        else
        {
          LocalTable[LocalIndex].type = type;
          match(ID);
          if (ErrorFlag)
            return;
        } /* end else */
      } /* end if LocalTable[LocalIndex] */
     
      else
      {
        error ("Trying to redefine a variable");
        return;
      }  /* end else */
    }  /* end if LocalIndex */
   
    else  /* variable is not entered as a local so insert */
    {
      if (NextLookahead == '[')
      {
        tempLocalIndex = LocalIndex = LocalInsert (lexbuf,ARRAY,type,0,0,0);
        if (ErrorFlag)
          return;
        lookahead = ARRAY;
        match (ARRAY);
        if (ErrorFlag)
          return;
        match ('[');
        if (ErrorFlag)
          return;
        if (lookahead == NUM)
        {
          LocalTable[tempLocalIndex].size = tokenval;
          if (ErrorFlag)
            return;
        }
        else
        {
          error("Array declarations requires an integer within []");
          return;
        }
        match (NUM);
        if (ErrorFlag)
          return;
        match (']');
        if (ErrorFlag)
   	  return;
        emit(LOC_DECL, tempLocalIndex, 0.0);
        offset += LocalTable[tempLocalIndex].size;
      } /* end if nextlook */
     
      else
      {
        LocalIndex = LocalInsert(lexbuf,ID,type,1,0,0);
        if (ErrorFlag)
          return;
        emit(LOC_DECL, LocalIndex, 0.0);
        ++offset;
        match (ID);
        if (ErrorFlag)
          return;
      } /* end else */
    } /* end else */

   switch (lookahead)
   {
     case ',':
       match (',');
       if (ErrorFlag)
 	 return;
       break;
     case ';':
       match (';');
       if (ErrorFlag)
	 return;
       return;
       break;
     default:
       error ("badly formed declarations");
       return;
   } /* end switch (lookahead) */
 } while ((lookahead == ID) || (lookahead == ARRAY));
 error("can only use ID  or ARRAAY");
 return;
} /* end function VarList */

/* ------------------------------------------------------------------- */

void FstmtList(void)
{
  match ('{');
  if (ErrorFlag)
    ErrorFlag = 0;
  
  do
  {
    parseAStmt();
    if (ErrorFlag)
      ErrorFlag = 0;
  }
  while ((lookahead != '}') && (lookahead != DONE));
  
  if (lookahead == DONE)
  {
     error("Unexpected end of file");
     return;
  } /* end if */
  else
  {
    match ('}');
    if (ErrorFlag)
      return;
  } /* end else */
} /* end function FstmtList */