#include "ProjectParser.h"
#include "Component.h"
#include "Generator.h"
#include "HostPlatform.h"
#include "Project.h"
#include "SharedRef.h"
#include "TokenStream.h"
#include "ToolChain.h"

#include <iostream>
#include <vector>

class Block;
class Declaration;
class Expression;

class Context
{
	public:
		Context(Project& aProject, TokenStream& anInput)
		: theProject(aProject), Input(anInput)
		{
		}

		SharedPtr<Declaration> lookup(const std::string& Name);

		Project& theProject;
		TokenStream& Input;
		std::vector<Block*> Stack;
	private:
		Context& operator=(const Context&) { return *this; }
};

SharedPtr<Expression> memberCall(Context& Here, SharedPtr<Declaration> This,
	SharedPtr<Executable>& Object, const std::string& Name, 
	const std::vector<SharedPtr<Expression> >& Arguments);
SharedPtr<Expression> memberCall(Context& Here, SharedPtr<Declaration> This,
	SharedPtr<Generator>& Object, const std::string& Name, 
	const std::vector<SharedPtr<Expression> >& Arguments);
SharedPtr<Expression> evaluateBuiltIn(Context& Here, const std::vector<std::string>::const_iterator Begin,
	const std::vector<std::string>::const_iterator End);

class Statement
{
	public:
		Statement()
		{
		}
		virtual ~Statement()
		{
		}

		virtual void print(const std::string& id) const = 0;
		virtual void execute(Context& Here) = 0;
};

class EmptyStatement : public Statement
{
	public:
		virtual void print(const std::string&) const
		{
		}
		virtual void execute(Context&)
		{
		}
};

class Expression : public Statement
{
	public:
		virtual SharedPtr<Expression> evaluate(Context& Here) const = 0;
};

class VoidExpression : public Expression
{
	public:
		virtual void print(const std::string&) const
		{
			std::cout << "(void)" << std::endl;
		}
		virtual void execute(Context&)
		{
		}
		virtual SharedPtr<Expression> evaluate(Context&) const
		{
			return new VoidExpression;
		}

};

class BoolExpression : public Expression
{
	public:
		BoolExpression(bool aValue)
		: Value(aValue)
		{
		}

		virtual void print(const std::string& id) const
		{
			std::cout << id << (Value?"true":"false") << std::endl;
		}
		virtual void execute(Context&)
		{
		}
		virtual SharedPtr<Expression> evaluate(Context&) const
		{
			return new BoolExpression(Value);
		}
		bool value() const
		{
			return Value;
		}
	private:
		bool Value;
};

class StringLiteral : public Expression
{
	public:
		StringLiteral(const std::string& aContent)
		: Content(aContent)
		{
		}

		virtual void print(const std::string& id) const
		{
			std::cout << id << "\"" << Content << "\"" << std::endl;
		}
		virtual void execute(Context&)
		{
		}
		virtual SharedPtr<Expression> evaluate(Context&) const
		{
			return new StringLiteral(Content);
		}
		const std::string& content() const
		{
			return Content;
		}

	private:
		std::string Content;
};


class Declaration : public Expression
{
	public:
		typedef enum {Executable, CCSource, Component, Generator} Type;

