/*

* Copyright (c) 1997-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: 

* Header LEXICAL.CPP

*

*/

#include "LEXICAL.H"

Lexical::Lexical()

 :	iType(ELexNL), iNumber(0)

	{

	iText[0] = '\0';

	}

Lexical::Lexical(const Lexical& aLex)

	{

	iType = aLex.iType;

	iNumber = aLex.iNumber;

	strcpy(iText, aLex.iText);

	}

Lexical& Lexical::operator = (const Lexical& aLex)

	{

	iType = aLex.iType;

	iNumber = aLex.iNumber;

	strcpy(iText, aLex.iText);

	return *this;

	}

int Lexical::CovertStringToHex()

	{

	char* curPtr = iText; // Position of current lexical in line

	int hexDigit;

	int number = 0;

	while (HexDigit(*curPtr, hexDigit))

		{

		number = (16 * number) + hexDigit;

		curPtr++;

		}

	return number;

	}

int Lexical::HexDigit(char aDigit, int& decimalEquivalent)

	{

	boolean validDigit = efalse;

	if ((aDigit >= '0') && (aDigit <= '9'))

		{

		decimalEquivalent = (aDigit - '0');

		validDigit = etrue;

		}

	else if ((aDigit >= 'a') && (aDigit <= 'f'))

		{

		decimalEquivalent = 10 + (aDigit - 'a');

		validDigit = etrue;

		}

	else if ((aDigit >= 'A') && (aDigit <= 'F'))

		{

		decimalEquivalent = 10 + (aDigit - 'A');

		validDigit = etrue;

		}

	return validDigit;

	}

ostream& operator << (ostream& out, const Lexical& aLex)

	{

	switch (aLex.iType)

		{

		case ELexEOF:

			{

			out << "EOF";

			break;

			}

		case ELexNL:

			{

			out << "NL";

			break;

			}

		case ELexNumber:

			{

			out << aLex.iNumber;

			break;

			}

		case ELexOperator:

			{

			out << aLex.iText[0];

			break;

			}

		default:

			{

			out << aLex.iText;

			}

		}	 

	return out;

	}

LexAnal::LexAnal(const char* aFilename)

 :	iFilename(aFilename)

	{

	iFin.open(aFilename);

	iLex.iType = ELexNL;

	iLineNo = 0;

	}

Lexical LexAnal::Read() // read next lexical into iLex

	{

	if (iLex.iType == ELexNL)

		{

		do

			{

			GetNextLex();

			}

		while (iLex.iType == ELexNL);

		}

	else

		GetNextLex();

	return iLex;

	}

Lexical LexAnal::ReadNextLine() // read first lex on next line

	{

	GetNextLine();

	return iLex;

	}

void LexAnal::Report()

	{

	cerr << iFilename.Text() << '(' << iLineNo << "): \n";

	cerr << iLine << '\n';

	for	(char* p = iLine; p < iLexPtr; p++)

		cerr << ' ';

	cerr << "^\n";

	}

LexAnal::~LexAnal()

	{

	iFin.close();

	}

void LexAnal::GetNextLex()

	{

	char ch;

	if (iLex.iType == ELexNL)

		{

		iFin.getline(iLine, MaxLineLen);

		// Remove any CR character that appear at the end when

		// reading a dos file on unix.

		PurgeLastCR(iLine);

		iCurPtr = iLine;

		iLineNo++;

		}

	while ((*iCurPtr == ' ') || (*iCurPtr == '\t'))

		iCurPtr++;

	ch = *iCurPtr;

	iLexPtr = iCurPtr;

	if ((ch == '\0') && (iFin.eof()))	// finds lexical type

		iLex = ReadEOF();

	else if ((ch == '\0') || (ch == '!'))	// ! is a comment

		iLex = ReadNewLine();

	else if ((ch == '-') || ((ch >= '0') && (ch <= '9')))

		iLex = ReadNumber();

	else if (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || (ch == '_'))

		iLex = ReadIdent();

	else if	(ch == '"')

		iLex = ReadString();

	else

		iLex = ReadOperator();	

	}

void LexAnal::GetNextLine()

	{

	iFin.getline(iLine, MaxLineLen);

	// Remove any CR character that appear at the end when

	// reading a dos file on unix.

	PurgeLastCR(iLine);

	iCurPtr = iLine;

	iLineNo++;

	char ch;

	while ((*iCurPtr == ' ') || (*iCurPtr == '\t'))

		iCurPtr++;

	ch = *iCurPtr;

	iLexPtr = iCurPtr;

	if ((ch == '\0') && (iFin.eof()))	// finds lexical type

		iLex = ReadEOF();

	else if ((ch == '\0') || (ch == '!'))

		iLex = ReadNewLine();

	else if ((ch == '-') || ((ch >= '0') && (ch <= '9')))

		iLex=ReadNumber();

	else if (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || (ch == '_'))

		iLex = ReadIdent();

	else if	(ch == '"')

		iLex = ReadString();

	else

		iLex = ReadOperator();	

	}

void LexAnal::PurgeLastCR(char *aLine)

	{

	int len = strlen(aLine) - 1;

	if (len >= 0 && aLine[len] == '\r')

		{

		aLine[len] = '\0';

		}

	}

Lexical LexAnal::ReadEOF()

	{

	Lexical lex;

	lex.iType = ELexEOF;

	return lex;

	}

Lexical LexAnal::ReadNewLine()

	{

	Lexical lex;

	lex.iType = ELexNL;

	while (*iCurPtr != '\0')

		iCurPtr++;

	return lex;

	}

Lexical LexAnal::ReadNumber()

	{

	Lexical lex;

	char ch;

	boolean negative = efalse;

	lex.iType = ELexNumber;

	if (*iCurPtr == '-')

		{

		negative = etrue;

		iCurPtr++;

		}

	ch = *iCurPtr;

	while ((ch >= '0') && (ch <= '9'))

		{

		if (negative)

			lex.iNumber = (10 * lex.iNumber) - (*iCurPtr - '0');

		else

			lex.iNumber=(10 * lex.iNumber) + (*iCurPtr - '0');

		iCurPtr++;

		ch = *iCurPtr;

		}

	return lex;

	}

Lexical LexAnal::ReadIdent()

	{

	Lexical lex;

	char ch;

	lex.iType = ELexIdent;

	do

		{

		iCurPtr++;

		ch = *iCurPtr;

		}

	while (((ch >= 'a') && (ch <= 'z')) || ((ch >= 'A') && (ch <= 'Z')) || (ch == '_') || ((ch >= '0') && (ch <= '9')));

	strncpy(lex.iText, iLexPtr, iCurPtr - iLexPtr);

	lex.iText[iCurPtr - iLexPtr] = '\0';

	return lex;

	}

Lexical LexAnal::ReadString()

	{

	Lexical lex;

	char ch;

	lex.iType = ELexString;

	iCurPtr++;

	ch = *iCurPtr;

	while ((ch != '"') && (*iCurPtr != '\0'))

		{

		iCurPtr++;

		ch = *iCurPtr;

		}

	strncpy(lex.iText, iLexPtr + 1, iCurPtr - (iLexPtr + 1));

	lex.iText[iCurPtr - (iLexPtr + 1)] = '\0';

	if (ch == '"')

		iCurPtr++;	// finds position after last double quotes 

	else

		{

		cerr << "Warning: missing quotes\n";

		Report();

		}

	return lex;

	}

Lexical LexAnal::ReadOperator()

	{

	Lexical lex;

	lex.iType = ELexOperator;

	lex.iText[0] = *iCurPtr;

	iCurPtr++;

	return lex;

	}