/*

* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:

*

*/

#include "CoreParser.h"

#include <sstream>

#include <iostream>

using namespace std;

ParseResult::ParseResult()

: iRuleId(0), iStart(0), iEnd(0)

	{

	}

bool ParseResult::Matched() const

	{

	return iRuleId != 0;

	}

ParseResult ParseResult::Fail()

	{

	ParseResult p;

	return p;

	}

Parser::Parser()

: iOp(ENul), iMatch(0), iSub1(0), iSub2(0), iId(-1)

	{

	}

Parser::Parser(const char* aMatch)

: iOp(EExact), iMatch(aMatch), iSub1(0), iSub2(0), iId(-1)

	{

	}

Parser::Parser(T0Op aOp)

: iOp(aOp), iMatch(0), iSub1(0), iSub2(0), iId(-1)

	{

	}

Parser::Parser(T1Op aOp, const Parser& aSub)

: iOp(aOp), iMatch(0), iSub1(&aSub), iSub2(0), iId(-1)

	{

	}

Parser::Parser(T2Op aOp, const Parser& aFirst, const Parser& aRest)

: iOp(aOp), iMatch(0), iSub1(&aFirst), iSub2(&aRest), iId(-1)

	{

	}

Parser::Parser(const Parser& aOther)

	{

	*this = aOther;

	}

const Parser& Parser::operator=(const Parser& aOther)

	{

	if (this == &aOther)

		return *this;

	iOp = aOther.iOp;

	iMatch = aOther.iMatch;

	iSub1 = 0;

	iSub2 = 0;

	iSub1 = aOther.iSub1;

	iSub2 = aOther.iSub2;

	iId = aOther.iId;

//	if (aOther.iSub1)

//		iSub1 = new Parser(*aOther.iSub1);

//	if (aOther.iSub2)

//		iSub2 = new Parser(*aOther.iSub2);

	return *this;

	}

Parser::~Parser()

	{

//	delete iSub1;

//	delete iSub2;

	}

Parser Parser::EOS()

	{

	return Parser(EEos);

	}

Parser Parser::Int()

	{

	return Parser(EInt);

	}

Parser Parser::Real()

	{

	return Parser(EReal);

	}

const Parser& Parser::Nul()

	{

	static Parser nul(ENul);

	nul.SetId(0);

	return nul;

	}

ParseResult Parser::Parse(const std::string& aString) const

	{

	vector<Step> stack;

	stack.push_back(Step(this, 0, -1));

	TMatchRes res = EContinue;

	bool done = false;

	while (!stack.empty() && !done)

		{

		Step& top = stack.back();

		int topId = stack.size()-1;

		switch (res)

			{

			case EFail:

				if (top.iRule->iOp == EAlt && top.iStep < 2)

					{

					res = top.iRule->ParseStep(topId, aString, top.iPos, stack);

					}

				else if (top.iRule->iOp == EMult && top.iStep < 2)

					{

					top.iStep = 2;

					res = top.iRule->ParseStep(topId, aString, top.iPos, stack);

					}

				else

					{

					if (top.iParent >= 0 && stack[top.iParent].iRule->iOp == ESeq)

						stack[top.iParent].iStep--;

					stack.pop_back();

					}

				break;

			case EPass:

				{

				int nextSeq = -1;

				for (int i=stack.size()-1; nextSeq==-1 && i>=0; i--)

					{

					if ((stack[i].iRule->iOp == ESeq && stack[i].iStep < 2) || 

						(stack[i].iRule->iOp == EMult && stack[i].iStep < 3))

						nextSeq = i;

					}

				if (nextSeq >= 0)

					res = stack[nextSeq].iRule->ParseStep(nextSeq, aString, top.iResult.iEnd, stack);

				else

					done = true;

				break;

				}

			case EContinue:

				res = top.iRule->ParseStep(topId, aString, top.iPos, stack);

				break;

			}

		}

	if (done)

		{

		for (int i=stack.size()-1; i>=1; i--)

			{

			Step& step = stack[i];

			Step& parent = stack[step.iParent];

			parent.iResult.iChildren.insert(0,step.iResult);//push_front

			if (parent.iResult.iEnd < step.iResult.iEnd)

				parent.iResult.iEnd = step.iResult.iEnd;

			}

		return stack[0].iResult;

		}

	else

		return ParseResult::Fail();

	}