		Declaration(Type aWhat, const std::string& aName, const std::vector<SharedPtr<Expression> >& Args)
			: What(aWhat), Name(aName), Arguments(Args)
		{
		}
		Declaration(SharedPtr< ::Component> aComp)
			: What(Component), Name(""),
			  AsComponent(aComp)
		{
		}
		Declaration(SharedPtr< ::CCSource> aSource)
		: What(CCSource), Name(""), AsCCSource(aSource)
		{
		}
		Declaration(const Declaration& other)
			: What(other.What), Name(other.Name),
			  AsExecutable(other.AsExecutable),
			  AsComponent(other.AsComponent),
			  AsGenerator(other.AsGenerator)
		{
		}
		SharedPtr< ::Component> component()
		{
			return AsComponent;
		}
		SharedPtr< ::CCSource> ccSource()
		{
			return AsCCSource;
		}
		virtual void print(const std::string& id) const
		{
			std::cout << id << "DECLARATION OF " << Name << " AS ";
			switch (What)
			{
			case Executable: std::cout << "Executable("; break;
			case CCSource: std::cout << "CCSource("; break;
			case Component: std::cout << "Component("; break;
			case Generator: std::cout << "Generator("; break;
			}
			for (unsigned int i=0; i<Arguments.size(); ++i)
			{
				if (i)
					std::cout << id << " ," << std::endl;
				Arguments[i]->print(id+"   ");
			}
			std::cout << id << ")" << std::endl;
			
		}
		const std::string& name() const
		{
			return Name;
		}
		virtual void execute(Context& Here)
		{
			if (Name.length() && !Here.lookup(Name).isNull())
				Here.Input.error("Declaration of "+Name+" shadows earlier one.");
			switch (What)
			{
				case Executable:
					if (AsExecutable.isNull())
					{
						AsExecutable = new ::Executable(Name);
						Here.theProject.add(AsExecutable);
						::memberCall(Here,SharedPtr<Declaration>(),AsExecutable,"",Arguments);
					}
					break;
				case CCSource:
					// TODO
					break;
				case Component:
					if (AsComponent.isNull())
					{
						Here.Input.error("Can't instantiate a component yourself");
					}
					break;
				case Generator:
					if (AsGenerator.isNull())
					{
						std::vector<std::string> Template;
						for (unsigned int i=0; i<Arguments.size(); ++i)
						{
							SharedPtr<StringLiteral> Arg(
								Arguments[i]->evaluate(Here).dynamicCast<StringLiteral>());
							if (Arg.isNull())
								Here.Input.error("Argument of Generator constructor must be a string");
							else
								Template.push_back(Arg->content());
						}
						AsGenerator = new ::Generator(Template);
						AsGenerator->configuration().setParent(
							&Here.theProject.configuration());
					}
					break;
			};
		}

		SharedPtr<Expression> memberCall(Context& Here, SharedPtr<Declaration>& This, const std::string& Name, 
			const std::vector<SharedPtr<Expression> >& Arguments)
		{
			switch (What)
			{
				case Executable:
					return ::memberCall(Here,This,AsExecutable,Name,Arguments);
					break;
				case CCSource:
					// TODO
					break;
				case Component:
					Here.Input.error("Component does not support call "+Name);
					break;
				case Generator:
					return ::memberCall(Here,This,AsGenerator,Name,Arguments);
					break;
			}
			return new VoidExpression;
		}

		virtual SharedPtr<Expression> evaluate(Context&) const
		{
			SharedPtr<Expression> Result(new Declaration(*this));
			return Result;
		}

	private:
		Type What;
		std::string Name;
		SharedPtr< ::Executable> AsExecutable;
		SharedPtr< ::CCSource> AsCCSource;
		SharedPtr< ::Component> AsComponent;
		SharedPtr< ::Generator> AsGenerator;
		std::vector<SharedPtr<Expression> > Arguments;
};

class VariablePtrerence : public Expression
{
	public:
		VariablePtrerence(const std::string& aName)
		: Name(aName)
		{
		}
		virtual void print(const std::string& id) const
		{
			std::cout << id << Name << std::endl;
		}

		virtual void execute(Context& Here)
		{
			evaluate(Here);
		}

		SharedPtr<Expression> evaluate(Context& Here) const
		{
			SharedPtr<Declaration> Var(Here.lookup(Name));
			if (Var.isNull())
			{
				Here.Input.error("Unkown object "+Name);
				return new VoidExpression;
			}
			return Var.validCast<Expression>();
		}
	private:
		std::string Name;
};

