Expressions.cpp

#include <jetscript/Expressions.h>
#include <jetscript/Compiler.h>
#include <jetscript/Parser.h>

using namespace Jet;

void PrefixExpression::Compile(CompilerContext* context)
{
	context->Line(this->_operator.line);

	right->Compile(context);

	context->UnaryOperation(this->_operator.type);

	switch (this->_operator.type)
	{
	case TokenType::BNot:
	case TokenType::Minus:
		{
			if (dynamic_cast<BlockExpression*>(this->Parent))
				context->Pop();
			break;
		}
	default://operators that also do a store, like ++ and --
		{
			auto location = dynamic_cast<IStorableExpression*>(this->right);
			if (location)
			{
				if (dynamic_cast<BlockExpression*>(this->Parent) == 0)
					context->Duplicate();

				location->CompileStore(context);
			}
			else if (dynamic_cast<BlockExpression*>(this->Parent) != 0)
				context->Pop();
		}
	}
}

void PostfixExpression::Compile(CompilerContext* context)
{
	context->Line(this->_operator.line);

	left->Compile(context);

	if (dynamic_cast<BlockExpression*>(this->Parent) == 0 && dynamic_cast<IStorableExpression*>(this->left))
		context->Duplicate();

	context->UnaryOperation(this->_operator.type);

	if (dynamic_cast<IStorableExpression*>(this->left))
		dynamic_cast<IStorableExpression*>(this->left)->CompileStore(context);
	else if (dynamic_cast<BlockExpression*>(this->Parent) != 0)
		context->Pop();
}

void IndexExpression::Compile(CompilerContext* context)
{
	context->Line(token.line);

	left->Compile(context);
	//if the index is constant compile to a special instruction carying that constant
	if (auto string = dynamic_cast<StringExpression*>(index))
	{
		context->LoadIndex(string->GetValue().c_str());
	}
	else
	{
		index->Compile(context);
		context->LoadIndex();
	}

	if (dynamic_cast<BlockExpression*>(this->Parent) != 0)
		context->Pop();
}

void IndexExpression::CompileStore(CompilerContext* context)
{
	context->Line(token.line);

	left->Compile(context);
	//if the index is constant compile to a special instruction carying that constant
	if (auto string = dynamic_cast<StringExpression*>(index))
	{
		context->StoreIndex(string->GetValue().c_str());
	}
	else
	{
		index->Compile(context);
		context->StoreIndex();
	}
}

