////////////////////////////////////////////////////////////
// power
double ParseLevel6()
{
double ans = ParseLevel7();
ETokenType operatorSy = GetTokenType();
while (operatorSy == ETokenType.PowSy)
{
GetNextToken();
ans = EvalOperator(operatorSy, ans, ParseLevel7());
operatorSy = GetTokenType();
}
return(ans);
}
double EvalOperator(ETokenType operatorSy, double lhs, double rhs)
{
switch (operatorSy)
{
// level 2
case ETokenType.AndSy: return((double)((uint)(lhs) & (uint)(rhs)));
case ETokenType.OrSy: return((double)((uint)(lhs) | (uint)(rhs)));
case ETokenType.BitShiftLeftSy: return((double)((uint)(lhs) << (ushort)(rhs)));
case ETokenType.BitShiftRightSy: return((double)((uint)(lhs) >> (ushort)(rhs)));
// level 3
case ETokenType.EqualSy: return(lhs == rhs ? 1.0 : 0.0);
case ETokenType.UnEqualSy: return(lhs != rhs ? 1.0 : 0.0);
case ETokenType.LessSy: return(lhs < rhs ? 1.0 : 0.0);
case ETokenType.GreaterSy: return(lhs > rhs ? 1.0 : 0.0);
case ETokenType.LessEqualSy: return(lhs <= rhs ? 1.0 : 0.0);
case ETokenType.GreaterEqualSy: return(lhs >= rhs ? 1.0 : 0.0);
// level 4
case ETokenType.PlusSy: return(lhs + rhs);
case ETokenType.MinusSy: return(lhs - rhs);
// level 5
case ETokenType.MultiplySy: return(lhs * rhs);
case ETokenType.DivideSy: return(lhs / rhs);
case ETokenType.ModuloSy: return((double)((uint)(lhs) % (uint)(rhs)));
case ETokenType.XOrSy: return((double)((uint)(lhs) ^ (uint)(rhs)));
// level 6
case ETokenType.PowSy: return(Math.Pow(lhs, rhs));
// level 7
case ETokenType.FactorialSy: return(Factorial(lhs));
}
ErrorAdd(MESSAGE_EXPR_ILLEGAL_OPERATOR);
return(0);
}
////////////////////////////////////////////////////////////
// add or subtract
double ParseLevel4()
{
double ans = ParseLevel5();
ETokenType operatorSy = GetTokenType();
while (operatorSy == ETokenType.PlusSy || operatorSy == ETokenType.MinusSy)
{
GetNextToken();
ans = EvalOperator(operatorSy, ans, ParseLevel5());
operatorSy = GetTokenType();
}
return(ans);
}
////////////////////////////////////////////////////////////
// multiply, divide, modulus, xor
double ParseLevel5()
{
double ans = ParseLevel6();
ETokenType operatorSy = GetTokenType();
while (operatorSy == ETokenType.MultiplySy || operatorSy == ETokenType.DivideSy || operatorSy == ETokenType.ModuloSy || operatorSy == ETokenType.XOrSy)
{
GetNextToken();
ans = EvalOperator(operatorSy, ans, ParseLevel6());
operatorSy = GetTokenType();
}
return(ans);
}
internal static ETokenType GetTokenType(int curr_pos, int world_start_pos, string line, out string out_word)
{
int len = curr_pos - world_start_pos;
out_word = line.Substring(world_start_pos, len);
bool only_digit = true;
int point_count = 0;
bool minus_was = false;
for (int i = 0; i < out_word.Length && only_digit; ++i)
{
char c = out_word[i];
bool point = c == '.';
point_count += point ? 1 : 0;
bool minus = c == '-' && i == 0;
if (minus)
{
minus_was = true;
}
only_digit = (minus || point || char.IsDigit(c)) && point_count < 2;
}
ETokenType tt = ETokenType.Word;
if (only_digit)
{
if (point_count > 0)
{
tt = ETokenType.Float;
}
else if (out_word.Length <= 20)
{
//long: -9223372036854775808 to 9223372036854775807
//ulong: 0 to 18446744073709551615
if (!minus_was && out_word.Length == 20)
{
tt = ETokenType.UInt;
}
else
{
tt = ETokenType.Int;
}
}
}
return(tt);
}
////////////////////////////////////////////////////////////
// conditional operators and bitshift
double ParseLevel2()
{
double ans = ParseLevel3();
ETokenType operatorSy = GetTokenType();
while (operatorSy == ETokenType.AndSy || operatorSy == ETokenType.OrSy || operatorSy == ETokenType.BitShiftLeftSy || operatorSy == ETokenType.BitShiftRightSy)
{
GetNextToken();
ans = EvalOperator(operatorSy, ans, ParseLevel3());
operatorSy = GetTokenType();
}
return(ans);
}
////////////////////////////////////////////////////////////
// conditional operators
double ParseLevel3()
{
double ans = ParseLevel4();
ETokenType operatorSy = GetTokenType();
while (operatorSy == ETokenType.EqualSy || operatorSy == ETokenType.UnEqualSy || operatorSy == ETokenType.LessSy || operatorSy == ETokenType.LessEqualSy ||
operatorSy == ETokenType.GreaterSy || operatorSy == ETokenType.GreaterEqualSy)
{
GetNextToken();
ans = EvalOperator(operatorSy, ans, ParseLevel4());
operatorSy = GetTokenType();
}
return(ans);
}
private static bool IsReturnOrBlockEnd(ETokenType tokenType)
{
switch (tokenType)
{
case ETokenType.KwReturn:
case ETokenType.Eof:
case ETokenType.KwEnd:
case ETokenType.KwElse:
case ETokenType.KwElseIf:
case ETokenType.KwUntil:
return true;
}
return false;
}
private static bool MayBeToken(List <char> list, char next, out ETokenType tokenType)
{
tokenType = ETokenType.E_ERROR;
var listWithNext = list.ToList();
listWithNext.Add(next);
if (MayBeComment(listWithNext, ref tokenType) || MayBeString(listWithNext, ref tokenType))
{
return(true);
}
// we can ignore checking if ( list + next ) can be keyword, because set of keywors is subset of possible id's,
// so if sth is not an id, it for sure won't be a keyword
return(IsToken(listWithNext, out tokenType));
}
////////////////////////////////////////////////////////////
// Factorial
double ParseLevel7()
{
double ans = ParseLevel8();
ETokenType operatorSy = GetTokenType();
while (operatorSy == ETokenType.FactorialSy)
{
GetNextToken();
// factorial does not need a value right from the
// operator, so zero is filled in.
ans = EvalOperator(operatorSy, ans, 0.0);
operatorSy = GetTokenType();
}
return(ans);
}
private static bool MayBeComment(List <char> listWithNext, ref ETokenType tokenType)
{
if (listWithNext.Count == 1 && listWithNext[0] == '/')
{
tokenType = ETokenType.E_STRING;
return(true);
}
else if (listWithNext.Count > 1 &&
GetString(listWithNext).StartsWith("/*") &&
!GetString(listWithNext).Contains("*/"))
{
tokenType = ETokenType.E_COMMENT;
return(true);
}
return(false);
}
double EvalFunction(ETokenType operatorSy, double value)
{
switch (operatorSy)
{
// arithmetic
case ETokenType.AbsSy: return(Math.Abs(value));
case ETokenType.ExpSy: return(Math.Exp(value));
case ETokenType.SignSy: return(Sign(value));
case ETokenType.SqrtSy: return(Math.Sqrt(value));
case ETokenType.LogSy: return(Math.Log(value, 2));
case ETokenType.Log10Sy: return(Math.Log10(value));
// trigonometric
case ETokenType.SinSy: return(Math.Sin(value));
case ETokenType.CosSy: return(Math.Cos(value));
case ETokenType.TanSy: return(Math.Tan(value));
case ETokenType.AsinSy: return(Math.Asin(value));
case ETokenType.AcosSy: return(Math.Acos(value));
case ETokenType.AtanSy: return(Math.Atan(value));
// probability
case ETokenType.FactorialFncSy: return(Factorial(value));
// cnc
case ETokenType.FixSy: return(Math.Floor(value));
case ETokenType.FupSy: return(Math.Ceiling(value));
case ETokenType.RoundSy: return(Math.Round(value));
}
ErrorAdd(MESSAGE_EXPR_ILLEGAL_FUNCTION);
return(0);
}
/*
* 字句型から色を得ます。
*/
Color ColorFromTokenType(ETokenType token_type)
{
switch (token_type)
{
case ETokenType.Char_:
case ETokenType.String_:
case ETokenType.VerbatimString:
return(Colors.Red);
case ETokenType.Keyword:
return(Colors.Blue);
case ETokenType.LineComment:
case ETokenType.BlockComment:
return(Colors.Green);
default:
return(Colors.Black);
}
}
public void EmitBinaryOp(ETokenType op, int a, int b, int c)
{
if (ArithAndBitwiseBinops.TryGetValue(op, out var opCode))
{
EmitABC(opCode, a, b, c);
}
else
{
switch (op)
{
case ETokenType.OpEq:
EmitABC(EOpCode.OP_EQ, 1, b, c);
break;
case ETokenType.OpNe:
EmitABC(EOpCode.OP_EQ, 0, b, c);
break;
case ETokenType.OpLt:
EmitABC(EOpCode.OP_LT, 1, b, c);
break;
case ETokenType.OpGt:
EmitABC(EOpCode.OP_LT, 1, c, b);
break;
case ETokenType.OpLe:
EmitABC(EOpCode.OP_LE, 1, b, c);
break;
case ETokenType.OpGe:
EmitABC(EOpCode.OP_LE, 1, c, b);
break;
}
EmitJmp(0, 1);
EmitLoadBool(a, 0, 1);
EmitLoadBool(a, 1, 0);
}
}
private static string GetColorForToken(ETokenType tokenType)
{
string color = "";
switch (tokenType)
{
case ETokenType.E_KEYWORD: color = "blue"; break;
case ETokenType.E_ID: color = "magenta"; break;
case ETokenType.E_NUMBER: color = "cyan"; break;
case ETokenType.E_STRING: color = "green"; break;
case ETokenType.E_ROUND_BRACKET: color = "navy"; break;
case ETokenType.E_CURLY_BRACKET: color = "olive"; break;
case ETokenType.E_SQUARE_BRACKET: color = "orange"; break;
case ETokenType.E_SEMICOLON: color = "pink"; break;
case ETokenType.E_UNARY_FRONT_OPERATOR: color = "salmon"; break;
case ETokenType.E_UNARY_BACK_OPERATOR: color = "silver"; break;
case ETokenType.E_BINARY_OPERATOR: color = "steelblue"; break;
case ETokenType.E_COMMENT: color = "teal"; break;
case ETokenType.E_ERROR: color = "red"; break;
case ETokenType.E_EMPTY: color = "white"; break;
default: break;
}
return(color);
}
public static void Main(string[] args)
{
string sourcePath = args[0];
string destinationPath = args[1];
List <char> Chars = new List <char>();
List <KeyValuePair <string, ETokenType> > Tokens = new List <KeyValuePair <string, ETokenType> >();
var code = LoadSourceCode(sourcePath);
code += " "; //always empty character on end to improve algorithm simplicity
int index = 0;
ETokenType tokenType = ETokenType.E_EMPTY;
while (index < code.Length)
{
var next = code[index++];
if (MayBeToken(Chars, next, out tokenType))
{
Chars.Add(next);
continue;
}
else if (IsToken(Chars, out tokenType))
{
Tokens.Add(new KeyValuePair <string, ETokenType>(GetString(Chars), tokenType));
index--;
}
else
{
Tokens.Add(new KeyValuePair <string, ETokenType>(GetString(Chars), ETokenType.E_ERROR));
}
Chars.Clear();
}
HTMLBuilder.Build(Tokens, destinationPath);
}
public string GetTokenShortName(ETokenType type)
{
switch (type)
{
case ETokenType.Other: return(string.Empty);
case ETokenType.Info: return("info");
case ETokenType.ClusterNode: return("cluster_node");
case ETokenType.Window: return("window");
case ETokenType.Screen: return("screen");
case ETokenType.Viewport: return("viewport");
case ETokenType.Projection: return("projection");
case ETokenType.Camera: return("camera");
case ETokenType.SceneNode: return("scene_node");
case ETokenType.Input: return("input");
case ETokenType.Stereo: return("stereo");
case ETokenType.Network: return("network");
case ETokenType.Debug: return("debug");
case ETokenType.General: return("general");
case ETokenType.Custom: return("custom");
}
return(string.Empty);
}
protected virtual void EndOfBlockTokenCorrect(Token endToken, string expectedEnd, ETokenType blockType)
{
//DO NOTHING ONLY ON OVERRIDE CLASS, CURRENTLY ONLY PASCAL NEEDS THIS METHOD
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a Condition is empty
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="compositeType">Composite type.</param>
/// <param name="startBlockIndicator">Start block indicator.</param>
protected CodeParseException EmptyCondition(int lineNumber, ETokenType compositeType, string startBlockIndicator)
{
return new CodeParseException (String.Format (errorAtLine + "Expected at least one condition after '{1}' declaration and before '{2}'", lineNumber, compositeType,startBlockIndicator));
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a CodeBlock is Empty
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="compositeType">Composite type.</param>
protected CodeParseException EmptyCodeBlock(int lineNumber, ETokenType compositeType)
{
return new CodeParseException (String.Format (errorAtLine + "A {1} block must define at least one child", lineNumber,compositeType));
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a comment is used inside of a condition.
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="compositeType">Composite type.</param>
/// <param name="startBlockIndicator">Start block indicator.</param>
protected CodeParseException CommentInsideCondition(int lineNumber, ETokenType compositeType, string startBlockIndicator)
{
return new CodeParseException (String.Format (errorAtLine + "a comment cannot be used between '{1}' and '{2}' because it is a block declaration", lineNumber,compositeType, startBlockIndicator));
}
/*
* 字句解析をして各文字の字句型の配列を返します。
*/
public ETokenType[] LexicalAnalysis(string text, ETokenType prev_token_type)
{
// 文字列の長さ
int text_len = text.Length;
// 現在の文字位置
int pos = 0;
// 各文字の字句型の配列
ETokenType[] token_type_list = new ETokenType[text_len];
// 文字列の最後までループします。
while (pos < text_len)
{
ETokenType token_type = ETokenType.Error;
// 字句の開始位置
int start_pos = pos;
// 現在位置の文字
char ch1 = text[pos];
// 次の文字の位置。行末の場合は'\0'
char ch2;
if (pos + 1 < text.Length)
{
// 行末でない場合
ch2 = text[pos + 1];
}
else
{
// 行末の場合
ch2 = '\0';
}
if (pos == 0 && (prev_token_type == ETokenType.BlockComment || prev_token_type == ETokenType.VerbatimString))
{
// 文字列の最初で直前がブロックコメントか逐語的文字列の場合
if (prev_token_type == ETokenType.BlockComment)
{
// ブロックコメントの場合
token_type = ETokenType.BlockComment;
// ブロックコメントの終わりを探します。
int k = text.IndexOf("*/");
if (k != -1)
{
// ブロックコメントの終わりがある場合
pos = k + 2;
}
else
{
// ブロックコメントの終わりがない場合
pos = text_len;
}
}
else
{
// 逐語的文字列の場合
token_type = ETokenType.VerbatimString;
// 逐語的文字列の終わりを探します。
int k = text.IndexOf('\"');
if (k != -1)
{
// 逐語的文字列の終わりがある場合
pos = k + 1;
}
else
{
// 逐語的文字列の終わりがない場合
pos = text_len;
}
}
}
else if (char.IsWhiteSpace(ch1))
{
// 空白の場合
token_type = ETokenType.White;
// 空白の終わりを探します。
for (pos++; pos < text_len && char.IsWhiteSpace(text[pos]); pos++)
{
;
}
}
else if (ch1 == '@' && ch2 == '\"')
{
// 逐語的文字列の場合
token_type = ETokenType.VerbatimString;
// 逐語的文字列の終わりの位置
int k = text.IndexOf('\"', pos + 2);
if (k != -1)
{
// 逐語的文字列の終わりがある場合
pos = k + 1;
}
else
{
// 逐語的文字列の終わりがない場合
pos = text_len;
}
}
else if (char.IsLetter(ch1) || ch1 == '_')
{
// 識別子の最初の文字の場合
// 識別子の文字の最後を探します。識別子の文字はユニコードカテゴリーの文字か数字か'_'です。
for (pos++; pos < text_len && (char.IsLetterOrDigit(text[pos]) || text[pos] == '_'); pos++)
{
;
}
// 識別子の文字列
string name = text.Substring(start_pos, pos - start_pos);
if (KeywordMap.ContainsKey(name))
{
// 名前がキーワード辞書にある場合
token_type = ETokenType.Keyword;
}
else
{
// 名前がキーワード辞書にない場合
token_type = ETokenType.Identifier;
}
}
else if (char.IsDigit(ch1))
{
// 数字の場合
token_type = ETokenType.Number;
if (ch1 == '0' && ch2 == 'x')
{
// 16進数の場合
pos += 2;
// 16進数字の終わりを探します。
for (; pos < text_len && IsHexDigit(text[pos]); pos++)
{
;
}
}
else
{
// 10進数の場合
// 10進数の終わりを探します。
for (; pos < text_len && char.IsDigit(text[pos]); pos++)
{
;
}
if (pos < text_len && text[pos] == '.')
{
// 小数点の場合
pos++;
// 10進数の終わりを探します。
for (; pos < text_len && char.IsDigit(text[pos]); pos++)
{
;
}
}
}
}
else if (ch1 == '\'')
{
// 文字の場合
pos++;
if (ch2 == '\\')
{
// エスケープ文字の場合
// エスケープ文字を読み込み、文字位置(pos)を進めます。
ReadEscapeChar(text, ref pos);
}
else
{
// エスケープ文字でない場合
pos++;
}
if (pos < text_len && text[pos] == '\'')
{
// 文字の終わりがある場合
pos++;
token_type = ETokenType.Char_;
}
else
{
// 文字の終わりがない場合
token_type = ETokenType.Error;
}
}
else if (ch1 == '\"')
{
// 文字列の場合
token_type = ETokenType.Error;
// 文字列の終わりを探します。
for (pos++; pos < text_len;)
{
char ch3 = text[pos];
if (ch3 == '\"')
{
// 文字列の終わりの場合
// ループを抜けます。
pos++;
token_type = ETokenType.String_;
break;
}
else if (ch3 == '\\')
{
// エスケープ文字の場合
// エスケープ文字を読み込み、文字位置(pos)を進めます。
ReadEscapeChar(text, ref pos);
}
else
{
// エスケープ文字でない場合
pos++;
}
}
}
else if (ch1 == '/' && ch2 == '/')
{
// 行コメントの場合
token_type = ETokenType.LineComment;
// 改行を探します。
int k = text.IndexOf('\n', pos);
if (k != -1)
{
// 改行がある場合
pos = k;
}
else
{
// 改行がない場合
pos = text_len;
}
}
else if (ch1 == '/' && ch2 == '*')
{
// ブロックコメントの場合
token_type = ETokenType.BlockComment;
// ブロックコメントの終わりを探します。
int idx = text.IndexOf("*/", pos + 2);
if (idx != -1)
{
// ブロックコメントの終わりがある場合
pos = idx + 2;
}
else
{
// ブロックコメントの終わりがない場合
pos = text_len;
}
}
else
{
// 上記以外は1文字の記号とします。
pos++;
token_type = ETokenType.Symbol;
}
// 各文字の字句型の配列に字句型をセットします。
for (int k = start_pos; k < pos; k++)
{
token_type_list[k] = token_type;
}
}
// 各文字の字句型の配列を返します。
return(token_type_list);
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a InvalidToken has been found after assignement operator
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="assignmentOperator">Assignment operator.</param>
/// <param name="variableName">Variable name.</param>
/// <param name="foundType">Found type.</param>
protected CodeParseException InvalidTokenAfterAssignmentOperator(int lineNumber, string assignmentOperator, string variableName, ETokenType foundType)
{
String result = String.Format (errorAtLine + invalidSyntax + "Found '{3}' after {1} of the variable declaration of '{2}'", lineNumber, assignmentOperator, variableName, foundType);
return new CodeParseException (result);
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a Invalid Value hase been found before an assignment operator
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="assignmentOperator">Assignment operator.</param>
/// <param name="variableName">Variable name.</param>
/// <param name="foundType">Found type.</param>
/// <param name="foundValue">Found value.</param>
protected CodeParseException FoundValueBeforeAssignmentOperator(int lineNumber, string assignmentOperator, string variableName,ETokenType foundType, string foundValue)
{
return new CodeParseException (String.Format (errorAtLine + invalidSyntax + "Found {2} with a value of {3} between {4} and {1} of a variable declaration", lineNumber, assignmentOperator, foundType, foundValue, variableName));
}
internal static bool IsDataType(ETokenType inType)
{
return(inType == ETokenType.Word || inType == ETokenType.Float ||
inType == ETokenType.Int || inType == ETokenType.UInt ||
inType == ETokenType.True || inType == ETokenType.False);
}
public Token(Expression expression, string text = "", ETokenType type = ETokenType.Fake)
: base(expression, text, EItemType.General, true)
{
TokenType = type;
ConstantTypes = ConstantTypes.NonType;
}
public string GetTokenFullName(ETokenType type)
{
string name = GetTokenShortName(type);
return(string.Format("[{0}]", name));
}
/// <summary>
/// Constructor for JSONToken which sets the token type and string value
/// </summary>
/// <param name="token">ETokenType to set</param>
/// <param name="value">string to set</param>
public JSONToken(ETokenType token, string value)
{
_token = token;
_value = value;
}
/*
* 字句型を更新します。
*/
void UpdateTokenType(int sel_start, int sel_end)
{
// 行の先頭位置
int line_top = GetLineTop(sel_start);
// 直前の字句型
ETokenType last_token_type = (line_top == 0 ? ETokenType.Undefined : Chars[line_top - 1].CharType);
for (;;)
{
// 次の行の先頭位置または文書の終わり
int next_line_top = GetNextLineTopOrEOT(line_top);
// 行の先頭位置から次の行の先頭位置または文書の終わりまでの文字列
string lex_string = StringFromRange(line_top, next_line_top);
// 変更前の最後の字句型
ETokenType last_token_type_before = (next_line_top == 0 ? ETokenType.Undefined : Chars[next_line_top - 1].CharType);
// 現在行の字句解析をして字句タイプのリストを得ます。
ETokenType[] token_type_list = LexicalAnalysis(lex_string, last_token_type);
// 字句型をテキストにセットします。
for (int i = 0; i < token_type_list.Length; i++)
{
TChar ch = Chars[line_top + i];
ch.CharType = token_type_list[i];
Chars[line_top + i] = ch;
}
// 変更後の最後の字句型
last_token_type = (token_type_list.Length == 0 ? ETokenType.Undefined : token_type_list[token_type_list.Length - 1]);
if (sel_end <= next_line_top)
{
// 変更した文字列の字句解析が終わった場合
if (last_token_type == last_token_type_before)
{
// 最後の字句型が同じ場合
break;
}
else
{
// 最後の字句型が違う場合
if (last_token_type_before != ETokenType.BlockComment && last_token_type_before != ETokenType.VerbatimString &&
last_token_type != ETokenType.BlockComment && last_token_type != ETokenType.VerbatimString)
{
// 変更前も変更後の最後の字句が複数行にまたがらない場合
break;
}
}
}
// 次の行の字句解析をします。
line_top = next_line_top;
}
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a a value was expected, but found other value
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="expectedType">Expected type.</param>
/// <param name="expectedValue">Expected value.</param>
/// <param name="actualType">Actual type.</param>
/// <param name="actualValue">Actual value.</param>
protected CodeParseException ExpectedButFound(int lineNumber, ETokenType expectedType, string expectedValue, ETokenType actualType, string actualValue)
{
return new CodeParseException (String.Format (errorAtLine + "Expected '{2}' of type {1}, but found '{4}' of type {3}",lineNumber,expectedType,expectedValue,actualType,actualValue));
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a Block is being used before assignment operator
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="assignmentOperator">Assignment operator.</param>
/// <param name="variableName">Variable name.</param>
/// <param name="foundType">Found type.</param>
protected CodeParseException FoundBlockBeforeAssignmentOperator(int lineNumber, string assignmentOperator, string variableName, ETokenType foundType)
{
return new CodeParseException (String.Format (errorAtLine + invalidSyntax + "Found block of type {3} between {2} and {1} of a variable declaration",lineNumber,assignmentOperator,variableName,foundType));
}
protected override void EndOfBlockTokenCorrect(Token endToken, string expectedEnd, ETokenType blockType)
{
if (endToken.Type == ETokenType.endBlock) {
if (endToken.Value != expectedEnd) {
throw IncorrectEndingOfBlock (endToken.Position.Line, expectedEnd, endToken.Value, blockType.ToString());
}
}
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a condition declaration is incomplete
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="compositeType">Composite type.</param>
/// <param name="startBlockIndicator">Start block indicator.</param>
protected CodeParseException IncompleteDeclarationOfCondition(int lineNumber, ETokenType compositeType, string startBlockIndicator)
{
return new CodeParseException (String.Format (errorAtLine + "Expected '{2}' after declaration of '{1}' because it starts the block ", lineNumber,compositeType, startBlockIndicator));
}
public Token(ETokenType operatorType, Object operatorValue)
{
this.operatorType = operatorType;
this.operatorValue = operatorValue;
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a BlockIndicator has been found after condition, this is invalid syntax
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="compositeType">Composite type.</param>
/// <param name="foundType">Found type.</param>
protected CodeParseException BlockIndicatorAfterCondition(int lineNumber, ETokenType compositeType, ETokenType foundType)
{
return new CodeParseException (String.Format (errorAtLine + "Expected new line after {1} declaration, found block of type {2}", lineNumber, compositeType, foundType));
}
public static bool IsValueType(this ETokenType self)
{
return(self == ETokenType.Bool || self == ETokenType.Float || self == ETokenType.Name);
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a unexpected statement has been found
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="value">Value.</param>
/// <param name="type">Type.</param>
protected CodeParseException UnexpectedStatement(int lineNumber, string value, ETokenType type)
{
if (type == ETokenType.Invalid) {
return new CodeParseException (String.Format (errorAtLine + "Syntax '{1}' is an invalid symbol", lineNumber, value));
} else {
return new CodeParseException (String.Format (errorAtLine + "Syntax {1} of type {2} is unexpected", lineNumber, value, type));
}
}
/// Author: Max Hamulyak
/// Date: 24-06-2015
/// <summary>
/// Should be used to indicate that a value is used inside condition.
/// </summary>
/// <returns>CodeParseException</returns>
/// <param name="lineNumber">Line number.</param>
/// <param name="compositeType">Composite type.</param>
/// <param name="foundType">Found type.</param>
/// <param name="value">Value.</param>
protected CodeParseException ValueIndicatorInsideCondition(int lineNumber, ETokenType compositeType, ETokenType foundType, string value)
{
return new CodeParseException (String.Format (errorAtLine + "Found {2} with a value of {3} after {1} declaration", lineNumber, compositeType, foundType, value));
}
public TokenDefinition(ETokenType type, Regex regex, bool isIgnored)
{
Type = type;
Regex = regex;
IsIgnored = isIgnored;
}
public CToken(ETokenType token_type, string inText, int inPos)
{
TokenType = token_type;
_position = inPos;
Text = inText;
}
public void NextToken(out int line, out ETokenType kind, out string token)
{
if (_nextTokenLine > 0)
{
Line = _nextTokenLine;
kind = _nextTokenKind;
line = _nextTokenLine;
token = _nextToken;
_nextTokenLine = 0;
return;
}
SkipWhiteSpaces();
if (_chunk.Length == 0)
{
line = Line;
kind = ETokenType.Eof;
token = "EOF";
return;
}
switch (_chunk[0])
{
case ';':
{
Next(1);
line = Line;
kind = ETokenType.SepSemi;
token = ";";
return;
}
case ',':
{
Next(1);
line = Line;
kind = ETokenType.SepComma;
token = ",";
return;
}
case '(':
{
Next(1);
line = Line;
kind = ETokenType.SepLParen;
token = "(";
return;
}
case ')':
{
Next(1);
line = Line;
kind = ETokenType.SepRParen;
token = ")";
return;
}
case ']':
{
Next(1);
line = Line;
kind = ETokenType.SepRBracket;
token = "]";
return;
}
case '{':
{
Next(1);
line = Line;
kind = ETokenType.SepLCurly;
token = "{";
return;
}
case '}':
{
Next(1);
line = Line;
kind = ETokenType.SepRCurly;
token = "}";
return;
}
case '+':
{
Next(1);
line = Line;
kind = ETokenType.OpAdd;
token = "+";
return;
}
case '-':
{
Next(1);
line = Line;
kind = ETokenType.OpMinus;
token = "-";
return;
}
case '*':
{
Next(1);
line = Line;
kind = ETokenType.OpMul;
token = "*";
return;
}
case '^':
{
Next(1);
line = Line;
kind = ETokenType.OpPow;
token = "^";
return;
}
case '%':
{
Next(1);
line = Line;
kind = ETokenType.OpMod;
token = "%";
return;
}
case '&':
{
Next(1);
line = Line;
kind = ETokenType.OpBAnd;
token = "&";
return;
}
case '|':
{
Next(1);
line = Line;
kind = ETokenType.OpBOr;
token = "|";
return;
}
case '#':
{
Next(1);
line = Line;
kind = ETokenType.OpLen;
token = "#";
return;
}
case ':':
{
if (Test("::"))
{
Next(2);
line = Line;
kind = ETokenType.SepLabel;
token = "::";
}
else
{
Next(1);
line = Line;
kind = ETokenType.SepColon;
token = ":";
}
return;
}
case '/':
{
if (Test("//"))
{
Next(2);
line = Line;
kind = ETokenType.OpIDiv;
token = "//";
}
else
{
Next(1);
line = Line;
kind = ETokenType.OpDiv;
token = "/";
}
return;
}
case '~':
{
if (Test("~="))
{
Next(2);
line = Line;
kind = ETokenType.OpNe;
token = "~=";
}
else
{
Next(1);
line = Line;
kind = ETokenType.OpWave;
token = "~";
}
return;
}
case '=':
{
if (Test("=="))
{
Next(2);
line = Line;
kind = ETokenType.OpEq;
token = "==";
}
else
{
Next(1);
line = Line;
kind = ETokenType.OpAssign;
token = "=";
}
return;
}
case '<':
{
if (Test("<<"))
{
Next(2);
line = Line;
kind = ETokenType.OpShl;
token = "<<";
}
else if (Test("<="))
{
Next(2);
line = Line;
kind = ETokenType.OpLe;
token = "<=";
}
else
{
Next(1);
line = Line;
kind = ETokenType.OpLt;
token = "<";
}
return;
}
case '>':
{
if (Test(">>"))
{
Next(2);
line = Line;
kind = ETokenType.OpShr;
token = ">>";
}
else if (Test(">="))
{
Next(2);
line = Line;
kind = ETokenType.OpGe;
token = ">=";
}
else
{
Next(1);
line = Line;
kind = ETokenType.OpGt;
token = ">";
}
return;
}
case '.':
{
if (Test("..."))
{
Next(3);
line = Line;
kind = ETokenType.Vararg;
token = "...";
return;
}
else if (Test(".."))
{
Next(2);
line = Line;
kind = ETokenType.OpConcat;
token = "..";
return;
}
else if (_chunk.Length == 1 || !char.IsDigit(_chunk[1]))
{
Next(1);
line = Line;
kind = ETokenType.SepDot;
token = ".";
return;
}
break;
}
case '[':
{
if (Test("[[") || Test("[="))
{
var t = ScanLongString();
line = Line;
kind = ETokenType.String;
token = t;
}
else
{
Next(1);
line = Line;
kind = ETokenType.SepLBracket;
token = "[";
}
return;
}
case '\'':
case '"':
{
var t = ScanShortString();
line = Line;
kind = ETokenType.String;
token = t;
return;
}
}
var c = _chunk[0];
// number
if (c == '.' || char.IsDigit(c))
{
token = ScanNumber();
line = Line;
kind = ETokenType.Number;
return;
}
if (c == '_' || char.IsLetter(c))
{
token = ScanIdentifier();
line = Line;
if (Token.Keywords.ContainsKey(token))
{
kind = Token.Keywords[token];
return;
}
else
{
kind = ETokenType.Identifier;
return;
}
}
line = 0;
kind = ETokenType.Unknown;
token = "";
Error($"unexpected symbol near {c}");
}
public TokenDefinition(ETokenType type, Regex regex)
: this(type, regex, false)
{
}
public Token(ETokenType type, int?value = null)
{
Type = type;
Attribute = value;
}
public EToken(int linenr, ETokenType type, string line = "")
{
LineNumber = linenr;
Type = type;
Line = line;
}
public Token(ETokenType type, string value, TokenPosition position)
{
Type = type;
Value = value;
Position = position;
}
public TOKEN(ETokenType type, T tag, int index)
{
_type = type;
_tag = tag;
_index = index;
}
