BlitzNext/compiler/exprnode.cpp

#include "std.h"
#include "nodes.h"

#include <math.h>
#include <float.h>

//////////////////////////////////
// Cast an expression to a type //
//////////////////////////////////
ExprNode *ExprNode::castTo( Type *ty,Environ *e ){
	if( !sem_type->canCastTo( ty ) ){
		ex( "Illegal type conversion" );
	}

	ExprNode *cast=d_new CastNode( this,ty );
	return cast->semant( e );
}

ExprNode *CastNode::semant( Environ *e ){
	if( !expr->sem_type ){
		expr=expr->semant( e );
	}

	if( ConstNode *c=expr->constNode() ){
		ExprNode *e;
		if( type==Type::int_type ) e=d_new IntConstNode( c->intValue() );
		else if( type==Type::float_type ) e=d_new FloatConstNode( c->floatValue() );
		else e=d_new StringConstNode( c->stringValue() );
		delete this;
		return e;
	}

	sem_type=type;
	return this;
}

//////////////////////////////////
// Cast an expression to a type //
//////////////////////////////////
TNode *CastNode::translate( Codegen *g ){
	TNode *t=expr->translate( g );
	if( expr->sem_type==Type::float_type && sem_type==Type::int_type ){
		//float->int
		return d_new TNode( IR_CAST,t,0 );
	}
	if( expr->sem_type==Type::int_type && sem_type==Type::float_type ){
		//int->float
		return d_new TNode( IR_FCAST,t,0 );
	}
	if( expr->sem_type==Type::string_type && sem_type==Type::int_type ){
		//str->int
		return call( "__bbStrToInt",t );
	}
	if( expr->sem_type==Type::int_type && sem_type==Type::string_type ){
		//int->str
		return call( "__bbStrFromInt",t );
	}
	if( expr->sem_type==Type::string_type && sem_type==Type::float_type ){
		//str->float
		return fcall( "__bbStrToFloat",t );
	}
	if( expr->sem_type==Type::float_type && sem_type==Type::string_type ){
		//float->str
		return call( "__bbStrFromFloat",t );
	}
	if( expr->sem_type->structType() && sem_type==Type::string_type ){
		//obj->str
		return call( "__bbObjToStr",t );
	}
	return t;
}

/////////////////////////////
// Sequence of Expressions //
/////////////////////////////
void ExprSeqNode::semant( Environ *e ){
	for( int k=0;k<exprs.size();++k ){
		if( exprs[k] ) exprs[k]=exprs[k]->semant( e );
	}
}

TNode *ExprSeqNode::translate( Codegen *g,bool cfunc ){
	TNode *t=0,*l=0;
	for( int k=0;k<exprs.size();++k ){

		TNode *q=exprs[k]->translate(g);

		if( cfunc ){
			Type *ty=exprs[k]->sem_type;
			if( ty->stringType() ){
				q=call( "__bbStrToCStr",q );
			}else if( ty->structType() ){
				q=d_new TNode( IR_MEM,q );
			}else if( ty==Type::void_type ){
				q=d_new TNode( IR_MEM,add(q,iconst(4)) );
			}
		}

		TNode *p;
		p=d_new TNode( IR_ARG,0,0,k*4 );
		p=d_new TNode( IR_MEM,p,0 );
		p=d_new TNode( IR_MOVE,q,p );
		p=d_new TNode( IR_SEQ,p,0 );
		if( l ) l->r=p;
		else t=p;
		l=p;
	}
	return t;
}

void ExprSeqNode::castTo( DeclSeq *decls,Environ *e,bool cfunc ){
	if( exprs.size()>decls->size() ) ex( "Too many parameters" );
	for( int k=0;k<decls->size();++k ){
		Decl *d=decls->decls[k];
		if( k<exprs.size() && exprs[k] ){

			if( cfunc && d->type->structType() ){
				if( exprs[k]->sem_type->structType() ){
				}else if( exprs[k]->sem_type->intType() ){
					exprs[k]->sem_type=Type::void_type;
				}else{
					ex( "Illegal type conversion" );
				}
				continue;
			}

			exprs[k]=exprs[k]->castTo( d->type,e );

		}else{
			if( !d->defType ) ex( "Not enough parameters" );
			ExprNode *expr=constValue( d->defType );
			if( k<exprs.size() ) exprs[k]=expr;
			else exprs.push_back( expr );
		}
	}
}