class BuiltInVariable : public Expression
{
	public:
		BuiltInVariable(const std::string& a, const std::string& b)
		{
			Names.push_back(a);
			Names.push_back(b);
		}
		BuiltInVariable(const std::vector<std::string> & aNames)
		: Names(aNames)
		{
		}

		virtual void print(const std::string& id) const
		{
			std::cout << id;
			for (unsigned int i=0;i<Names.size(); ++i)
				std::cout << (i?" :: ":"") << Names[i];
			std::cout << std::endl;
		}

		virtual void execute(Context&)
		{
		}

		SharedPtr<Expression> evaluate(Context& Here) const
		{
			return evaluateBuiltIn(Here,Names.begin(),Names.end());
		}

		bool is(const std::string& What) const
		{
			std::string Total;
			for (unsigned int i=0; i<Names.size(); ++i)
				Total += (i?"::":"")+Names[i];
			return Total == What;
		}
	private:
		std::vector<std::string> Names;
};
class MemberCall : public Expression
{
	public:
		MemberCall(SharedPtr<Expression> anObj, const std::string& aName, 
			const std::vector<SharedPtr<Expression> >& Args)
		: Object(anObj), Name(aName), Arguments(Args)
		{
			if (Object.isNull())
				Object = new VoidExpression;
		}

		virtual void print(const std::string& id) const
		{
			Object->print(id);
			std::cout << id << " . " << Name << " (";
			for (unsigned int i=0; i<Arguments.size(); ++i)
			{
				if (i)
					std::cout << id << "   ," << std::endl;
				Arguments[i]->print(id+"   ");
			}
			if (Arguments.size())
				std::cout << id << " )" << std::endl;
			else
				std::cout << " )" << std::endl;
		}
		virtual void execute(Context& Here)
		{
			evaluate(Here);
		}
		virtual SharedPtr<Expression> evaluate(Context& Here) const
		{
			SharedPtr<Declaration> Var(Object->evaluate(Here).dynamicCast<Declaration>());
			if (Var.isNull())
				Here.Input.error("Left hand side of member call was not a composite object");
			else
				return Var->memberCall(Here,Var,Name,Arguments);
			return new VoidExpression;
		}
	private:
		SharedPtr<Expression> Object;
		std::string Name;
		std::vector<SharedPtr<Expression> > Arguments;
};

class ShiftLeftExpression : public Expression
{
	public:
		ShiftLeftExpression(SharedPtr<Expression> aLeft, SharedPtr<Expression> aRight)
		: Left(aLeft), Right(aRight)
		{
			if (Left.isNull())
				Left = new VoidExpression;
			if (Right.isNull())
				Right = new VoidExpression;
		}
		virtual void print(const std::string& id) const
		{
			Left->print(id);
			std::cout << id << " << ";
			Right->print(id+" ");
		}
		virtual void execute(Context& Here)
		{
			evaluate(Here);
		}
		virtual SharedPtr<Expression> evaluate(Context& Here) const
		{
			SharedPtr<Expression> First(Left->evaluate(Here));
			SharedPtr<BuiltInVariable> FirstAsBuiltIn(First.dynamicCast<BuiltInVariable>());
			if (!FirstAsBuiltIn.isNull() && FirstAsBuiltIn->is("std::cout"))
			{
				SharedPtr<Expression> Second(Right->evaluate(Here));
				SharedPtr<StringLiteral> SecondAsString(Second.dynamicCast<StringLiteral>());
				if (!SecondAsString.isNull())
				{
					std::cout << SecondAsString->content();
					return First;
				}
				SharedPtr<BuiltInVariable> SecondAsVariable(Second.dynamicCast<BuiltInVariable>());
				if (!SecondAsVariable.isNull() && SecondAsVariable->is("std::endl"))
				{
					std::cout << std::endl;
					return First;
				}
				Here.Input.error("Can't print right hand side of left shift");
				return First;
			}
			Here.Input.error("Invalid expression type for left argument of left shift.");
			return new VoidExpression;
		}
	private:
		SharedPtr<Expression> Left, Right;
};


