/// <summary>
/// </summary>
/// <param name="ch"></param>
/// <returns></returns>
public static int Escape(ILReader reader, int ch)
{
int res = -1;
if (ch >= '0' && ch <= '7')
{
StringBuilder octal = new StringBuilder();
octal.Append((char)ch);
int possibleOctalChar = reader.Peek();
if (possibleOctalChar >= '0' && possibleOctalChar <= '7')
{
octal.Append((char)reader.Read());
possibleOctalChar = reader.Peek();
if (possibleOctalChar >= '0' && possibleOctalChar <= '7')
{
octal.Append((char)reader.Read());
}
}
res = Convert.ToInt32(octal.ToString(), 8);
}
else
{
int id = "abfnrtv\"'\\".IndexOf((char)ch);
if (id != -1)
{
res = "\a\b\f\n\r\t\v\"'\\"[id];
}
}
return(res);
}
/// <summary>
/// </summary>
/// <returns></returns>
public override string Build()
{
if (mode == Token.UNKNOWN)
{
return(String.Empty);
}
int ch = 0;
ILReader reader = host.Reader;
StringBuilder idsb = new StringBuilder();
if (mode == Token.SQSTRING || mode == Token.QSTRING)
{
int term = (mode == Token.SQSTRING) ? '\'' : '"';
reader.Read(); // skip quote
for (ch = reader.Read(); ch != -1; ch = reader.Read())
{
if (ch == term)
{
break;
}
if (ch == '\\')
{
ch = reader.Read();
/*
* Long string can be broken across multiple lines
* by using '\' as the last char in line.
* Any white space chars between '\' and the first
* char on the next line are ignored.
*/
if (ch == '\n')
{
reader.SkipWhitespace();
continue;
}
int escaped = Escape(reader, ch);
if (escaped == -1)
{
reader.Unread(ch);
ch = '\\';
}
else
{
ch = escaped;
}
}
idsb.Append((char)ch);
}
}
else
{
// ID
while ((ch = reader.Read()) != -1)
{
if (IsIdChar(ch))
{
idsb.Append((char)ch);
}
else
{
reader.Unread(ch);
break;
}
}
}
return(idsb.ToString());
}
public ILToken GetNextToken()
{
if (lastToken == ILToken.EOF)
{
return(ILToken.EOF);
}
int ch;
int next;
ILToken res = ILToken.EOF.Clone() as ILToken;
while ((ch = reader.Read()) != -1)
{
// Comments
if (ch == '/')
{
next = reader.Peek();
if (next == '/')
{
// double-slash comment, skip to the end of the line.
for (reader.Read();
next != -1 && next != '\n';
next = reader.Read())
{
;
}
res.token = Token.SL_COMMENT;
break;
}
else if (next == '*')
{
reader.Read();
for (next = reader.Read(); next != -1; next = reader.Read())
{
if (next == '*' && reader.Peek() == '/')
{
reader.Read();
goto end;
}
}
end:
res.token = Token.ML_COMMENT;
break;
}
}
// HEXBYTES are flagged by the parser otherwise it is
// impossible to figure them out
if (in_byte_array)
{
string hx = String.Empty;
if (Char.IsWhiteSpace((char)ch))
{
continue;
}
if (ch == ')')
{
res = ILToken.CloseParens;
break;
}
if (!is_hex(ch))
{
throw new ILTokenizingException(reader.Location, ((char)ch).ToString());
}
hx += (char)ch;
if (is_hex(reader.Peek()))
{
hx += (char)reader.Read();
}
else if (!Char.IsWhiteSpace((char)reader.Peek()) && reader.Peek() != ')')
{
throw new ILTokenizingException(reader.Location,
((char)reader.Peek()).ToString());
}
res.token = Token.HEXBYTE;
res.val = Byte.Parse(hx, NumberStyles.HexNumber);
while (Char.IsWhiteSpace((char)reader.Peek()))
{
reader.Read();
}
break;
}
// Ellipsis
if (ch == '.' && reader.Peek() == '.')
{
reader.MarkLocation();
int ch2 = reader.Read();
if (reader.Peek() == '.')
{
res = ILToken.Ellipsis;
reader.Read();
break;
}
reader.Unread(ch2);
reader.RestoreLocation();
}
if (ch == '.' || ch == '#')
{
next = reader.Peek();
if (ch == '.' && Char.IsDigit((char)next))
{
numBuilder.Start(ch);
reader.Unread(ch);
numBuilder.Build();
if (numBuilder.ResultToken != ILToken.Invalid)
{
res.CopyFrom(numBuilder.ResultToken);
break;
}
}
else
{
if (strBuilder.Start(next) && strBuilder.TokenId == Token.ID)
{
reader.MarkLocation();
string dirBody = strBuilder.Build();
string dir = new string((char)ch, 1) + dirBody;
if (IsDirective(dir))
{
res = ILTables.Directives[dir] as ILToken;
}
else
{
reader.Unread(dirBody.ToCharArray());
reader.RestoreLocation();
res = ILToken.Dot;
}
}
else
{
res = ILToken.Dot;
}
break;
}
}
// Numbers && Hexbytes
if (numBuilder.Start(ch))
{
if ((ch == '-') && !(Char.IsDigit((char)reader.Peek())))
{
res = ILToken.Dash;
break;
}
else
{
reader.Unread(ch);
numBuilder.Build();
if (numBuilder.ResultToken != ILToken.Invalid)
{
res.CopyFrom(numBuilder.ResultToken);
break;
}
}
}
// Punctuation
ILToken punct = ILToken.GetPunctuation(ch);
if (punct != null)
{
if (punct == ILToken.Colon && reader.Peek() == ':')
{
reader.Read();
res = ILToken.DoubleColon;
}
else
{
res = punct;
}
break;
}
// ID | QSTRING | SQSTRING | INSTR_* | KEYWORD
if (strBuilder.Start(ch))
{
reader.Unread(ch);
string val = strBuilder.Build();
if (strBuilder.TokenId == Token.ID)
{
ILToken opcode;
next = reader.Peek();
if (next == '.')
{
reader.MarkLocation();
reader.Read();
next = reader.Peek();
if (IsIdChar((char)next))
{
string opTail = BuildId();
string full_str = String.Format("{0}.{1}", val, opTail);
opcode = InstrTable.GetToken(full_str);
if (opcode == null)
{
if (strBuilder.TokenId != Token.ID)
{
reader.Unread(opTail.ToCharArray());
reader.Unread('.');
reader.RestoreLocation();
res.val = val;
}
else
{
res.token = Token.COMP_NAME;
res.val = full_str;
}
break;
}
else
{
res = opcode;
break;
}
}
else if (Char.IsWhiteSpace((char)next))
{
// Handle 'tail.' and 'unaligned.'
opcode = InstrTable.GetToken(val + ".");
if (opcode != null)
{
res = opcode;
break;
}
// Let the parser handle the dot
reader.Unread('.');
}
}
opcode = InstrTable.GetToken(val);
if (opcode != null)
{
res = opcode;
break;
}
if (IsKeyword(val))
{
res = ILTables.Keywords[val] as ILToken;
break;
}
}
res.token = strBuilder.TokenId;
res.val = val;
break;
}
}
OnNewToken(res);
lastToken.CopyFrom(res);
return(res);
}
/// <summary>
/// </summary>
/// <returns></returns>
public override string Build()
{
ILReader reader = host.Reader;
reader.MarkLocation();
StringBuilder num_builder = new StringBuilder();
string num;
int ch;
int peek;
bool is_real = false;
bool dec_found = false;
NumberStyles nstyles = NumberStyles.AllowExponent | NumberStyles.AllowDecimalPoint |
NumberStyles.AllowLeadingSign;
ch = reader.Read();
peek = reader.Peek();
reader.Unread(ch);
if (ch == '0' && (peek == 'x' || peek == 'X'))
{
return(BuildHex());
}
if (is_sign(reader.Peek()))
{
num_builder.Append((char)reader.Read());
}
do
{
ch = reader.Read();
peek = reader.Peek();
num_builder.Append((char)ch);
if (is_e(ch))
{
if (is_real)
{
throw new ILTokenizingException(reader.Location, num_builder.ToString());
}
is_real = true;
}
if (ch == '.')
{
dec_found = true;
}
if (!is_hex(peek) &&
!(peek == '.' && !dec_found) && !is_e(peek) &&
!(is_sign(peek) && is_real))
{
break;
}
} while (ch != -1);
num = num_builder.ToString();
// Check for hexbytes
if (num.Length == 2)
{
if (Char.IsLetter(num[0]) || Char.IsLetter(num[1]))
{
result.token = Token.HEXBYTE;
result.val = Byte.Parse(num, NumberStyles.HexNumber);
return(num);
}
}
if (ch == '.' && peek == '.')
{
num = num.Substring(0, num.Length - 1);
reader.Unread('.');
dec_found = false;
}
else if (ch == '.')
{
num += '0';
}
if (!dec_found && !is_real)
{
try
{
long i = Int64.Parse(num, nstyles);
result.token = Token.INT64;
result.val = i;
return(num);
}
catch
{
}
try
{
long i = (long)UInt64.Parse(num, nstyles);
result.token = Token.INT64;
result.val = i;
return(num);
}
catch
{
}
}
try
{
double d = Double.Parse(num, nstyles, NumberFormatInfo.InvariantInfo);
result.token = Token.FLOAT64;
result.val = d;
}
catch
{
reader.Unread(num.ToCharArray());
reader.RestoreLocation();
num = String.Empty;
Reset();
throw new ILTokenizingException(reader.Location, num_builder.ToString());
}
return(num);
}
public string BuildHex()
{
ILReader reader = host.Reader;
reader.MarkLocation();
StringBuilder num_builder = new StringBuilder();
NumberStyles nstyles = NumberStyles.HexNumber;
string num;
int ch;
int peek;
ch = reader.Read();
if (ch != '0')
{
throw new ILTokenizingException(reader.Location, ((char)ch).ToString());
}
ch = reader.Read();
if (ch != 'x' && ch != 'X')
{
throw new ILTokenizingException(reader.Location, "0" + (char)ch);
}
do
{
ch = reader.Read();
peek = reader.Peek();
num_builder.Append((char)ch);
if (!is_hex((char)peek))
{
break;
}
if (num_builder.Length == 32)
{
throw new ILTokenizingException(reader.Location, num_builder.ToString());
}
} while (ch != -1);
num = num_builder.ToString();
try
{
long i = (long)UInt64.Parse(num, nstyles);
//if (i < Int32.MinValue || i > Int32.MaxValue) {
result.token = Token.INT64;
result.val = i;
//} else {
// result.token = Token.INT32;
// result.val = (int) i;
//}
}
catch
{
string tnum = num;
reader.Unread(num.ToCharArray());
reader.RestoreLocation();
num = String.Empty;
Reset();
throw new ILTokenizingException(reader.Location, tnum);
}
return(num);
}
/// <summary>
/// </summary>
/// <param name="ch"></param>
/// <returns></returns>
public static int Escape(ILReader reader, int ch)
{
int res = -1;
if (ch >= '0' && ch <= '7')
{
StringBuilder octal = new StringBuilder();
octal.Append((char) ch);
int possibleOctalChar = reader.Peek();
if (possibleOctalChar >= '0' && possibleOctalChar <= '7')
{
octal.Append((char) reader.Read());
possibleOctalChar = reader.Peek();
if (possibleOctalChar >= '0' && possibleOctalChar <= '7')
octal.Append((char) reader.Read());
}
res = Convert.ToInt32(octal.ToString(), 8);
}
else
{
int id = "abfnrtv\"'\\".IndexOf((char) ch);
if (id != -1)
{
res = "\a\b\f\n\r\t\v\"'\\"[id];
}
}
return res;
}