void ExprSeqNode::castTo( Type *t,Environ *e ){
	for( int k=0;k<exprs.size();++k ){
		exprs[k]=exprs[k]->castTo( t,e );
	}
}

///////////////////
// Function call //
///////////////////
ExprNode *CallNode::semant( Environ *e ){
	Type *t=e->findType( tag );
	sem_decl=e->findFunc( ident );
	if( !sem_decl || !(sem_decl->kind & DECL_FUNC) ) ex( "Function '"+ident+"' not found" );
	FuncType *f=sem_decl->type->funcType();
	if( t && f->returnType!=t ) ex( "incorrect function return type" );
	exprs->semant( e );
	exprs->castTo( f->params,e,f->cfunc );
	sem_type=f->returnType;
	return this;
}

TNode *CallNode::translate( Codegen *g ){

	FuncType *f=sem_decl->type->funcType();

	TNode *t;
	TNode *l=global( "_f"+ident );
	TNode *r=exprs->translate( g,f->cfunc );

	if( f->userlib ){
		l=d_new TNode( IR_MEM,l );
		usedfuncs.insert( ident );
	}

	if( sem_type==Type::float_type ){
		t=d_new TNode( IR_FCALL,l,r,exprs->size()*4 );
	}else{
		t=d_new TNode( IR_CALL,l,r,exprs->size()*4 );
	}

	if( f->returnType->stringType() ){
		if( f->cfunc ){
			t=call( "__bbCStrToStr",t );
		}
	}
	return t;
}

/////////////////////////
// Variable expression //
/////////////////////////
ExprNode *VarExprNode::semant( Environ *e ){
	var->semant( e );
	sem_type=var->sem_type;
	ConstType *c=sem_type->constType();
	if( !c ) return this;
	ExprNode *expr=constValue( c );
	delete this;return expr;
}

TNode *VarExprNode::translate( Codegen *g ){
	return var->load( g );
}

//////////////////////
// Integer constant //
//////////////////////
IntConstNode::IntConstNode( int n ):value(n){
	sem_type=Type::int_type;
}

TNode *IntConstNode::translate( Codegen *g ){
	return d_new TNode( IR_CONST,0,0,value );
}

int IntConstNode::intValue(){
	return value;
}

float IntConstNode::floatValue(){
	return value;
}

string IntConstNode::stringValue(){
	return itoa( value );
}

////////////////////
// Float constant //
////////////////////
FloatConstNode::FloatConstNode( float f ):value(f){
	sem_type=Type::float_type;
}

TNode *FloatConstNode::translate( Codegen *g ){
	return d_new TNode( IR_CONST,0,0,*(int*)&value );
}

int FloatConstNode::intValue(){
	float flt=value;
	int temp;
	_control87( _RC_NEAR|_PC_24|_EM_INVALID|_EM_ZERODIVIDE|_EM_OVERFLOW|_EM_UNDERFLOW|_EM_INEXACT|_EM_DENORMAL,0xfffff );
	_asm{
		fld [flt];
		fistp [temp];
	}
	_control87( _CW_DEFAULT,0xfffff );
	return temp;
}

float FloatConstNode::floatValue(){
	return value;
}

string FloatConstNode::stringValue(){
	return ftoa( value );
}

/////////////////////
// String constant //
/////////////////////
StringConstNode::StringConstNode( const string &s ):value(s){
	sem_type=Type::string_type;
}

TNode *StringConstNode::translate( Codegen *g ){
	string lab=genLabel();
	g->s_data( value,lab );
	return call( "__bbStrConst",global( lab ) );
}

int StringConstNode::intValue(){
	return atoi( value );
}

float StringConstNode::floatValue(){
	return (float)atof( value );
}

string StringConstNode::stringValue(){
	return value;
}

////////////////////
// Unary operator //
////////////////////
ExprNode *UniExprNode::semant( Environ *e ){
	expr=expr->semant( e );
	sem_type=expr->sem_type;
	if( sem_type!=Type::int_type && sem_type!=Type::float_type ) ex( "Illegal operator for type" );
	if( ConstNode *c=expr->constNode() ){
		ExprNode *e;
		if( sem_type==Type::int_type ){
			switch( op ){
			case '+':e=d_new IntConstNode( +c->intValue() );break;
			case '-':e=d_new IntConstNode( -c->intValue() );break;
			case ABS:e=d_new IntConstNode( c->intValue()>=0 ? c->intValue() : -c->intValue() );break;
			case SGN:e=d_new IntConstNode( c->intValue()>0 ? 1 : (c->intValue()<0 ? -1 : 0) );break;
			}
		}else{
			switch( op ){
			case '+':e=d_new FloatConstNode( +c->floatValue() );break;
			case '-':e=d_new FloatConstNode( -c->floatValue() );break;
			case ABS:e=d_new FloatConstNode( c->floatValue()>=0 ? c->floatValue() : -c->floatValue() );break;
			case SGN:e=d_new FloatConstNode( c->floatValue()>0 ? 1 : (c->floatValue()<0 ? -1 : 0) );break;
			}
		}
		delete this;
		return e;
	}
	return this;
}