Parser::TMatchRes Parser::ParseStep(int aStepId, const std::string& aString, int aPos, vector<Step>& aStack) const

	{

	Step& step = aStack[aStepId];

	step.iResult.iRuleId = Id();

	switch (iOp)

		{

		case EExact:

			{

			string match(iMatch);

			unsigned int mLen = match.size();

			if (mLen + aPos > aString.size())

				return EFail;

			else if (aString.substr(aPos, mLen) != match)

				return EFail;

			else

				step.iResult.iEnd = aPos + mLen;

			return EPass;

			}

		case EEos:

			{

			if (static_cast<unsigned int>( aPos ) != aString.size())

				return EFail;

			else

				step.iResult.iEnd = aPos;

			return EPass;

			}

		case EInt:

			{

			istringstream strm(aString.substr(aPos));

			int temp;

			strm >> temp;

			int len = strm.tellg();

			if (len >= 0)

				step.iResult.iEnd = aPos + len;

			else

				return EFail;

			return EPass;

			}

		case EReal:

			{

			istringstream strm(aString.substr(aPos));

			double temp;

			strm >> temp;

			int len = strm.tellg();

			if (len >= 0)

				step.iResult.iEnd = aPos + len;

			else

				return EFail;

			return EPass;

			}

		case ENul:

			{

			step.iResult.iChildren.clear();

			step.iResult.iEnd = aPos;

			return EPass;

			}

		case EMult:

			{

/*			Step next(iSub1, aPos, aStepId);

			if (step.iStep == 1)

				next.iRule = this;

			else if (step.iStep == 2)

				next.iRule = &Parser::Nul();

			step.iStep++;

			aStack.push_back(next);

			return EContinue;

*/

			return EFail;

			}

		case ESeq:

			{

			Step next(iSub1, aPos, aStepId);

			if (step.iStep == 1)

				next.iRule = iSub2;

			step.iStep++;

			aStack.push_back(next);

			return EContinue;

			}

		case EAlt:

			{

			Step next(iSub1, aPos, aStepId);

			if (step.iStep == 1)

				next.iRule = iSub2;

			step.iStep++;

			aStack.push_back(next);

			return EContinue;

			}

		}

	return EFail;

	}

int Parser::Id() const

	{

	return iId;

	}

void Parser::SetId(int aId)

	{

	iId = aId;

	}

Parser operator|(const Parser& aFirst, const Parser& aRest)

	{

	return Parser(Parser::EAlt, aFirst, aRest);

	}

Parser operator>>(const Parser& aFirst, const Parser& aRest)

	{

	return Parser(Parser::ESeq, aFirst, aRest);

	}

/*Parser operator*(const Parser& aSub)

	{

	return Parser(Parser::EMult, aSub);

	}

*/

void DoPrint(const ParseResult& res)

	{

	cout << res.iRuleId << " " << res.iStart << "..." << res.iEnd << " ";

	if (res.iChildren.size())

		{

		cout << "{ ";

		for (unsigned int i=0; i<res.iChildren.size(); i++)

			DoPrint(res.iChildren[i]);

		cout << "} ";

		}

	}

void Print(const ParseResult& res)

	{

	DoPrint(res);

	cout << endl;

	}

