int FRModel::setSerialNumber(const QString &number, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_SetSerialNumber(codec->fromUnicode(number));
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = setSerialNumber(number, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка установки серийного номера."), result));
}
return result;
}
int mail_TXT_Error(game* aGame,
envelope *anEnvelope,
char* raceName,
int kind,
int resNumber,
int theTurnNumber ) {
int result = FALSE;
FILE* forecast;
char *forecastName = createString( "%s/NG_TXT_%d_errors",
tempdir, getpid( ) );
forecast = openForecast( forecastName );
if ( forecast ) {
/* OK */
}
else {
return TRUE;
}
setHeader( anEnvelope, MAILHEADER_SUBJECT, "[GNG] Major Trouble" );
plog( LBRIEF, "Major Trouble %d\n", resNumber );
generateErrorMessage( resNumber, aGame, raceName, theTurnNumber, forecast );
fclose( forecast );
result |= mailForecast( forecastName, "TXT", anEnvelope, aGame, kind );
result |= GOS_delete( forecastName );
free( forecastName );
fclose( forecast );
return result;
}
int FRModel::report()
{
int result = hw->hw()->ECR_SetMode(0);
if (!result)
{
result = hw->hw()->ECR_SetMode(3);
if (!result)
result = hw->hw()->ECR_Report(Z_REPORT);
}
result = err->analizeError(result, "report");
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = report();
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка создания z-отчета."), result));
}
return result;
}
int FRModel::setDateTime(int day, int month, int year, int hour, int minute, int second)
{
int result = hw->hw()->ECR_SetMode(0);
if (!result)
{
result = hw->hw()->ECR_SetDate(day, month, year);
if (!result)
result = hw->hw()->ECR_SetTime(hour, minute, second);
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = setDateTime(day, month, year, hour, minute, second);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка синхронизации даты и времени."), result));
}
return result;
}
int FRModel::makeFullReport(int sessionBegin, int sessionEnd, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_Report(FULL_REPORT_BY_SESSION, 0, 0, 0, 0, 0, 0, sessionBegin, sessionEnd);
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = makeFullReport(sessionBegin, sessionEnd, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка снятия полного отчета по сменам."), result));
}
return result;
}
int FRModel::makeBriefReport(int dayBegin, int monthBegin, int yearBegin, int dayEnd, int monthEnd, int yearEnd, QString password)
{
fillString(password, getPasswordLength(password));
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_Report(BRIEF_REPORT_BY_DATE, dayBegin, monthBegin, yearBegin, dayEnd, monthEnd, yearEnd);
}
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = makeBriefReport(dayBegin, monthBegin, yearBegin, dayEnd, monthEnd, yearEnd, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка снятия краткого отчета по датам."), result));
}
return result;
}
int FRModel::fiscalization(QString registrationNumber, QString INN, QString newPassword, QString password)
{
fillString(password, getPasswordLength(password));
fillString(newPassword, getPasswordLength(password));
fillString(registrationNumber, getRegistrationNumberLength());
fillString(INN, getINNNumberLength());
int result = hw->hw()->ECR_SetMode(0);
if (result == 0 || result == 157)
{
result = hw->hw()->ECR_SetMode(5, codec->fromUnicode(password));
if (!result)
result = hw->hw()->ECR_Fiscalization(codec->fromUnicode(registrationNumber), codec->fromUnicode(INN), codec->fromUnicode(newPassword));
}
result = err->analizeError(result, "fiscalization");
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = fiscalization(registrationNumber, INN, newPassword, password);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка фискализации."), result));
}
return result;
}
int FRModel::setLicence(const QString &license)
{
int result = hw->hw()->ECR_SetMode(0);
if (!result)
hw->hw()->ECR_SetLicense(4, codec->fromUnicode(license));
result = err->analizeError(result);
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = setLicence(license);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка установки лицензии."), result));
}
return result;
}
int FRModel::testSale(double price)
{
int result = hw->hw()->ECR_SetMode(0);
if (!result)
{
result = hw->hw()->ECR_SetMode(1);
if (!result)
{
result = hw->hw()->ECR_OpenCheck(0);
if (!result)
{
result = hw->hw()->ECR_Registration(price, 1, "");
if (!result)
result = hw->hw()->ECR_CloseCheck(price);
}
}
}
result = err->analizeError(result, "check");
switch (result)
{
case 0:
updateInformation();
break;
case 1:
waitForRelease();
result = testSale(price);
break;
default:
emit signalFail(generateErrorMessage(conv("Ошибка печати чека."), result));
}
return result;
}
int CMD_check( int argc, char **argv, int kind ) {
int result;
char *logName;
envelope *anEnvelope;
char* forecastName;
char* returnAddress;
char* raceName;
char* password;
char* final_orders;
game* aGame;
FILE* forecast;
player* aPlayer;
int resNumber, theTurnNumber;
result = FALSE;
logName = createString( "%s/log/orders_processed.txt", galaxynghome );
openLog( logName, "a" );
free( logName );
plogtime( LBRIEF );
if ( argc >= 2 ) {
anEnvelope = createEnvelope( );
returnAddress = getReturnAddress( stdin );
raceName = NULL;
password = NULL;
final_orders = NULL;
aGame = NULL;
resNumber = areValidOrders( stdin, &aGame, &raceName,
&password, &final_orders, &theTurnNumber );
plog( LBRIEF, "game %s\n", aGame->name );
setHeader(anEnvelope, MAILHEADER_FROM, "%s", aGame->serverOptions.SERVERemail);
setHeader( anEnvelope, MAILHEADER_TO, "%s", returnAddress );
setHeader(anEnvelope, MAILHEADER_REPLYTO, aGame->serverOptions.ReplyTo);
anEnvelope->from_name = strdup(aGame->serverOptions.SERVERname);
anEnvelope->from_address = strdup(aGame->serverOptions.SERVERemail);
if ( resNumber == RES_OK) {
aPlayer = findElement( player, aGame->players, raceName );
aPlayer->orders = NULL;
plog( LBRIEF, "Orders from %s\n", returnAddress );
/* produce an XML forecast */
if ( aPlayer->flags & F_XMLREPORT ) {
if ( ( theTurnNumber == LG_CURRENT_TURN ) ||
( theTurnNumber == ( aGame->turn ) + 1 ) ) {
forecastName = createString( "%s/NG_XML_%d_forecast",
tempdir, getpid( ) );
copyOrders( aGame, stdin, raceName, password, final_orders,
aGame->turn + 1 );
if ( ( forecast =
GOS_fopen( forecastName, "w" ) ) == NULL ) {
plog( LBRIEF, "Could not open %s for forecasting\n",
forecastName );
fprintf( stderr,
"Could not open %s for forecasting\n",
forecastName );
return EXIT_FAILURE;
}
if (final_orders)
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] %s turn %d XML finalorders forecast for %s",
aGame->name, ( aGame->turn ) + 1, raceName );
else
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] %s turn %d XML forecast for %s",
aGame->name, ( aGame->turn ) + 1, raceName );
checkOrders( aGame, raceName, forecast, F_XMLREPORT );
fclose( forecast );
if ( kind == CMD_CHECK_REAL ) {
plog( LBRIEF, "mailing XML report %s to %s\n",
forecastName, anEnvelope->to );
fprintf( stderr, "mailing XML report %s to %s\n",
forecastName, anEnvelope->to );
result |= eMail( aGame, anEnvelope, forecastName );
} else {
char *forecastFile;
forecastFile =
createString( "%s/forecasts/%s/%s_XML",
galaxynghome, argv[2],
returnAddress );
GOS_copy( forecastName, forecastFile );
}
result |= GOS_delete( forecastName );
free( forecastName );
}
}
/* produce a text forecast */
if ( aPlayer->flags & F_TXTREPORT ) {
if ( ( theTurnNumber == LG_CURRENT_TURN ) ||
( theTurnNumber == ( aGame->turn ) + 1 ) ) {
forecastName = createString( "%s/NG_TXT_%d_forecast",
tempdir, getpid( ) );
if ( ( forecast =
GOS_fopen( forecastName, "w" ) ) == NULL ) {
plog( LBRIEF, "Could not open %s for forecasting\n",
forecastName );
return EXIT_FAILURE;
}
if ( aPlayer->orders == NULL )
copyOrders( aGame, stdin, raceName, password, final_orders,
aGame->turn + 1 );
if (final_orders)
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] %s turn %d text finalorders forecast for %s",
aGame->name, ( aGame->turn ) + 1, raceName );
else
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] %s turn %d text forecast for %s",
aGame->name, ( aGame->turn ) + 1, raceName );
checkOrders( aGame, raceName, forecast, F_TXTREPORT );
fclose( forecast );
if ( kind == CMD_CHECK_REAL ) {
plog( LBRIEF, "mailing TXT report %s to %s\n",
forecastName, anEnvelope->to );
fprintf( stderr, "mailing TXT report %s to %s\n",
forecastName, anEnvelope->to );
result |= eMail( aGame, anEnvelope, forecastName );
} else {
char *forecastFile;
forecastFile =
createString( "%s/forecasts/%s/%s_TXT",
galaxynghome, argv[2],
returnAddress );
GOS_copy( forecastName, forecastFile );
}
result |= GOS_delete( forecastName );
free( forecastName );
}
}
} else {
forecastName = createString( "%s/NG_TXT_%d_errors",
tempdir, getpid( ) );
forecast = GOS_fopen( forecastName, "w" );
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] Major Trouble" );
plog( LBRIEF, "Major Trouble %d\n", resNumber );
generateErrorMessage( resNumber, aGame, raceName,
theTurnNumber, forecast );
fclose( forecast );
if ( kind == CMD_CHECK_REAL ) {
plog( LBRIEF, "mailing error report %s to %s\n", forecastName,
anEnvelope->to );
result |= eMail( aGame, anEnvelope, forecastName );
} else {
char *forecastFile;
forecastFile =
createString( "%s/forecasts/%s/%s_ERR",
galaxynghome, argv[2], returnAddress );
GOS_copy( forecastName, forecastFile );
}
result |= GOS_delete( forecastName );
free( forecastName );
}
/* code here for advanced orders, we need to see how to determine this */
if ( theTurnNumber > (aGame->turn+1)) {
if ( aPlayer->orders == NULL )
copyOrders( aGame, stdin, raceName, password, final_orders,
theTurnNumber );
if (final_orders) {
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] %s turn %d advance finalorders received for %s.",
aGame->name, theTurnNumber, raceName );
plog( LBRIEF, "%s turn %d advance finalorders received for %s.\n",
aGame->name, theTurnNumber, raceName );
}
else {
setHeader( anEnvelope, MAILHEADER_SUBJECT,
"[GNG] %s turn %d advance orders received for %s.",
aGame->name, theTurnNumber, raceName );
plog( LBRIEF, "%s turn %d advance orders received for %s.\n",
aGame->name, theTurnNumber, raceName );
}
if ( aPlayer->flags & F_XMLREPORT ) {
forecastName = createString( "%s/NG_XML_forecast", tempdir );
forecast = GOS_fopen( forecastName, "w" );
fprintf( forecast,
"<galaxy>\n <variant>GalaxyNG</variant>\n" );
fprintf( forecast, " <version>%d.%d.%d</version>\n",
GNG_MAJOR, GNG_MINOR, GNG_RELEASE );
fprintf( forecast, " <game name=\"%s\">\n", aGame->name );
fprintf( forecast, " <turn num=\"%d\">\n", theTurnNumber );
fprintf( forecast, " <race name=\"%s\">\n", raceName );
fprintf( forecast, " <message>\n" );
fprintf( forecast, " <line num=\"1\">"
"O wise leader, your orders for turn %d</line>",
theTurnNumber );
fprintf( forecast, " <line num=\"2\">"
"have been received and stored.</line>" );
fprintf( forecast, " </message>\n" );
fprintf( forecast, " </race>\n" );
fprintf( forecast, " </turn>\n" );
fprintf( forecast, " </game>\n" );
fprintf( forecast, "</galaxy>\n" );
fclose( forecast );
if ( kind == CMD_CHECK_REAL ) {
result |= eMail( aGame, anEnvelope, forecastName );
} else {
char *forecastFile;
forecastFile =
createString( "%s/forecasts/%s/%s_XML",
galaxynghome, argv[2], returnAddress );
GOS_copy( forecastName, forecastFile );
}
result |= GOS_delete( forecastName );
free( forecastName );
}
if ( aPlayer->flags & F_TXTREPORT ) {
if ( aPlayer->orders == NULL )
copyOrders( aGame, stdin, raceName, password, final_orders,
theTurnNumber );
forecastName = createString( "%s/NG_TXT_forecast", tempdir );
forecast = GOS_fopen( forecastName, "w" );
fprintf( forecast, "O wise leader your orders for turn %d "
"have been received and stored.\n", theTurnNumber );
fclose( forecast );
if ( kind == CMD_CHECK_REAL ) {
result |= eMail( aGame, anEnvelope, forecastName );
} else {
char *forecastFile;
forecastFile =
createString( "%s/forecasts/%s/%s_TXT",
galaxynghome, argv[2], returnAddress );
GOS_copy( forecastName, forecastFile );
}
result |= GOS_delete( forecastName );
free( forecastName );
}
}
}
if ( raceName )
free( raceName );
if ( password )
free( password );
destroyEnvelope( anEnvelope );
result = ( result ) ? EXIT_FAILURE : EXIT_SUCCESS;
return result;
}
void bluetoothProcessReply(SoftwareSerial* bluetoothSerial, char *inputString)
{
char encryptedPassword[2 * PASSWORD_SIZE]; //make them more local
char shortEncryptedPassword[PASSWORD_SIZE];
char password[PASSWORD_SIZE];
char message[MESSAGE_SIZE];
memset(encryptedPassword, 0, 2 * PASSWORD_SIZE);
memset(shortEncryptedPassword, 0, PASSWORD_SIZE);
memset(password, 0, PASSWORD_SIZE);
memset(message, 0, MESSAGE_SIZE);
int typeCommand = getTypeCommand(inputString);
switch (typeCommand)
{
case '0' + 1:
{ // add new entry
getLastMessage(inputString, password);
if (encryptPassword((const unsigned char*)password, (const unsigned char*)key, PASSWORD_CHUNCKS, (unsigned char*)encryptedPassword)) {
generateBluetoothAddMessage(inputString, encryptedPassword, strlen(password), message);
setMessageReceiver(Phone);
storeInDataBuffer(message);
memset(message, '\0', MESSAGE_SIZE);
generateStoredInBuffer(message);
sendToBluetooth(bluetoothSerial, message);
}
else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
case '0' + 2: //retrive password
case '0' + 13: //retrive note
{
getLastMessage(inputString, encryptedPassword);
generateShortPassword(encryptedPassword, shortEncryptedPassword);
byte l = getPasswordLength(inputString);
if (decryptPassword((unsigned char*)shortEncryptedPassword, (unsigned char*)key, PASSWORD_CHUNCKS, l, (unsigned char*)password)) {
generateSerialRetriveInfo(password, message);
setMessageReceiver(Pc);
storeInDataBuffer(message);
}
else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
case '0' + 5:
{ // get from message and store the hash value and close connection
char hash[HASH_SIZE]; //input = "5:hash_value\n
memset(hash, '\0', HASH_SIZE);
getLastMessage(inputString, hash);
writeHash(hash);
}
break;
case '0' + 6:
{ //read hash from EERPOM and send back to bluetooth
char hash[HASH_SIZE]; //input = 6:\n
memset(hash, '\0', HASH_SIZE);
readHash(hash);
generateBluetoothRetrieveHash(hash, HASH_SIZE, message); //message = 6:hash_value\n
storeInDataBuffer(message);
setMessageReceiver(Phone);
setEnableBluetoothOperations(true);
}
break;
case '0' + 4:
{
char lastTimeUsed[LAST_TIME_USED_SIZE];
memset(lastTimeUsed, '\0', LAST_TIME_USED_SIZE);
readLastTimeUsed(lastTimeUsed);
generateBluetoothLastTimeUsed(lastTimeUsed, LAST_TIME_USED_SIZE, message);
//Serial.print(message);
sendToBluetooth(bluetoothSerial, message);
}
break;
case '0' + 10:
{
char lastTimeUsed[LAST_TIME_USED_SIZE];
memset(lastTimeUsed, '\0', LAST_TIME_USED_SIZE);
getLastMessage(inputString, lastTimeUsed);
writeLastTimeUsed(lastTimeUsed);
}
break;
case '0' + 7:
{ // generate password
if ((generatePassword(inputString, password, PASSWORD_CHUNCKS)) &&
(encryptPassword((const unsigned char*)password, (const unsigned char*)key, PASSWORD_CHUNCKS, (unsigned char*)encryptedPassword))) {
generateBluetoothAddMessage(inputString, encryptedPassword, strlen(password), message);
setMessageReceiver(Phone);
storeInDataBuffer(message);
memset(message, '\0', MESSAGE_SIZE);
generateStoredInBuffer(message);
sendToBluetooth(bluetoothSerial, message);
} else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
case '0' + 8:
{ // get the salt
char salt[SALT_SIZE];
memset(salt, '\0', SALT_SIZE);
getLastMessage(inputString, salt);
readKey(key, KEY_SIZE, salt);
}
break;
case '0' + 9:
{ // is alive message
generateIsAliveMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
break;
case '0' + 12:
{ //add note
getLastMessage(inputString, password);//password = note text
if (encryptPassword((const unsigned char*)password, (const unsigned char*)key, PASSWORD_CHUNCKS, (unsigned char*)encryptedPassword)) {
generateBluetoothAddNote(inputString, encryptedPassword, strlen(password), message);
setMessageReceiver(Phone);
storeInDataBuffer(message);
generateStoredInBuffer(message);
sendToBluetooth(bluetoothSerial, message);
}
else {
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
}
break;
default:
{
generateErrorMessage(message);
sendToBluetooth(bluetoothSerial, message);
}
break;
}
}
Token Tokenizer::getNextToken()
{
Token result;
if (position == LEN)
{
result.type = Token::TOKEN_TYPE::FINISHED;
result.stringRepresentation = "EOL";
return result;
}
do
{
//skip over whitespace characters
while (position < LEN && std::isspace(CUR))
position++;
//skip comments
if (CUR == '/')
{
if (NEXT == '*')
{
position+=2;
do
{
while (CUR != '*')
position++;
position++;
} while (CUR != '/');
position++;
}
else if (NEXT == '/')
{
position += 2;
while (CUR != '\n' && CUR != '\r')//new line
position++;
}
}
//skip over whitespace characters after comments
while (position < LEN && std::isspace(CUR))
position++;
} while (CUR == '/' && (NEXT == '/' || NEXT == '*'));
//end of file
if (position == LEN )
{
result.type = Token::TOKEN_TYPE::FINISHED;
result.stringRepresentation = "";
return result;
}
//operators
std::vector<string> operators{ "+", "-", "*", "/", "%", "++", "--", "==",
"!=", ">", "<", ">=", "<=", "&&", "||", "!",
"&", "|", "^", "~", "<<", ">>", "=", "+=",
"-=", "*=", "/=", "%=", ">>=", "<<=", "&=",
"^=", "|=", };//using initializer lists
int ind = 0;
string op = "";
//while there is a longer operator keep going
do
{
op += CUR;
position++;
} while ((std::find(operators.begin(), operators.end(), op) != operators.end()));
op.pop_back();//remove last character
position--;
if (op.length() > 0)
{
result.type = Token::TOKEN_TYPE::OPERATOR;
result.stringRepresentation = op;
return result;
}
//delimiters
if (std::strchr("(),;{}[].:", CUR))
{
result.type = Token::TOKEN_TYPE::DELIMITER;
result.stringRepresentation = "";
result.stringRepresentation += CUR;
position++;
return result;
}
string ligit_escape = "0abfnrtv\\\"?";
//string literal
if (CUR == '"')
{
string s = "";
position++;
bool escaped = false;
while (CUR != '"' || escaped)
{
if (CUR == '\n' || CUR == '\r')
{
result.type = Token::TOKEN_TYPE::ERROR;
result.stringRepresentation = generateErrorMessage("New line in string literal");
return result;
}
if (escaped && std::strchr(ligit_escape.c_str(), CUR)==nullptr)
{
result.type = Token::TOKEN_TYPE::ERROR;
result.stringRepresentation = generateErrorMessage("Illegal escape character");
return result;
}
s += CUR;
if (CUR == '\\')
escaped = true;
else
escaped = false;
position++;
}
position++;
result.type = Token::TOKEN_TYPE::STRING_LITERAL;
result.stringRepresentation = s;
return result;
}
//char literal
if (CUR == '\'')
{
position++;
if (CUR == '\\')
{
position++;
}
if (NEXT == '\'')
{
if (CUR == '\n' || CUR == '\r')
{
result.type = Token::TOKEN_TYPE::ERROR;
result.stringRepresentation = generateErrorMessage("New line in character literal");
return result;
}
else
{
result.type = Token::TOKEN_TYPE::CHAR_LITERAL;
result.stringRepresentation = "";
result.stringRepresentation += CUR;
return result;
position += 2;
}
}
else
{
result.type = Token::TOKEN_TYPE::ERROR;
result.stringRepresentation = generateErrorMessage("Character literal too long");
return result;
}
}
//number literal
if (std::isdigit(CUR))
{
string n;
n += CUR;
position++;
while (std::isdigit(CUR))
{
n += CUR;
position++;
}
result.type = Token::TOKEN_TYPE::NUMBER_LITERAL;
result.stringRepresentation = n;
return result;
}
//keywords and identifiers
string word = "";
if (std::isalpha(CUR) || CUR == '_')
{
while (!isdelim(CUR))
{
word += CUR;
position++;
}
}
std::vector<string> keywords{ "auto", "break", "case", "char", "const", "continue", "default",
"do", "double", "else", "enum", "extern", "float", "for", "goto",
"if", "int", "long", "register", "return", "short", "signed", "sizeof",
"static", "struct", "switch", "typedef", "union", "unsigned", "void",
"volatile", "while" };
if (word.length() > 0)
{
if ((std::find(keywords.begin(), keywords.end(), word) != keywords.end()))//its a keyword
{
result.type = Token::TOKEN_TYPE::KEYWORD;
result.stringRepresentation = word;
return result;
}
else
{
result.type = Token::TOKEN_TYPE::IDENTIFIER;
result.stringRepresentation = word;
return result;
}
}
result.type = Token::TOKEN_TYPE::ERROR;
result.stringRepresentation = generateErrorMessage("Unexpected character");
return result;
}