TNode *UniExprNode::translate( Codegen *g ){
	int n=0;
	TNode *l=expr->translate( g );
	if( sem_type==Type::int_type ){
		switch( op ){
		case '+':return l;
		case '-':n=IR_NEG;break;
		case ABS:return call( "__bbAbs",l );
		case SGN:return call( "__bbSgn",l );
		}
	}else{
		switch( op ){
		case '+':return l;
		case '-':n=IR_FNEG;break;
		case ABS:return fcall( "__bbFAbs",l );
		case SGN:return fcall( "__bbFSgn",l );
		}
	}
	return d_new TNode( n,l,0 );
}

/////////////////////////////////////////////////////
// boolean expression - accepts ints, returns ints //
/////////////////////////////////////////////////////
ExprNode *BinExprNode::semant( Environ *e ){
	lhs=lhs->semant(e);lhs=lhs->castTo( Type::int_type,e );
	rhs=rhs->semant(e);rhs=rhs->castTo( Type::int_type,e );
	ConstNode *lc=lhs->constNode(),*rc=rhs->constNode();
	if( lc && rc ){
		ExprNode *expr;
		switch( op ){
		case AND:expr=d_new IntConstNode( lc->intValue() & rc->intValue() );break;
		case OR: expr=d_new IntConstNode( lc->intValue() | rc->intValue() );break;
		case XOR:expr=d_new IntConstNode( lc->intValue() ^ rc->intValue() );break;
		case SHL:expr=d_new IntConstNode( lc->intValue()<< rc->intValue() );break;
		case SHR:expr=d_new IntConstNode( (unsigned)lc->intValue()>>rc->intValue() );break;
		case SAR:expr=d_new IntConstNode( lc->intValue()>> rc->intValue() );break;
		}
		delete this;
		return expr;
	}
	sem_type=Type::int_type;
	return this;
}

TNode *BinExprNode::translate( Codegen *g ){
	TNode *l=lhs->translate( g );
	TNode *r=rhs->translate( g );
	int n=0;
	switch( op ){
	case AND:n=IR_AND;break;case OR:n=IR_OR;break;case XOR:n=IR_XOR;break;
	case SHL:n=IR_SHL;break;case SHR:n=IR_SHR;break;case SAR:n=IR_SAR;break;
	}
	return d_new TNode( n,l,r );
}

///////////////////////////
// arithmetic expression //
///////////////////////////
ExprNode *ArithExprNode::semant( Environ *e ){
	lhs=lhs->semant(e);
	rhs=rhs->semant(e);
	if( lhs->sem_type->structType() || rhs->sem_type->structType() ){
		ex( "Arithmetic operator cannot be applied to custom type objects" );
	}
	if( lhs->sem_type==Type::string_type || rhs->sem_type==Type::string_type ){
		//one side is a string - only + operator...
		if( op!='+' ) ex( "Operator cannot be applied to strings" );
		sem_type=Type::string_type;
	}else if( op=='^' || lhs->sem_type==Type::float_type || rhs->sem_type==Type::float_type ){
		//It's ^, or one side is a float
		sem_type=Type::float_type;
	}else{
		//must be 2 ints
		sem_type=Type::int_type;
	}
	lhs=lhs->castTo( sem_type,e );
	rhs=rhs->castTo( sem_type,e );
	ConstNode *lc=lhs->constNode(),*rc=rhs->constNode();
	if( rc && (op=='/' || op==MOD) ){
		if( (sem_type==Type::int_type && !rc->intValue()) || (sem_type==Type::float_type && !rc->floatValue()) ){
			ex( "Division by zero" );
		}
	}
	if( lc && rc ){
		ExprNode *expr;
		if( sem_type==Type::string_type ){
			expr=d_new StringConstNode( lc->stringValue()+rc->stringValue() );
		}else if( sem_type==Type::int_type ){
			switch( op ){
			case '+':expr=d_new IntConstNode( lc->intValue()+rc->intValue() );break;
			case '-':expr=d_new IntConstNode( lc->intValue()-rc->intValue() );break;
			case '*':expr=d_new IntConstNode( lc->intValue()*rc->intValue() );break;
			case '/':expr=d_new IntConstNode( lc->intValue()/rc->intValue() );break;
			case MOD:expr=d_new IntConstNode( lc->intValue()%rc->intValue() );break;
			}
		}else{
			switch( op ){
			case '+':expr=d_new FloatConstNode( lc->floatValue()+rc->floatValue() );break;
			case '-':expr=d_new FloatConstNode( lc->floatValue()-rc->floatValue() );break;
			case '*':expr=d_new FloatConstNode( lc->floatValue()*rc->floatValue() );break;
			case '/':expr=d_new FloatConstNode( lc->floatValue()/rc->floatValue() );break;
			case MOD:expr=d_new FloatConstNode( fmod( lc->floatValue(),rc->floatValue() ) );break;
			case '^':expr=d_new FloatConstNode( pow( lc->floatValue(),rc->floatValue() ) );break;
			}
		}
		delete this;
		return expr;
	}
	return this;
}