class Block : public Statement
{
	public:
		Block()
		: StatementsSeen(0)
		{
		}
		void add(const SharedPtr<Statement>& One)
		{
			List.push_back(One);
		}
		virtual void execute(Context& Here)
		{
			Here.Stack.push_back(this);
			for (StatementsSeen=0; StatementsSeen<List.size(); ++StatementsSeen)
				List[StatementsSeen]->execute(Here);
			Here.Stack.pop_back();
		}
		virtual void print(const std::string& id) const
		{
			std::cout << id << "{" << std::endl;
			for (unsigned int i=0; i<List.size(); ++i) 
				List[i]->print(id+" ");
			std::cout << id << "}" << std::endl;
		}
		void clear()
		{
			List.clear();
		}
		SharedPtr<Declaration> lookup(const std::string& Name)
		{
			for (unsigned int i=0; i<StatementsSeen; ++i)
			{
				SharedPtr<Declaration> Current(List[i].dynamicCast<Declaration>());
				if (!Current.isNull() && (Current->name() == Name))
					return Current;
			}
			return SharedPtr<Declaration>();
		}

	private:
		std::vector<SharedPtr<Statement> > List;
		unsigned int StatementsSeen;
};


class IfStatement : public Statement
{
	public:
		IfStatement(SharedPtr<Expression> aCond, SharedPtr<Statement> anIf, SharedPtr<Statement> anElse)
		: Condition(aCond), If(anIf), Else(anElse)
		{
			if (Condition.isNull())
				Condition = new StringLiteral("");
			if (If.isNull())
				If = new EmptyStatement;
			if (Else.isNull())
				Else = new EmptyStatement;
		}

		virtual void print(const std::string& id) const
		{
			std::cout << id << "if (" << std::endl;
			Condition->print(id+"    ");
			std::cout << id << ")" << std::endl << id << "{" << std::endl;
			If->print(id+"   ");
			std::cout << id << "} else {" << std::endl;
			Else->print(id+"   ");
			std::cout << id << "}" << std::endl;
		}
		virtual void execute(Context& Here)
		{
			SharedPtr<BoolExpression> Result(Condition->evaluate(Here).dynamicCast<BoolExpression>());
			if (Result.isNull())
				Here.Input.error("Condition on if-clause does not evaluate to boolean expression.");
			else
			{
				if (Result->value())
					If->execute(Here);
				else
					Else->execute(Here);
			}
		}
	private:
		SharedPtr<Expression> Condition;
		SharedPtr<Statement> If,Else;
};

/* CONTEXT */

SharedPtr<Declaration> Context::lookup(const std::string& Name)
{
	for (unsigned int i=Stack.size(); i; --i)
	{
		SharedPtr<Declaration> Test(Stack[i-1]->lookup(Name));
		if (!Test.isNull())
			return Test;
	}
	return SharedPtr<Declaration>();
}

/* PROJECTPARSER */

class ProjectParser
{
	public:
		ProjectParser(Project& aProject, const std::string& Filename, bool aMode);

	private:
		SharedPtr<Statement> statement(SharedPtr<Block>& Scope);
		SharedPtr<Block> block(SharedPtr<Block>& Scope);
		SharedPtr<Statement> declaration(SharedPtr<Block>& Scope);
		SharedPtr<Statement> ifStatement(SharedPtr<Block>& Scope);
		SharedPtr<Expression> expression();
		SharedPtr<Expression> factorExpression();
		SharedPtr<Expression> basicExpression();
		SharedPtr<Expression> builtinVariable();
		std::vector<SharedPtr<Expression> > argumentList(bool Mandatory);
		void skipToEndOfStatement();

		TokenStream Input;
		SharedPtr<Block> Global;
		bool DiscoveryMode;
};

