/*

* Copyright (c) 2002 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 "LayoutParse.h"

#include <sstream>

#include <fstream>

#include <algorithm>

#include <iostream> // !!! for debug output only

extern string whiteSpace;

void SkipWhitespace(istream& aIn)

	{

	char ch;

	while (!aIn.eof())

		{

		ch = aIn.get();

		if (whiteSpace.find(ch) == string::npos)

			{

			aIn.putback(ch);

			break;

			}

		}

	}

void TrimEnd(string& aString)

	{

	int len = aString.length();

	while (whiteSpace.find(aString[len-1]) != string::npos)

		len--;

	aString = aString.substr(0, len);

	}

string NextToken(istream& aIn, const string& aTerminate)

	{

	SkipWhitespace(aIn);

	string ret;

	char ch;

	while (!aIn.eof())

		{

		ch = aIn.get();

		if (aTerminate.find(ch) != string::npos)

			{

			if (ret.length())

				aIn.putback(ch);

			else

				ret += (ch);

			break;

			}

		ret += ch;

		}

	TrimEnd(ret);

	return ret;

	}

void FindAndSkip(istream& aIn, const string& aString)

	{

	string tok = NextToken(aIn, aString);

	if (aString.find(tok) == string::npos)

		throw LayParseErr(aIn, tok, "not found");

	}

TLayParseValues::TLayParseValues(TLayoutLine* aLine, string aName)

: TValues(aLine, aName)

	{

	}

void TLayParseValues::Parse(istream& aIn)

	{

	string tok = NextToken(aIn, ",{}");

	if (tok == "," || tok == "}")

		{

		aIn.putback(tok[0]);

		push_back("");

		}

	else if (tok == "{")

		{

		do	{

			TLayParseValues v(iLine, iName);

			v.Parse(aIn);

			insert(end(), v.begin(), v.end());

			tok = NextToken(aIn, ",}");

			} while (tok != "}");

		tok = NextToken(aIn, ",}[");

		if (tok == "[")

			{

			tok = NextToken(aIn, "]");

			if (tok != "]")

				{

				iParam = tok;

				FindAndSkip(aIn, "]");

				}

			}

		else if (tok == "," || tok == "}")

			{

			aIn.putback(tok[0]);

			}

		else

			{

			throw LayParseErr(aIn, tok, "expected '[' ',' or '}'");

			}

		}

	else

		{

		push_back(tok);

		}

	}

//

//  TLayParseLayoutLine

//

TLayParseLayoutLine::TLayParseLayoutLine(TLayoutTable* aTable, int aId)

: TLayoutLine(aTable, aId)

	{

	}

void TLayParseLayoutLine::Parse(istream& aIn)

	{

	FindAndSkip(aIn, "{");

	string tok;

	for (vector<string>::iterator pCol = iTable->iColumnNames.begin();

		 pCol != iTable->iColumnNames.end();

		 ++pCol)

		{

		TLayParseValues values(this, *pCol);

		values.Parse(aIn);

		insert(make_pair(*pCol, values));

		tok = NextToken(aIn, ",}");

		}

	if (tok != "}")

		throw LayParseErr(aIn, tok, "expected }");

	}

// TLayParseLayoutTable

TLayParseLayoutTable::TLayParseLayoutTable(TLayout* aTables)

: TLayoutTable(aTables)

	{

	}

void TLayParseLayoutTable::Parse(istream& aIn)

	{

	string tok = NextToken(aIn, ":{}");

	if (string(":{}").find(tok) != string::npos)

		throw LayParseErr(aIn, tok, "expected table name");

	iName = tok;

	tok = NextToken(aIn, ":{");

	if (string(":{").find(tok) == string::npos)

		throw LayParseErr(aIn, tok, "expected ':' or '{'");

	if (tok == ":")

		{

		iParentName = NextToken(aIn, "{");

		FindAndSkip(aIn, "{");

		}

	tok = NextToken(aIn, "{+");

	if (string("{+").find(tok) == string::npos)

		throw LayParseErr(aIn, tok, "expected '+' or '{'");

	else if (tok == "+")

		iAppend = true;

	else

		aIn.putback(tok[0]);

	int id = 0;

	do  {

		TLayParseLayoutLine* line = new TLayParseLayoutLine(this, ++id);

		push_back(line);

		line->Parse(aIn);

		tok = NextToken(aIn, ",}");

		if (string(",}").find(tok) == string::npos)

			throw LayParseErr(aIn, tok, "expected ',' or '}'");

		} while (tok != "}");

	}

void TLayParseLayout::Parse(istream& aIn)

	{

	while (!aIn.eof())

		{

		string tok = NextToken(aIn, whiteSpace);

		if (tok == "WindowTable" || tok == "TextTable")

			{

			TLayParseLayoutTable* tab = new TLayParseLayoutTable(this);

			push_back(tab);

			tab->iType = (tok == "WindowTable" ? TLayoutTable::EWindowTable : TLayoutTable::ETextTable);

			tab->SetDefaultColumnNames();

			tab->Parse(aIn);

			}

		else if (tok.length()==0 && aIn.eof())

			{

			// white space at end of file

			break;

			}

		else

			{

			throw LayParseErr(aIn, tok, "expected a Table");

			}

		}

	Compile();

	}

auto_ptr<TLayParseLayout> TLayParseLayout::Parse(const string& aLayName)

	{

	string layName = aLayName;

	auto_ptr<TLayParseLayout> layout(new TLayParseLayout);

	if (layName.size() >= 2 && layName.substr(0,2) == "-m")

		{

		layName = layName.substr(2);

		layout->iCanBeMirror = true;

		}

	layout->iName = layName;

	string::size_type pos=0;

	bool first = true;

	while (pos != string::npos)

		{

		string::size_type next = layName.find('+', pos);

		string name;

		if (next == string::npos)

			{

			name = layName.substr(pos);

			pos = next;

			}

		else

			{

			name = layName.substr(pos, next-pos);

			pos = layName.find_first_not_of('+', next);

			}

		ifstream in(name.c_str());

		if (!in.is_open())

			throw NotFoundErr(name);

		cout << "reading layout " << name << endl;

		if (first)

			{

			layout->Parse(in);

			}

		else

			{

			TLayParseLayout nextLay;

			nextLay.Parse(in);

			layout->Merge(TLayout::KMergeModeUnion, nextLay);

			}

		first = false;

		in.close();

		}

	return layout;

	}

LayParseErr::LayParseErr(istream& aIn, const string& aTok, const string& aMsg)

: iLoc(StreamLoc(aIn,"<<Near Here>>", 100, 100)), iTok(aTok), iMsg(aMsg) 

	{

	}

void LayParseErr::Show(ostream& aOut) const

	{

	aOut << "ERROR : \"" << iTok << "\" " << iMsg << endl << iLoc << endl;

	}

// End of File