#ifndef EXPRNODE_H
#define EXPRNODE_H

#include "node.h"

struct ConstNode;	//is constant int,float or string

struct ExprNode : public Node{
	Type *sem_type;
	ExprNode():sem_type(0){}
	ExprNode( Type *t ):sem_type( t ){}

	ExprNode *castTo( Type *ty,Environ *e );
	ExprNode *semant( Environ *e,Type *ty );

	virtual ExprNode *semant( Environ *e )=0;
	virtual TNode *translate( Codegen *g )=0;
	virtual ConstNode *constNode(){ return 0; }
};

struct ExprSeqNode : public Node{
	vector<ExprNode*> exprs;
	~ExprSeqNode(){ for( ;exprs.size();exprs.pop_back() ) delete exprs.back(); }
	void push_back( ExprNode *e ){ exprs.push_back( e ); }
	int  size(){ return exprs.size(); }
	void semant( Environ *e );
	TNode *translate( Codegen *g,bool userlib );
	void castTo( DeclSeq *ds,Environ *e,bool userlib );
	void castTo( Type *t,Environ *e );
};

#include "varnode.h"

struct CastNode : public ExprNode{
	ExprNode *expr;
	Type *type;
	CastNode( ExprNode *ex,Type *ty ):expr( ex ),type( ty ){}
	~CastNode(){ delete expr; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct CallNode : public ExprNode{
	string ident,tag;
	ExprSeqNode *exprs;
	Decl *sem_decl;
	CallNode( const string &i,const string &t,ExprSeqNode *e ):ident(i),tag(t),exprs(e){}
	~CallNode(){ delete exprs; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct VarExprNode : public ExprNode{
	VarNode *var;
	VarExprNode( VarNode *v ):var(v){}
	~VarExprNode(){ delete var; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct ConstNode : public ExprNode{
	ExprNode *semant( Environ *e ){ return this; }
	ConstNode *constNode(){ return this; }
	virtual int intValue()=0;
	virtual float floatValue()=0;
	virtual string stringValue()=0;
};

struct IntConstNode : public ConstNode{
	int value;
	IntConstNode( int n );
	TNode *translate( Codegen *g );
	int intValue();
	float floatValue();
	string stringValue();
};

struct FloatConstNode : public ConstNode{
	float value;
	FloatConstNode( float f );
	TNode *translate( Codegen *g );
	int intValue();
	float floatValue();
	string stringValue();
};

struct StringConstNode : public ConstNode{
	string value;
	StringConstNode( const string &s );
	TNode *translate( Codegen *g );
	int intValue();
	float floatValue();
	string stringValue();
};

struct UniExprNode : public ExprNode{
	int op;ExprNode *expr;
	UniExprNode( int op,ExprNode *expr ):op( op ),expr( expr ){}
	~UniExprNode(){ delete expr; }
	ExprNode *constize();
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

// and, or, eor, lsl, lsr, asr
struct BinExprNode : public ExprNode{
	int op;ExprNode *lhs,*rhs;
	BinExprNode( int op,ExprNode *lhs,ExprNode *rhs ):op( op ),lhs( lhs ),rhs( rhs ){}
	~BinExprNode(){ delete lhs;delete rhs; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

// *,/,Mod,+,-
struct ArithExprNode : public ExprNode{
	int op;ExprNode *lhs,*rhs;
	ArithExprNode( int op,ExprNode *lhs,ExprNode *rhs ):op( op ),lhs( lhs ),rhs( rhs ){}
	~ArithExprNode(){ delete lhs;delete rhs; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

//<,=,>,<=,<>,>=
struct RelExprNode : public ExprNode{
	int op;ExprNode *lhs,*rhs;
	Type *opType;
	RelExprNode( int op,ExprNode *lhs,ExprNode *rhs ):op( op ),lhs( lhs ),rhs( rhs ){}
	~RelExprNode(){ delete lhs;delete rhs; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct NewNode : public ExprNode{
	string ident;
	NewNode( const string &i ):ident(i){}
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct FirstNode : public ExprNode{
	string ident;
	FirstNode( const string &i ):ident(i){}
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct LastNode : public ExprNode{
	string ident;
	LastNode( const string &i ):ident(i){}
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct AfterNode : public ExprNode{
	ExprNode *expr;
	AfterNode( ExprNode *e ):expr(e){}
	~AfterNode(){ delete expr; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct BeforeNode : public ExprNode{
	ExprNode *expr;
	BeforeNode( ExprNode *e ):expr(e){}
	~BeforeNode(){ delete expr; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct NullNode : public ExprNode{
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct ObjectCastNode : public ExprNode{
	ExprNode *expr;
	string type_ident;
	ObjectCastNode( ExprNode *e,const string &t ):expr(e),type_ident(t){}
	~ObjectCastNode(){ delete expr; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

struct ObjectHandleNode : public ExprNode{
	ExprNode *expr;
	ObjectHandleNode( ExprNode *e ):expr(e){}
	~ObjectHandleNode(){ delete expr; }
	ExprNode *semant( Environ *e );
	TNode *translate( Codegen *g );
};

#endif