ProjectParser::ProjectParser(Project& theProject, const std::string& Filename, bool aMode)
: Input(Filename), Global(new Block), DiscoveryMode(aMode)
{
	while (!Input.eos())
	{
		SharedPtr<Statement> Next(statement(Global));
		if (Next.isNull())
		{
			skipToEndOfStatement();
			Input.error("expected a statement got "+Input.cToken());
		}
		else
			Global->add(Next);
		Input.whiteSpace();
	}
	Global->print("");
	if (Input.errors())
	{
		std::cerr << Input.errors() << " error(s) detected" << std::endl;
		return;
	}
	Context theContent(theProject,Input);
	Global->execute(theContent);
}

void ProjectParser::skipToEndOfStatement()
{
	while (!Input.eosButWhite())
	{
		std::string Token(Input.cToken());
		if (Token == "}") break;
		if (Token == ";") break;
	}
}

SharedPtr<Statement> ProjectParser::statement(SharedPtr<Block>& Scope)
{
	SharedPtr<Block> AsBlock(block(Scope));
	if (!AsBlock.isNull())
		return AsBlock.validCast<Statement>();
	SharedPtr<Statement> AsIf(ifStatement(Scope));
	if (!AsIf.isNull())
		return AsIf;
	SharedPtr<Statement> AsDeclaration(declaration(Scope));
	if (!AsDeclaration.isNull())
	{
		if (!Input.literal(";"))
			Input.error("; expected after declaration");
		return AsDeclaration;
	}
	SharedPtr<Expression> AsExpression(expression());
	if (!AsExpression.isNull())
	{
		if (!Input.literal(";"))
			Input.error("; expected after expression");
		return AsExpression.validCast<Statement>();
	}
/*
	if (assignmentStatement())
	{
		if (!Input.literal(";"))
			Input.error("; expected after assignment");
		return true;
	} */
	return SharedPtr<Statement>();
}

SharedPtr<Block> ProjectParser::block(SharedPtr<Block>& )
{
	if (!Input.literal("{"))
		return SharedPtr<Block>();
	SharedPtr<Block> NewBlock(new Block);
	while (!Input.eos())
	{
		if (Input.literal("}"))
			return NewBlock;
		SharedPtr<Statement> Next(statement(NewBlock));
		if (Next.isNull())
		{
			Input.error("expected a statement got "+Input.cToken());
			skipToEndOfStatement();
		}
		else
			NewBlock->add(Next);
		Input.whiteSpace();
	}
	Input.error("unexpected end of file, expected } to close statement block");
	return NewBlock;
}

SharedPtr<Statement> ProjectParser::ifStatement(SharedPtr<Block>& Scope)
{
	if (!Input.literal("if")) return SharedPtr<Statement>();
	if (!Input.literal("("))
		Input.error("expecting ( after if");
	SharedPtr<Expression> Condition(expression());
	if (Condition.isNull())
	{
		Input.error("expecting an expression for if clause");
	}
	if (!Input.literal(")"))
		Input.error("expecting ) to close if-expression");
	SharedPtr<Statement> If(statement(Scope));
	if (If.isNull())
	{
		Input.error("expecting a statement after if expression");
		skipToEndOfStatement();
	}
	SharedPtr<Statement> Else;
	if (Input.literal("else"))
	{
		Else = statement(Scope);
		if (Else.isNull())
			Input.error("expecting a statement after else expression");	
	}
	return new IfStatement(Condition,If,Else);
}

SharedPtr<Statement> ProjectParser::declaration(SharedPtr<Block>& Scope)
{
	if (Input.literal("Executable"))
	{
		std::string Name = Input.cIdentifier();
		if (!Name.length())
			Input.error("Name expected for Executable");
		else if (!Scope->lookup(Name).isNull())
			Input.error("Name already used");
		else
			return new Declaration(Declaration::Executable,Name,argumentList(false));
		return new EmptyStatement;
	}
	else if (Input.literal("CCSource"))
	{
		std::string Name = Input.cIdentifier();
		if (!Name.length())
		{
			Input.error("Name expected for CCSource");
			return new EmptyStatement;	// TODO pass empty statement instead
		}
		// TODO check if name already exists
		// also check constructor
		SharedPtr<Statement> Result(new Declaration(Declaration::CCSource,Name,argumentList(false)));
//		ccSourceConstructor(PV);
		return Result;
	}
	else if (Input.literal("Generator"))
	{
		std::string Name(Input.cIdentifier());
		if (!Name.length())
		{
			Input.error("Name expeced for Generator");
			return new EmptyStatement;
		}
		return new Declaration(Declaration::Generator,Name,argumentList(false));
	}
	return SharedPtr<Statement>();
}