int TestParser()

	{

	Parser p = Parser("A");

	ParseResult res;

	res = p.Parse("A");	Print(res);

	res = p.Parse("B");	Print(res);

	p = Parser("A") | Parser("B");

	res = p.Parse("A");	Print(res);

	res = p.Parse("B");	Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("C");	Print(res);

	p = Parser("A") | Parser("B") | Parser("C");

	res = p.Parse("A");	Print(res);

	res = p.Parse("B");	Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("C");	Print(res);

	res = p.Parse("D");	Print(res);

	p = Parser("A") >> Parser("B");

	res = p.Parse("A");	Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("BA"); Print(res);

	res = p.Parse("C"); Print(res);

	p = Parser("A") >> Parser("B") >> Parser("C");

	res = p.Parse("A");	Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("ABC"); Print(res);

	res = p.Parse("ABCD"); Print(res);

	res = p.Parse("BAC"); Print(res);

	res = p.Parse("D"); Print(res);

	p = Parser("A") >> Parser("B") >> Parser("A") >> Parser::EOS();

	res = p.Parse("A"); Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("BA"); Print(res);

	res = p.Parse("ABA"); Print(res);

	res = p.Parse("ABAB"); Print(res);

	res = p.Parse("C"); Print(res);

	p = (Parser("A") | Parser("B")) >> Parser("C");

	res = p.Parse("A");	Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AC"); Print(res);

	res = p.Parse("BC"); Print(res);

	res = p.Parse("BA"); Print(res);

	res = p.Parse("C"); Print(res);

	res = p.Parse("CC"); Print(res);

	p = Parser("A") >> (Parser("B") | Parser("BB")) >> Parser::EOS();

	res = p.Parse("A"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("ABB"); Print(res);

	res = p.Parse("ABBB"); Print(res);

	p = Parser("A") >> (Parser("B") | Parser("C")) >> (Parser("D") | Parser("E")) >> Parser::EOS();

	res = p.Parse("A"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("AC"); Print(res);

	res = p.Parse("AD"); Print(res);

	res = p.Parse("AE"); Print(res);

	res = p.Parse("ABD"); Print(res);

	res = p.Parse("ABE"); Print(res);

	res = p.Parse("ACD"); Print(res);

	res = p.Parse("ACE"); Print(res);

	res = p.Parse("ADB"); Print(res);

	res = p.Parse("AEB"); Print(res);

	res = p.Parse("ADC"); Print(res);

	res = p.Parse("AEC"); Print(res);

	res = p.Parse("ABDB"); Print(res);

	res = p.Parse("ABEC"); Print(res);

	res = p.Parse("ACDE"); Print(res);

	res = p.Parse("ACEE"); Print(res);

	p = Parser("A") | Parser("B");

	Parser q = p >> p;

	cout << p.Id() << endl;

	cout << q.Id() << endl;

	res = q.Parse("A"); Print(res);

	res = q.Parse("B"); Print(res);

	res = q.Parse("AA"); Print(res);

	res = q.Parse("AB"); Print(res);

	res = q.Parse("BA"); Print(res);

	res = q.Parse("BB"); Print(res);

	res = q.Parse("AC"); Print(res);

	res = q.Parse("CA"); Print(res);

	q = Parser("A") >> p;

	p = q | Parser::Nul();

	res = p.Parse("A"); Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AA"); Print(res);

	res = p.Parse(""); Print(res);

	Parser r = Parser::Nul();

	q = Parser("A") >> r;

	r = q | Parser::Nul();

	p = r >> Parser::EOS();

	res = p.Parse("A"); Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AA"); Print(res);

	res = p.Parse("AAB"); Print(res);

	res = p.Parse(""); Print(res);

	p = Parser("B") >> r >> Parser("B");

	res = p.Parse("B"); Print(res);

	res = p.Parse("BB"); Print(res);

	res = p.Parse("BAB"); Print(res);

	res = p.Parse("BAAB"); Print(res);

	res = p.Parse("BAAAB"); Print(res);

	p = r >> Parser("AAB");

	res = p.Parse("B"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("AAB"); Print(res);

	res = p.Parse("AAAB"); Print(res);

	res = p.Parse("AAAAB"); Print(res);

	p = Parser::Int();

	res = p.Parse("1"); Print(res);

	res = p.Parse("a"); Print(res);

	res = p.Parse("123"); Print(res);

	res = p.Parse("123ab"); Print(res);

	res = p.Parse(""); Print(res);

	p = Parser::Real();

	res = p.Parse("1"); Print(res);

	res = p.Parse("1.0"); Print(res);

	res = p.Parse(".01"); Print(res);

	res = p.Parse("1e9"); Print(res);

	res = p.Parse("a"); Print(res);

	res = p.Parse("123"); Print(res);

	res = p.Parse("123ab"); Print(res);

	res = p.Parse(""); Print(res);

	// unsupported *

/*	p = *Parser("A");

	res = p.Parse("A"); Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AA"); Print(res);

	res = p.Parse(""); Print(res);

	p = *Parser("A") >> Parser::EOS();

	res = p.Parse("A"); Print(res);

	res = p.Parse("B"); Print(res);

	res = p.Parse("AA"); Print(res);

	res = p.Parse("AAB"); Print(res);

	res = p.Parse(""); Print(res);

	p = Parser("B") >> *Parser("A") >> Parser("B");

	res = p.Parse("B"); Print(res);

	res = p.Parse("BB"); Print(res);

	res = p.Parse("BAB"); Print(res);

	res = p.Parse("BAAB"); Print(res);

	res = p.Parse("BAAAB"); Print(res);

	p = *Parser("A") >> Parser("AB");

	res = p.Parse("B"); Print(res);

	res = p.Parse("AB"); Print(res);

	res = p.Parse("AAB"); Print(res);

	res = p.Parse("AAAB"); Print(res);

	res = p.Parse("AAAAB"); Print(res);

*/

	return 0;

	}

/*

Parser p = Parser("A") >> (Parser("B") | Parser("C")) >> (Parser("D") | Parser("E")) >> Parser("F");

Parser q = p | (p >> q);

int TestFormulaTreeNode()

	{

	ParseResult res;

	res = q.Parse("ACEFACEF");	Print(res);

	return 0;

	}

*/

// note, uncomment this line to execute test code

//int x = TestParser();