class Analyze : public SymTab, public Parse
{
private:
	int location;
	void Traverse1( TreeNode * t );
	void Traverse2( TreeNode * t );
	void InsertNode(TreeNode *t);
	void nullProc(TreeNode * t);
	void checkNode(TreeNode * t);
	void typeError(TreeNode * t, char * message);

public:
	Analyze(char * name):Parse(name){ location = 0; }
	void buildSymtab(TreeNode * syntaxTree);
	void typeCheck(TreeNode * syntaxTree);
};



void Analyze ::Traverse1( TreeNode * t )
{
	if (t != NULL)
	{
		InsertNode(t);
	    { 
			int i;
			for (i=0; i < 3; i++)
			    Traverse1(t->child[i]);
	    }
		nullProc(t);
		Traverse1(t->sibling);
	}
}

void Analyze ::Traverse2( TreeNode * t )
{
	if (t != NULL)
	{
		nullProc(t);
	    { 
			int i;
			for (i=0; i < 3; i++)
			    Traverse2(t->child[i]);
	    }
		checkNode(t);
		Traverse2(t->sibling);
	}
}

void Analyze:: nullProc(TreeNode * t)
{ 
	if (t==NULL) return;
	else return;
}


void Analyze :: InsertNode( TreeNode * t)
{ 
	switch (t->nodekind)
   {
		case StmtK:
			switch (t->kind.stmt)
			{
				case AssignK:
			    case ReadK:
					 if ( Find(t->attr.name) == -1 )
          				Insert(t->attr.name,t->linenos,location++);
					 else
						Insert(t->attr.name,t->linenos,0);
					break;
				default:
					break;
			 }
			 break;
		case ExpK:
			 switch (t->kind.exp)
			{
				case IdK:
					 if ( Find (t->attr.name) == -1)
						 Insert(t->attr.name,t->linenos,location++);
					 else
						 Insert(t->attr.name,t->linenos,0);
					 break;
				default:
					 break;
			 }
			 break;
		default:
			 break;
  }
}


void Analyze :: buildSymtab(TreeNode * syntaxTree)
{ 
	Traverse1(syntaxTree);
	cout<<"\nSymbol table:\n\n";
    PrintSymTab();
  
}


void Analyze ::typeError(TreeNode * t, char * message)
{ 
	cout<<"Type error at line "<<t->linenos<<message<<endl;
    Error = 1;
}


void Analyze :: checkNode(TreeNode * t)
{ switch (t->nodekind)
  { case ExpK:
      switch (t->kind.exp)
      { case OpK:
          if ((t->child[0]->type != Integer) ||
              (t->child[1]->type != Integer))
            typeError(t,"Op applied to non-integer");
          if ((t->attr.op == EQ) || (t->attr.op == LT))
            t->type = Boolean;
          else
            t->type = Integer;
          break;
        case ConstK:
        case IdK:
          t->type = Integer;
          break;
        default:
          break;
      }
      break;
    case StmtK:
      switch (t->kind.stmt)
      { case IfK:
          if (t->child[0]->type == Integer)
            typeError(t->child[0],"if test is not Boolean");
          break;
        case AssignK:
          if (t->child[0]->type != Integer)
            typeError(t->child[0],"assignment of non-integer value");
          break;
        case WriteK:
          if (t->child[0]->type != Integer)
            typeError(t->child[0],"write of non-integer value");
          break;
        case RepeatK:
          if (t->child[1]->type == Integer)
            typeError(t->child[1],"repeat test is not Boolean");
          break;
        default:
          break;
      }
      break;
    default:
      break;

  }
}


void Analyze ::typeCheck(TreeNode * syntaxTree)
{
	Traverse2(syntaxTree);
}