TNode *ArithExprNode::translate( Codegen *g ){
	TNode *l=lhs->translate( g );
	TNode *r=rhs->translate( g );
	if( sem_type==Type::string_type ){
		return call( "__bbStrConcat",l,r );
	}
	int n=0;
	if( sem_type==Type::int_type ){
		switch( op ){
		case '+':n=IR_ADD;break;case '-':n=IR_SUB;break;
		case '*':n=IR_MUL;break;case '/':n=IR_DIV;break;
		case MOD:return call( "__bbMod",l,r );
		}
	}else{
		switch( op ){
		case '+':n=IR_FADD;break;case '-':n=IR_FSUB;break;
		case '*':n=IR_FMUL;break;case '/':n=IR_FDIV;break;
		case MOD:return fcall( "__bbFMod",l,r );
		case '^':return fcall( "__bbFPow",l,r );
		}
	}
	return d_new TNode( n,l,r );
}

/////////////////////////
// relation expression //
/////////////////////////
ExprNode *RelExprNode::semant( Environ *e ){
	lhs=lhs->semant(e);
	rhs=rhs->semant(e);
	if( lhs->sem_type->structType() || rhs->sem_type->structType() ){
		if( op!='=' && op!=NE ) ex( "Illegal operator for custom type objects" );
		opType=lhs->sem_type!=Type::null_type ? lhs->sem_type : rhs->sem_type;
	}else if( lhs->sem_type==Type::string_type || rhs->sem_type==Type::string_type ){
		opType=Type::string_type;
	}else if( lhs->sem_type==Type::float_type || rhs->sem_type==Type::float_type ){
		opType=Type::float_type;
	}else{
		opType=Type::int_type;
	}
	sem_type=Type::int_type;
	lhs=lhs->castTo( opType,e );
	rhs=rhs->castTo( opType,e );
	ConstNode *lc=lhs->constNode(),*rc=rhs->constNode();
	if( lc && rc ){
		ExprNode *expr;
		if( opType==Type::string_type ){
			switch( op ){
			case '<':expr=d_new IntConstNode( lc->stringValue()< rc->stringValue() );break;
			case '=':expr=d_new IntConstNode( lc->stringValue()==rc->stringValue() );break;
			case '>':expr=d_new IntConstNode( lc->stringValue()> rc->stringValue() );break;
			case LE: expr=d_new IntConstNode( lc->stringValue()<=rc->stringValue() );break;
			case NE: expr=d_new IntConstNode( lc->stringValue()!=rc->stringValue() );break;
			case GE: expr=d_new IntConstNode( lc->stringValue()>=rc->stringValue() );break;
			}
		}else if( opType==Type::float_type ){
			switch( op ){
			case '<':expr=d_new IntConstNode( lc->floatValue()< rc->floatValue() );break;
			case '=':expr=d_new IntConstNode( lc->floatValue()==rc->floatValue() );break;
			case '>':expr=d_new IntConstNode( lc->floatValue()> rc->floatValue() );break;
			case LE: expr=d_new IntConstNode( lc->floatValue()<=rc->floatValue() );break;
			case NE: expr=d_new IntConstNode( lc->floatValue()!=rc->floatValue() );break;
			case GE: expr=d_new IntConstNode( lc->floatValue()>=rc->floatValue() );break;
			}
		}else{
			switch( op ){
			case '<':expr=d_new IntConstNode( lc->intValue()< rc->intValue() );break;
			case '=':expr=d_new IntConstNode( lc->intValue()==rc->intValue() );break;
			case '>':expr=d_new IntConstNode( lc->intValue()> rc->intValue() );break;
			case LE: expr=d_new IntConstNode( lc->intValue()<=rc->intValue() );break;
			case NE: expr=d_new IntConstNode( lc->intValue()!=rc->intValue() );break;
			case GE: expr=d_new IntConstNode( lc->intValue()>=rc->intValue() );break;
			}
		}
		delete this;
		return expr;
	}
	return this;
}

