void morse::AndThings()
{
if(Serial.available())
{
while(Serial.available())
{
_fromSerial = _fromSerial + (char)(Serial.read());
}
_Wordstring = _fromSerial;
Serial.print("You wrote: ");
Serial.println(_fromSerial);
_fromSerial = "";
}
CheckLetters(_Wordstring);
}
Token &
TokenFactory::
DoSymbol(unsigned char ch)
{
// Get the position of the start of the symbol
std::streampos
pos = m_sCur->tellg();
pos -= 1;
// State of symbol determination
E_STATE
state = ES__NONE;
// Current symbol type
TokenType::E_TYPE
type = TokenType::TT_SYMBOL;
do
{
switch (state)
{
case ES__NONE: // ES_NONE
switch (ch)
{
case 'A':
if (CheckLetters("rray")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Array;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'B':
if (CheckLetters("oolean")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Boolean;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'D':
if (CheckLetters("ate")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Date;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'E':
state = ES_E; // ES_E
break;
case 'F':
if (CheckLetters("unction")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Function;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'M':
if (CheckLetters("ath")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Math;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'N':
if (CheckLetters("umber")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Number;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'O':
if (CheckLetters("bject")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Object;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'R':
state = ES_R; // ES_R
break;
case 'S':
state = ES_S; // ES_S
break;
case 'T':
if (CheckLetters("ypeError")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_TypeError;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'U':
if (CheckLetters("RIError")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_URIError;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'a':
if (CheckLetters("bstract")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_abstract;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'b':
state = ES_b; // ES_b
break;
case 'c':
state = ES_c; // ES_c
break;
case 'd':
state = ES_d; // ES_d
break;
case 'e':
state = ES_e; // ES_e
break;
case 'f':
state = ES_f; // ES_f
break;
case 'g':
if (CheckLetters("oto")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_goto;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'i':
state = ES_i; // ES_i
break;
case 'l':
if (CheckLetters("ong")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_long;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'n':
state = ES_n; // ES_n
break;
case 'p':
state = ES_p; // ES_p
break;
case 'r':
if (CheckLetters("eturn")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_return;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 's':
state = ES_s; // ES_s
break;
case 't':
state = ES_t; // ES_t
break;
case 'u':
if (CheckLetters("ndefined")) // Can only be this or unknown
{
// "undefined" is not a keyword but
// is often used as one, we'll treat it
// as one but warn them of the problems
state = ES__DONE; // Mark as done
type = TokenType::TK_undefined;
Message::Send(Message::USED_UNDEFINED);
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'v':
state = ES_v; // ES_v
break;
case 'w':
state = ES_w; // ES_w
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_E: // ES_E
switch (ch)
{
case 'r':
if (CheckLetters("ror")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_Error;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'v':
if (CheckLetters("alError")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_EvalError;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_R: // ES_R
switch (ch)
{
case 'a':
if (CheckLetters("ngeError")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_RangeError;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'e':
state = ES_Re; // ES_Re
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_Re: // ES_Re
switch (ch)
{
case 'f':
if (CheckLetters("erenceError")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_ReferenceError;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'g':
if (CheckLetters("Exp")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_RegExp;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_S: // ES_S
switch (ch)
{
case 't':
if (CheckLetters("ring")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_String;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'y':
if (CheckLetters("ntaxError")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TG_SyntaxError;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_b: // ES_b
switch (ch)
{
case 'o':
if (CheckLetters("olean")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_boolean;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'r':
if (CheckLetters("eak")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_break;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'y':
if (CheckLetters("te")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_byte;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_c: // ES_c
switch (ch)
{
case 'a':
state = ES_ca; // ES_ca
break;
case 'h':
if (CheckLetters("ar")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_char;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'l':
if (CheckLetters("ass")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_class;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'o':
if (CheckLetters("n")) // All possible symbols have these symbols
{
state = ES_con; // ES_con
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_ca: // ES_ca
switch (ch)
{
case 's':
if (CheckLetters("e")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_case;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 't':
if (CheckLetters("ch")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_catch;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_con: // ES_con
switch (ch)
{
case 's':
if (CheckLetters("t")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_const;
// SOME browsers implement this (at least FF)
// but others don't (at least IE)
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 't':
if (CheckLetters("inue")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_continue;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_d: // ES_d
switch (ch)
{
case 'e':
state = ES_de; // ES_de
break;
case 'o':
state = ES_do; // ES_do
type = TokenType::TK_do;
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_de: // ES_de
switch (ch)
{
case 'b':
if (CheckLetters("ugger")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_debugger;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'f':
if (CheckLetters("ault")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_default;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'l':
if (CheckLetters("ete")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_delete;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_do: // ES_do
switch (ch)
{
case 'u':
if (CheckLetters("ble")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_double;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_e: // ES_e
switch (ch)
{
case 'l':
if (CheckLetters("se")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_else;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'n':
if (CheckLetters("um")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_enum;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'v':
if (CheckLetters("al")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_eval;
// Bad Bad Bad
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'x':
state = ES_ex; // ES_ex
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_ex: // ES_ex
switch (ch)
{
case 'p':
if (CheckLetters("ort")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_export;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 't':
if (CheckLetters("ends")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_extends;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_f: // ES_f
switch (ch)
{
case 'a':
if (CheckLetters("lse")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_false;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'i':
if (CheckLetters("nal")) // All possible symbols have these symbols
{
state = ES_final; // ES_final
type = TokenType::TR_final;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'l':
if (CheckLetters("oat")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_float;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'o':
if (CheckLetters("r")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_for;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'u':
if (CheckLetters("nction")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_function;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_final: // ES_final
switch (ch)
{
case 'l':
if (CheckLetters("y")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_finally;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_i: // ES_i
switch (ch)
{
case 'f':
state = ES__DONE; // Mark as done
type = TokenType::TK_if;
break;
case 'm':
if (CheckLetters("p")) // All possible symbols have these symbols
{
state = ES_imp; // ES_imp
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'n':
state = ES_in; // ES_in
type = TokenType::TK_in;
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_imp: // ES_imp
switch (ch)
{
case 'l':
if (CheckLetters("ements")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_implements;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'o':
if (CheckLetters("rt")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_import;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_in: // ES_in
switch (ch)
{
case 's':
if (CheckLetters("tanceof")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_instanceof;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 't':
state = ES_int; // ES_int
type = TokenType::TR_int;
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_int: // ES_int
switch (ch)
{
case 'e':
if (CheckLetters("rface")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_interface;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_n: // ES_n
switch (ch)
{
case 'a':
if (CheckLetters("tive")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_native;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'e':
if (CheckLetters("w")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_new;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'u':
if (CheckLetters("ll")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_null;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_p: // ES_p
switch (ch)
{
case 'a':
if (CheckLetters("ckage")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_package;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'r':
state = ES_pr; // ES_pr
break;
case 'u':
if (CheckLetters("blic")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_public;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_pr: // ES_pr
switch (ch)
{
case 'i':
if (CheckLetters("vate")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_private;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'o':
if (CheckLetters("tected")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_protected;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_s: // ES_s
switch (ch)
{
case 'h':
if (CheckLetters("ort")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_short;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 't':
if (CheckLetters("atic")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_static;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'u':
if (CheckLetters("per")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_super;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'w':
if (CheckLetters("itch")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_switch;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'y':
if (CheckLetters("nchronized")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_synchronized;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_t: // ES_t
switch (ch)
{
case 'h':
state = ES_th; // ES_th
break;
case 'r':
state = ES_tr; // ES_tr
break;
case 'y':
if (CheckLetters("peof")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_typeof;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_th: // ES_th
switch (ch)
{
case 'i':
if (CheckLetters("s")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
//type = TokenType::TT_THIS; // Special case, "this" keyword
//value.keyword = SymbolType::EK_this; // Only needed for the check below
type = TokenType::TK_this;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'r':
if (CheckLetters("ow")) // All possible symbols have these symbols
{
state = ES_throw; // ES_throw
type = TokenType::TK_throw;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_throw: // ES_throw
switch (ch)
{
case 's':
state = ES__DONE; // Mark as done
type = TokenType::TR_throws;
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_tr: // ES_tr
switch (ch)
{
case 'a':
if (CheckLetters("nsient")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_transient;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'u':
if (CheckLetters("e")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_true;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'y':
state = ES__DONE; // Mark as done
type = TokenType::TK_try;
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_v: // ES_v
switch (ch)
{
case 'a':
if (CheckLetters("r")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_var;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'o':
state = ES_vo; // ES_vo
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_vo: // ES_vo
switch (ch)
{
case 'i':
if (CheckLetters("d")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_void;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'l':
if (CheckLetters("atile")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TR_volatile;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES_w: // ES_w
switch (ch)
{
case 'h':
if (CheckLetters("ile")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_while;
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
case 'i':
if (CheckLetters("th")) // Can only be this or unknown
{
state = ES__DONE; // Mark as done
type = TokenType::TK_with;
// Bad Bad Bad
}
else
{
state = ES__UNKNOWN; // Mark as unknown
}
break;
default:
state = ES__UNKNOWN; // Mark as unknown
break;
}
break;
case ES__DONE:
// If it's done that means there's no longer known
// word that it can be, so if we get another char
// then it's a custom symbol that starts out the
// same as a regular symbol
Message::Send(Message::POSSIBLY_AMBIGUOUS);
state = ES__UNKNOWN;
break;
case ES__UNKNOWN:
// Do nothing, we're just collecting data
break;
default:
Message::Send(Message::UNKNOWN_STATE);
state = ES__UNKNOWN;
break;
}
ch = Read();
// Check IsSym and IsDec as now they're both
// valid symbol characters
}
while (IsSym(ch) || IsDec(ch));
if (state == ES__UNKNOWN || type == TokenType::TT_SYMBOL)
{
// Technically not "unknown"
// Just a new custom symbol
// Found a new token
std::streampos
len;
if (!ch)
{
// At the end of the file
m_sCur->clear();
len = 1;
}
else
{
len = 0;
}
len += m_sCur->tellg();
len -= pos;
// Include NULL in allocation
// Use alloca because we only need this
// temporarilly and it's easy to handle
// no need to remember to delete the
// memory on function exit or exception
char *
c = (char *)alloca(len);
if (c)
{
// Get the start of the symbol and read
m_sCur->seekg(pos);
len -= 1;
m_sCur->read(c, len);
c[len] = '\0';
Preprocessor &
pp = Compiler::Get().GetPreprocessor();
// Check if this is a macro
if (pp.Defined(c))
{
// Yes
m_altIn.push(pp.Get(c));
return GetNext();
}
if (m_sCur->bad())
{
// Error reading
Message::Send(Message::INPUT_STREAM_ERROR);
}
else
{
// Read, save token
return Create(c, TokenType::TT_SYMBOL);
}
}
else
{
m_sCur->unget();
Message::Send(Message::OUT_OF_MEMORY);
}
// Something went wrong
// Compile should fail
return Create(TokenType::TT__NONE);
}
else
{
// Found an existing known token
if (TokenType::IsReserved(type) && type != TokenType::TK_undefined)
{
// Using a reserved word, may conflict in future
Message::Send(Message::USED_RESERVE, SC::L(type));
}
// Return a character to the stream
m_sCur->unget();
return Create(type);
}
}