SharedPtr<Expression> ProjectParser::expression()
{
	SharedPtr<Expression> Result(factorExpression());
	if (!Result.isNull())
	{
		while (Input.literal("<<"))
		{
			SharedPtr<Expression> Right(factorExpression());
			if (Right.isNull())
				Input.error("Expression expected as right hand side of left shift");
			Result = new ShiftLeftExpression(Result,Right);
		}
	}
	return Result;
}

SharedPtr<Expression> ProjectParser::factorExpression()
{
	SharedPtr<Expression> Object(basicExpression());
	while (!Object.isNull() && Input.literal("."))
	{
		std::string MemberName(Input.cIdentifier());
		if (!MemberName.length())
		{
			Input.error("Member name expected after .");
			break;
		}
		Object = new MemberCall(Object,MemberName,argumentList(true));
	}
	return Object;
}

std::vector<SharedPtr<Expression> > ProjectParser::argumentList(bool Mandatory)
{
	std::vector<SharedPtr<Expression> > Arguments;
	if (Mandatory && !Input.literal("("))
	{
		Input.error("Argument list expected.");
		return Arguments;
	}
	else if (!Mandatory && !Input.literal("("))
		return Arguments;
	bool First = true;
	while (!Input.literal(")"))
	{
		if (Input.eos())
		{
			Input.error("End of stream reached instead of )");
			break;
		}
		if (!First && !Input.literal(","))
			Input.error("expected , between arguments");
		First = false;
		SharedPtr<Expression> Argument(expression());
		if (Argument.isNull())
			Input.error("expected an expression");
		else
			Arguments.push_back(Argument);
	}
	return Arguments;
}

SharedPtr<Expression> ProjectParser::basicExpression()
{
	if (Input.literal("true"))
		return new BoolExpression(true);
	if (Input.literal("false"))
		return new BoolExpression(false);
	std::string StringLit(Input.cString());
	if (StringLit.size())
		return new StringLiteral(StringLit.substr(1,StringLit.length()));
	SharedPtr<Expression> AsBuiltIn(builtinVariable());
	if (!AsBuiltIn.isNull())
		return AsBuiltIn;
	std::string Identifier(Input.cIdentifier());
	if (Identifier.length())
		return new VariablePtrerence(Identifier);
	return SharedPtr<Expression>();
}

SharedPtr<Expression> ProjectParser::builtinVariable()
{
	TokenPoint Pt(Input);
	std::vector<std::string> Names;
	std::string Name = Input.cIdentifier();
	if (!Name.length() || !Input.literal("::"))
		return SharedPtr<Expression>();
	Names.push_back(Name);
	do
	{
		Name = Input.cIdentifier();
		if (!Name.length())
		{
			Input.error("Expected identifier after ::");
			break;
		}
		Names.push_back(Name);
	} while (Input.literal("::"));
	Pt.accept();
	return new BuiltInVariable(Names);
}


#if 0
bool ProjectParser::assignmentStatement()
{
	TokenPoint Pt(Input);
	VariablePtr* PV(existingVar(true));
	if (!PV) return false;
	VariablePtr LeftSide(*PV);
	if (Input.cToken() != "=")
		return false;
	VariablePtr RightSide(expression());
	if (SilentLockCount) return Pt.accept();
	std::string err(LeftSide->assignFrom(RightSide));
	if (err.length()) Input.error(err);
	return Pt.accept();
}

#endif