void ObjectExpression::Compile(CompilerContext* context)
{
	int count = 0;
	if (this->inits)
	{
		count = this->inits->size();
		//set these up
		for (auto ii: *this->inits)
		{
			context->String(ii.first);
			ii.second->Compile(context);
		}
	}
	context->NewObject(count);

	//pop off if we dont need the result
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void ArrayExpression::Compile(CompilerContext* context)
{
	int count = this->initializers.size();
	for (auto i: this->initializers)
		i->Compile(context);

	context->NewArray(count);

	//pop off if we dont need the result
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void StringExpression::Compile(CompilerContext* context)
{
	context->String(this->value);

	//pop off if we dont need the result
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void NullExpression::Compile(CompilerContext* context)
{
	context->Null();

	//pop off if we dont need the result
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void NumberExpression::Compile(CompilerContext* context)
{
	context->Number(this->value);

	//pop off if we dont need the result
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void SwapExpression::Compile(CompilerContext* context)
{
	right->Compile(context);
	left->Compile(context);

	if (auto rstorable = dynamic_cast<IStorableExpression*>(this->right))
		rstorable->CompileStore(context);

	if (dynamic_cast<BlockExpression*>(this->Parent) == 0)
		context->Duplicate();

	if (auto lstorable = dynamic_cast<IStorableExpression*>(this->left))
		lstorable->CompileStore(context);
}

void AssignExpression::Compile(CompilerContext* context)
{
	this->right->Compile(context);

	if (dynamic_cast<BlockExpression*>(this->Parent) == 0)
		context->Duplicate();//if my parent is not block expression, we need the result, so push it

	if (auto storable = dynamic_cast<IStorableExpression*>(this->left))
		storable->CompileStore(context);
}

void CallExpression::Compile(CompilerContext* context)
{
	context->Line(token.line);

	//need to check if left is a local, or a captured value before looking at globals
	if (dynamic_cast<NameExpression*>(left) && context->IsLocal(dynamic_cast<NameExpression*>(left)->GetName()) == false)
	{
		//push args onto stack
		for (auto i: *args)
			i->Compile(context);

		context->Call(dynamic_cast<NameExpression*>(left)->GetName(), args->size());
	}
	else// if (dynamic_cast<IStorableExpression*>(left) != 0)
	{
		auto index = dynamic_cast<IndexExpression*>(left);
		if (index && index->token.type == TokenType::Colon)//its a "self" call
		{
			index->left->Compile(context);//push object as the first argument

			//push args onto stack
			for (auto i: *args)
				i->Compile(context);//pushes args

			//compile left I guess?
			left->Compile(context);//pushes function

			//increase number of args
			context->ECall(args->size()+1);
		}
		else
		{
			//push args onto stack
			for (auto i: *args)
				i->Compile(context);

			//compile left I guess?
			left->Compile(context);

			context->ECall(args->size());
		}
	}
	//else
	//{
	//throw ParserException(token.filename, token.line, "Error: Cannot call an expression that is not a name");
	//}
	//help, how should I handle this for multiple returns
	//pop off return value if we dont need it
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();//if my parent is block expression, we dont the result, so pop it
}

void NameExpression::Compile(CompilerContext* context)
{
	//add load variable instruction
	//todo make me detect if this is a local or not
	context->Load(name);

	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void OperatorAssignExpression::Compile(CompilerContext* context)
{
	context->Line(token.line);
	//https://dl.dropboxusercontent.com/u/675786/ShareX/2015-02/08_22-33-22.png fix this
	this->left->Compile(context);
	this->right->Compile(context);
	context->BinaryOperation(token.type);

	//insert store here
	if (dynamic_cast<BlockExpression*>(this->Parent) == 0)
		context->Duplicate();//if my parent is not block expression, we need the result, so push it

	if (auto storable = dynamic_cast<IStorableExpression*>(this->left))
		storable->CompileStore(context);
}

void OperatorExpression::Compile(CompilerContext* context)
{
	context->Line(this->_operator.line);

	if (this->_operator.type == TokenType::And)
	{
		std::string label = "_endand"+context->GetUUID();
		this->left->Compile(context);
		context->JumpFalsePeek(label.c_str());//jump to endand if false
		context->Pop();
		this->right->Compile(context);
		context->Label(label);//put endand label here
		return;
	}

	if (this->_operator.type == TokenType::Or)
	{
		std::string label = "_endor"+context->GetUUID();
		this->left->Compile(context);
		context->JumpTruePeek(label.c_str());//jump to endor if true
		context->Pop();
		this->right->Compile(context);
		context->Label(label);//put endor label here
		return;
	}

	this->left->Compile(context);
	this->right->Compile(context);
	context->BinaryOperation(this->_operator.type);

	//pop off if we dont need the result
	if (dynamic_cast<BlockExpression*>(this->Parent))
		context->Pop();
}

void FunctionExpression::Compile(CompilerContext* context)
{
	context->Line(token.line);

	std::string fname;
	if (name)
		fname = static_cast<NameExpression*>(name)->GetName();
	else
		fname = "_lambda_id_";

	CompilerContext* function = context->AddFunction(fname, this->args->size(), this->varargs);
	//ok, kinda hacky
	int start = context->out.size();

	//ok push locals, in opposite order
	for (unsigned int i = 0; i < this->args->size(); i++)
	{
		auto aname = static_cast<NameExpression*>((*this->args)[i]);
		function->RegisterLocal(aname->GetName());
	}
	if (this->varargs)
		function->RegisterLocal(this->varargs->GetName());

	block->Compile(function);

	//if last instruction was a return, dont insert another one
	if (block->statements.size() > 0)
	{
		if (dynamic_cast<ReturnExpression*>(block->statements.at(block->statements.size()-1)) == 0)
		{
			function->Null();//return nil
			function->Return();
		}
	}
	else
	{
		function->Null();//return nil
		function->Return();
	}

	context->FinalizeFunction(function);

	//only named functions need to be stored here
	if (name)
		context->Store(static_cast<NameExpression*>(name)->GetName());

	//vm will pop off locals when it removes the call stack
}

void LocalExpression::Compile(CompilerContext* context)
{
	context->Line((*_names)[0].line);

	//add load variable instruction
	for (auto ii: *this->_right)
		ii->Compile(context);

	//make sure to create identifier
	for (auto _name: *this->_names)
		if (context->RegisterLocal(_name.getText()) == false)
			throw CompilerException(context->filename, _name.line, "Duplicate Local Variable '"+_name.text+"'");

	//actually store if we have something to store
	for (int i = _right->size()-1; i >= 0; i--)
		context->StoreLocal((*_names)[i].text);
}