TNode *RelExprNode::translate( Codegen *g ){
	TNode *l=lhs->translate( g );
	TNode *r=rhs->translate( g );
	return compare( op,l,r,opType );
}

////////////////////
// New expression //
////////////////////
ExprNode *NewNode::semant( Environ *e ){
	sem_type=e->findType( ident );
	if( !sem_type ) ex( "custom type name not found" );
	if( sem_type->structType()==0 ) ex( "type is not a custom type" );
	return this;
}

TNode *NewNode::translate( Codegen *g ){
	return call( "__bbObjNew",global( "_t"+ident ) );
}

////////////////////
// First of class //
////////////////////
ExprNode *FirstNode::semant( Environ *e ){
	sem_type=e->findType( ident );
	if( !sem_type ) ex( "custom type name name not found" );
	return this;
}

TNode *FirstNode::translate( Codegen *g ){
	return call( "__bbObjFirst",global( "_t"+ident ) );
}

///////////////////
// Last of class //
///////////////////
ExprNode *LastNode::semant( Environ *e ){
	sem_type=e->findType( ident );
	if( !sem_type ) ex( "custom type name not found" );
	return this;
}

TNode *LastNode::translate( Codegen *g ){
	return call( "__bbObjLast",global( "_t"+ident ) );
}

////////////////////
// Next of object //
////////////////////
ExprNode *AfterNode::semant( Environ *e ){
	expr=expr->semant( e );
	if( expr->sem_type==Type::null_type ) ex( "'After' cannot be used on 'Null'" );
	if( expr->sem_type->structType()==0 ) ex( "'After' must be used with a custom type object" );
	sem_type=expr->sem_type;
	return this;
}

TNode *AfterNode::translate( Codegen *g ){
	TNode *t=expr->translate( g );
	if( g->debug ) t=jumpf( t,"__bbNullObjEx" );
	return call( "__bbObjNext",t );
}

////////////////////
// Prev of object //
////////////////////
ExprNode *BeforeNode::semant( Environ *e ){
	expr=expr->semant( e );
	if( expr->sem_type==Type::null_type ) ex( "'Before' cannot be used with 'Null'" );
	if( expr->sem_type->structType()==0 ) ex( "'Before' must be used with a custom type object" );
	sem_type=expr->sem_type;
	return this;
}

TNode *BeforeNode::translate( Codegen *g ){
	TNode *t=expr->translate( g );
	if( g->debug ) t=jumpf( t,"__bbNullObjEx" );
	return call( "__bbObjPrev",t );
}

/////////////////
// Null object //
/////////////////
ExprNode *NullNode::semant( Environ *e ){
	sem_type=Type::null_type;
	return this;
}

TNode *NullNode::translate( Codegen *g ){
	return d_new TNode( IR_CONST,0,0,0 );
}

/////////////////
// Object cast //
/////////////////
ExprNode *ObjectCastNode::semant( Environ *e ){
	expr=expr->semant( e );
	expr=expr->castTo( Type::int_type,e );
	sem_type=e->findType( type_ident );
	if( !sem_type ) ex( "custom type name not found" );
	if( !sem_type->structType() ) ex( "type is not a custom type" );
	return this;
}

TNode *ObjectCastNode::translate( Codegen *g ){
	TNode *t=expr->translate( g );
	t=call( "__bbObjFromHandle",t,global( "_t"+sem_type->structType()->ident ) );
	return t;
}

///////////////////
// Object Handle //
///////////////////
ExprNode *ObjectHandleNode::semant( Environ *e ){
	expr=expr->semant( e );
	if( !expr->sem_type->structType() ) ex( "'ObjectHandle' must be used with an object" );
	sem_type=Type::int_type;
	return this;
}

TNode *ObjectHandleNode::translate( Codegen *g ){
	TNode *t=expr->translate( g );
	return call( "__bbObjToHandle",t );
}