void executableConstructor(Context& Here, SharedPtr<Executable>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	if (!Arguments.size()) return;
	if (Arguments.size() != 1)
	{
		Here.Input.error("Executable constructor does not match Executable() or Executable(std::string)");
		return;
	}
	SharedPtr<StringLiteral> Name(Arguments[0]->evaluate(Here).dynamicCast<StringLiteral>());
	if (Name.isNull())
	{
		Here.Input.error("Executable constructor does not match Executable() or Executable(std::string)");
		return;
	}
	Object->setName(Name->content());
}

void executableAdd(Context& Here, SharedPtr<Executable>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	for (unsigned int i=0; i<Arguments.size(); ++i)
	{
		SharedPtr<Expression> Result(Arguments[i]->evaluate(Here));
		SharedPtr<StringLiteral> AsString(Result.dynamicCast<StringLiteral>());
		if (AsString.isNull())
		{
			SharedPtr<Declaration> AsDecl(Result.dynamicCast<Declaration>());
			if (AsDecl.isNull() || AsDecl->ccSource().isNull())
				Here.Input.error("Argument to Executable::add is not a string or ccsource");
			else
				Object->add(AsDecl->ccSource());
		}
		else
			Object->add(new CCSource(AsString->content()));
	}
}

void executableDefine(Context& Here, SharedPtr<Executable>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	for (unsigned int i=0; i<Arguments.size(); ++i)
	{
		SharedPtr<StringLiteral> Result(Arguments[i]->evaluate(Here).dynamicCast<StringLiteral>());
		if (Result.isNull())
			Here.Input.error("Argument to Executable::define is not a string");
		else
			Object->configuration().addDefine(Result->content());
	}
}

void executableUse(Context& Here, SharedPtr<Executable>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	for (unsigned int i=0; i<Arguments.size(); ++i)
	{
		SharedPtr<Declaration> Result(Arguments[i]->evaluate(Here).dynamicCast<Declaration>());
		if (Result.isNull() || Result->component().isNull())
			Here.Input.error("Executable::use called with a wrong parameter");
		else
			Object->add(Result->component());
	}
}

SharedPtr<Expression> memberCall(Context& Here, SharedPtr<Declaration> This, SharedPtr<Executable>& Object, 
	const std::string& Name, const std::vector<SharedPtr<Expression> >& Arguments)
{
	if (Name == "")
	{
		executableConstructor(Here,Object,Arguments);
		return This.validCast<Expression>();
	}
	else if (Name == "add")
	{
		executableAdd(Here, Object,Arguments);
		return This.validCast<Expression>();
	}
	else if (Name == "define")
	{
		executableDefine(Here,Object,Arguments);
		return This.validCast<Expression>();
	}
	else if (Name == "use")
	{
		executableUse(Here,Object,Arguments);
		return This.validCast<Expression>();
	}
	else
		Here.Input.error("Unknown membercall "+Name);
	return new VoidExpression;
}

void generatorOutput(Context& Here, SharedPtr<Generator>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	if (Arguments.size() != 1)
	{
		Here.Input.error("Generator::output takes one std::string argument");
		return;
	}
	SharedPtr<StringLiteral> Result(Arguments[0]->evaluate(Here).dynamicCast<StringLiteral>());
	if (Result.isNull())
		Here.Input.error("Argument to Executable::output is not a string");
	else
		Object->setOutput(Result->content());
}

void generatorInput(Context& Here, SharedPtr<Generator>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	for (unsigned int i=0; i<Arguments.size(); ++i)
	{
		SharedPtr<StringLiteral> Result(Arguments[i]->evaluate(Here).dynamicCast<StringLiteral>());
		if (Result.isNull())
			Here.Input.error("Argument to Generator::input is not a string");
		else
			Object->addInput(Result->content());
	}
}


