--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/sbsv2/raptor/test/smoke_suite/test_resources/tools2/pdrtran/src/LEXICAL.CPP	Fri Jan 22 16:42:55 2010 +0000
@@ -0,0 +1,311 @@
+/*
+* 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;
+	}