SharedPtr<Expression> generatorMakeCCSource(Context& Here, SharedPtr<Generator>& Object,
	const std::vector<SharedPtr<Expression> >& Arguments)
{
	if (Arguments.size())
		Here.Input.error("Generator::makeCCSource takes no arguments");
	return new Declaration(new GeneratedCCSource(Object));	
}

SharedPtr<Expression> memberCall(Context& Here, SharedPtr<Declaration> This, SharedPtr<Generator>& Object, 
	const std::string& Name, const std::vector<SharedPtr<Expression> >& Arguments)
{
	if (Name == "output")
	{
		generatorOutput(Here, Object,Arguments);
		return This.validCast<Expression>();
	}
	else if (Name == "input")
	{
		generatorInput(Here,Object,Arguments);
		return This.validCast<Expression>();
	}
	else if (Name == "makeCCSource")
		return generatorMakeCCSource(Here,Object,Arguments);
	else
		Here.Input.error("Unknown membercall "+Name);
	return new VoidExpression;
}


SharedPtr<Expression> evaluateHostPlatformBuiltIn(Context& Here, const std::vector<std::string>::const_iterator Begin,
	const std::vector<std::string>::const_iterator End)
{
	if (Begin == End)
	{
		Here.Input.error("Subnamespace expected");
		return new VoidExpression;
	}
	if (Begin+1 != End)
	{
		Here.Input.error("Subnamespace not expected");
		return new VoidExpression;
	}
	if (*Begin == "is_windows")
		return new BoolExpression(hostIsWindows());
	else if (*Begin == "is_macosx")
		return new BoolExpression(hostIsMacOSX());
	else
		Here.Input.error("Unknown variable "+*Begin);
	return new VoidExpression;
}

SharedPtr<Expression> evaluateStdBuiltIn(Context& Here, const std::vector<std::string>::const_iterator Begin,
	const std::vector<std::string>::const_iterator End)
{
	if (Begin == End)
	{
		Here.Input.error("Subnamespace expected");
		return new VoidExpression;
	}
	if (*Begin == "cout")
		return new BuiltInVariable("std","cout");
	else if (*Begin == "endl")
		return new BuiltInVariable("std","endl");
	else if (*Begin == "target_platform")
		// TODO CROSSCOMPILING then target!=host
		return evaluateHostPlatformBuiltIn(Here,Begin+1,End);
	else if (*Begin == "host_platform")
		return evaluateHostPlatformBuiltIn(Here,Begin+1,End);
	else
	{
		Here.Input.error("Unknown namespace "+*Begin);
		return new VoidExpression;
	}
}

SharedPtr<Expression> evaluateLibraryBuiltIn(Context& Here, const std::vector<std::string>::const_iterator Begin,
	const std::vector<std::string>::const_iterator End)
{

	if (Begin == End)
	{
		Here.Input.error("Subnamespace expected");
		return new VoidExpression;
	}
	std::string Total;
	for (std::vector<std::string>::const_iterator i=Begin; i!=End; ++i)
	{
		if (i!=Begin)
			Total+="::";
		Total += *i;
	}
	SharedPtr<Component> Result(createComponentFromName(Total));
	if (Result.isNull())
	{
		Here.Input.error("Unkown component "+Total);
		return new VoidExpression;
	}
	return new Declaration(Result);
}

SharedPtr<Expression> evaluateBuiltIn(Context& Here, const std::vector<std::string>::const_iterator Begin,
	const std::vector<std::string>::const_iterator End)
{
	if (Begin == End)
	{
		Here.Input.error("Subnamespace expected");
		return new VoidExpression;
	}
	if (*Begin == "std")
		return evaluateStdBuiltIn(Here,Begin+1,End);
	else if (*Begin == "library")
		return evaluateLibraryBuiltIn(Here,Begin+1,End);
	else
	{
		Here.Input.error("Unknown namespace "+*Begin);
		return new VoidExpression;
	}
}

void parse(Project& theProject, const std::string& Filename, bool DiscoveryMode)
{
	ProjectParser PP(theProject, Filename, DiscoveryMode);
}