void Expr4(out ScriptVar v)
{
ScriptVar b;
Expr5(out v);
while (la.kind == 22 || la.kind == 23)
{
bool isDiv;
if (la.kind == 22)
{
Get();
isDiv = false;
}
else
{
Get();
isDiv = true;
}
Expr5(out b);
if (!_isParsing)
{
if (!v.IsNumber || !b.IsNumber)
{
SemErr(string.Format("Operator '{0}' cant be applied to numbers only", isDiv ? '/' : '*'));
}
v.AsNumber = isDiv ? (b.AsNumber == 0f ? 0f : v.AsNumber / b.AsNumber) : v.AsNumber * b.AsNumber;
}
}
}
public static void ExecImpl(ScriptVar var, object userData)
{
var engine = (ScriptEngine)userData;
var script = var.GetParameter("str").String;
engine.Execute(script);
}
private ScriptVarLink Condition(ref bool execute)
{
ScriptVarLink a = Shift(ref execute);
while (_currentLexer.TokenType == ScriptLex.LexTypes.Equal ||
_currentLexer.TokenType == ScriptLex.LexTypes.NEqual ||
_currentLexer.TokenType == ScriptLex.LexTypes.TypeEqual ||
_currentLexer.TokenType == ScriptLex.LexTypes.NTypeEqual ||
_currentLexer.TokenType == ScriptLex.LexTypes.LEqual ||
_currentLexer.TokenType == ScriptLex.LexTypes.GEqual ||
_currentLexer.TokenType == (ScriptLex.LexTypes) '>' ||
_currentLexer.TokenType == (ScriptLex.LexTypes) '<'
)
{
ScriptLex.LexTypes op = _currentLexer.TokenType;
_currentLexer.Match(op);
ScriptVarLink b = Shift(ref execute);
if (execute)
{
ScriptVar res = a.Var.MathsOp(b.Var, op);
if (a.Owned)
{
a = new ScriptVarLink(res, null);
}
else
{
a.ReplaceWith(res);
}
}
}
return(a);
}
private ScriptVarLink Term(ref bool execute)
{
ScriptVarLink a = Unary(ref execute);
while (_currentLexer.TokenType == (ScriptLex.LexTypes) '*' ||
_currentLexer.TokenType == (ScriptLex.LexTypes) '/' ||
_currentLexer.TokenType == (ScriptLex.LexTypes) '%')
{
ScriptLex.LexTypes op = _currentLexer.TokenType;
_currentLexer.Match(_currentLexer.TokenType);
ScriptVarLink b = Unary(ref execute);
if (execute)
{
ScriptVar res = a.Var.MathsOp(b.Var, op);
if (a.Owned)
{
a = new ScriptVarLink(res, null);
}
else
{
a.ReplaceWith(res);
}
}
}
return(a);
}
private ScriptVarLink Logic(ref bool execute)
{
var a = Condition(ref execute);
ScriptVarLink b;
while (currentLexer.TokenType == (ScriptLex.LexTypes) '&' ||
currentLexer.TokenType == (ScriptLex.LexTypes) '|' ||
currentLexer.TokenType == (ScriptLex.LexTypes) '^' ||
currentLexer.TokenType == ScriptLex.LexTypes.AndAnd ||
currentLexer.TokenType == ScriptLex.LexTypes.OrOr)
{
var noExecute = false;
var op = currentLexer.TokenType;
currentLexer.Match(op);
var shortcut = false;
var isBool = false;
if (op == ScriptLex.LexTypes.AndAnd)
{
op = (ScriptLex.LexTypes) '&';
shortcut = !a.Var.Bool;
isBool = true;
}
else if (op == ScriptLex.LexTypes.OrOr)
{
op = (ScriptLex.LexTypes) '|';
shortcut = a.Var.Bool;
isBool = true;
}
if (shortcut)
{
b = Condition(ref noExecute);
}
else
{
b = Condition(ref execute);
}
if (execute && !shortcut)
{
if (isBool)
{
var newA = new ScriptVar(a.Var.Bool);
var newB = new ScriptVar(b.Var.Bool);
CreateLink(ref a, newA);
CreateLink(ref b, newB);
}
var res = a.Var.MathsOp(b.Var, op);
CreateLink(ref a, res);
}
}
return(a);
}
private ScriptVarLink Base(ref bool execute)
{
ScriptVarLink a = Ternary(ref execute);
if (_currentLexer.TokenType == (ScriptLex.LexTypes) '=' ||
_currentLexer.TokenType == ScriptLex.LexTypes.PlusEqual ||
_currentLexer.TokenType == ScriptLex.LexTypes.MinusEqual)
{
if (execute && a.Owned)
{
if (a.Name.Length > 0)
{
ScriptVarLink aReal = Root.AddChildNoDup(a.Name, a.Var);
a = aReal;
}
else
{
// Hit an unknow error here
#if !WINDOWS_UWP
System.Diagnostics.Trace.TraceWarning("Trying to assign to an unnamed type...");
#endif
}
}
ScriptLex.LexTypes op = _currentLexer.TokenType;
_currentLexer.Match(op);
ScriptVarLink b = Base(ref execute);
if (execute)
{
switch (op)
{
case (ScriptLex.LexTypes) '=':
a.ReplaceWith(b);
break;
case ScriptLex.LexTypes.PlusEqual:
{
ScriptVar res = a.Var.MathsOp(b.Var, (ScriptLex.LexTypes) '+');
a.ReplaceWith(res);
}
break;
case ScriptLex.LexTypes.MinusEqual:
{
ScriptVar res = a.Var.MathsOp(b.Var, (ScriptLex.LexTypes) '-');
a.ReplaceWith(res);
}
break;
default:
throw new ScriptException("Base broke");
}
}
}
return(a);
}
public void BoolScriptVarIsIntAndTrue()
{
var v = new ScriptVar(true);
Assert.IsTrue(v.IsInt);
Assert.IsTrue(v.Bool);
}
public static void MathRandomImpl(ScriptVar var, object userData)
{
var random = new Random();
var randomNumber = random.NextDouble();
var.ReturnVar.Float = (randomNumber);
}
private ScriptVarLink Unary(ref bool execute)
{
ScriptVarLink a;
if (_currentLexer.TokenType == (ScriptLex.LexTypes) '!')
{
_currentLexer.Match((ScriptLex.LexTypes) '!');
a = Factor(ref execute);
if (execute)
{
ScriptVar zero = new ScriptVar(0);
ScriptVar res = a.Var.MathsOp(zero, ScriptLex.LexTypes.Equal);
if (a.Owned)
{
a = new ScriptVarLink(res, null);
}
else
{
a.ReplaceWith(res);
}
}
}
else
{
a = Factor(ref execute);
}
return(a);
}
public static void MathATanImpl(ScriptVar var, object userData)
{
var val = var.GetParameter("val").Float;
var returnVal = Math.Atan(val);
var.ReturnVar.Float = (returnVal);
}
public static void Round(ScriptVar var, object userData)
{
var val = var.GetParameter("val").Float;
var returnVal = Math.Round(val);
var.ReturnVar.Float = (returnVal);
}
public static void IntValueOfImpl(ScriptVar var, object userData)
{
var str = var.GetParameter("str").String;
var intResult = Convert.ToInt32(str[0]);
var.ReturnVar.Int = intResult;
}
public static void CharToIntImpl(ScriptVar var, object userData)
{
var charStr = var.GetParameter("char").String;
var charParam = charStr[0];
var charAsInt = Convert.ToInt32(charParam);
var.ReturnVar.Int = charAsInt;
}
public static void StringFromCharCodeImpl(ScriptVar var, object userData)
{
var charVar = var.GetParameter("char").Int;
var charAsChar = Convert.ToChar(charVar);
var.ReturnVar.String = charAsChar.ToString();
}
public static void EvalImpl(ScriptVar var, object userData)
{
var engine = (ScriptEngine)userData;
var script = var.GetParameter("str").String;
var returnVal = engine.EvalComplex(script);
var.ReturnVar = returnVal.Var;
}
public static void MathATan2Impl(ScriptVar var, object userData)
{
var y = var.GetParameter("y").Float;
var x = var.GetParameter("x").Float;
var returnVal = Math.Atan2(y, x);
var.ReturnVar.Float = (returnVal);
}
public static void StringIndexOfImpl(ScriptVar var, object userData)
{
var search = var.GetParameter("search").String;
var searchInStr = var.GetParameter("this").String;
var index = searchInStr.IndexOf(search);
var.ReturnVar.Int = index;
}
public static void MathMaxImpl(ScriptVar var, object userData)
{
var val1 = var.GetParameter("val1").Float;
var val2 = var.GetParameter("val2").Float;
var returnVal = Math.Max(val1, val2);
var.ReturnVar.Float = (returnVal);
}
public static void MathPowImpl(ScriptVar var, object userData)
{
var y = var.GetParameter("y").Float;
var x = var.GetParameter("x").Float;
var returnVal = Math.Pow(x, y);
var.ReturnVar.Float = (returnVal);
}
public static void StringSubStringImpl(ScriptVar var, object userData)
{
var str = var.GetParameter("this").String;
var lo = var.GetParameter("lo").Int;
var hi = var.GetParameter("hi").Int;
var substr = str.Substring(lo, hi - lo);
var.ReturnVar.String = substr;
}
void Expr2(out ScriptVar v)
{
ScriptVar b; int mode;
Expr3(out v);
while (StartOf(3))
{
if (la.kind == 16)
{
Get();
mode = 0;
}
else if (la.kind == 17)
{
Get();
mode = 1;
}
else if (la.kind == 18)
{
Get();
mode = 2;
}
else
{
Get();
mode = 3;
}
Expr3(out b);
if (!_isParsing)
{
if (!v.IsNumber || !b.IsNumber)
{
SemErr("'<' operator can be applied to numbers only");
}
switch (mode)
{
case 0:
v.AsNumber = v.AsNumber < b.AsNumber ? 1f : 0f;
break;
case 1:
v.AsNumber = v.AsNumber > b.AsNumber ? 1f : 0f;
break;
case 2:
v.AsNumber = v.AsNumber <= b.AsNumber ? 1f : 0f;
break;
case 3:
v.AsNumber = v.AsNumber >= b.AsNumber ? 1f : 0f;
break;
}
}
}
}
public static void IntParseIntImpl(ScriptVar var, object userData)
{
var str = var.GetParameter("str").String;
if (int.TryParse(str, out int intResult) == false)
{
intResult = 0;
}
var.ReturnVar.Int = intResult;
}
public static void MathRandomIntImpl(ScriptVar var, object userData)
{
var random = new Random();
var min = var.GetParameter("min").Int;
var max = var.GetParameter("max").Int;
var randomInt = random.Next(min, max);
var.ReturnVar.Int = randomInt;
}
public static void JsonStringifyImpl(ScriptVar var, object userData)
{
var stream = new MemoryStream();
var.GetParameter("obj").GetJSON(stream, "");
stream.Seek(0, SeekOrigin.Begin);
var streamReader = new StreamReader(stream);
var json = streamReader.ReadToEnd();
var.ReturnVar.String = json;
}
public static void StringCharCodeAtImpl(ScriptVar var, object userData)
{
var str = var.GetParameter("this").String;
var pos = var.GetParameter("pos").Int;
var charCode = 0;
if (str.Length > pos)
{
charCode = Convert.ToInt32(str[pos]);
}
var.ReturnVar.Int = charCode;
}
public static void StringCharAtImpl(ScriptVar var, object userData)
{
var str = var.GetParameter("this").String;
var pos = var.GetParameter("pos").Int;
var charStr = string.Empty;
if (str.Length > pos)
{
charStr = str[pos].ToString();
}
var.ReturnVar.String = charStr;
}
public string CallFunction()
{
la = Scanner.EmptyToken;
_isReturned = false;
RetVal = new ScriptVar();
try {
Get();
Block();
} catch (Exception ex) {
return(ex.Message);
}
return(null);
}
public static void StringSplitImpl(ScriptVar var, object userData)
{
var str = var.GetParameter("this").String;
var sep = var.GetParameter("sep").String;
var spltStrs = str.Split(new[] { sep }, StringSplitOptions.None);
var.ReturnVar.SetArray();
for (int x = 0; x < spltStrs.Length; x++)
{
var.ReturnVar.SetArrayIndex(x, new ScriptVar(spltStrs[x]));
}
}
private ScriptVarLink Unary(ref bool execute)
{
ScriptVarLink a;
if (currentLexer.TokenType == (ScriptLex.LexTypes) '!')
{
currentLexer.Match((ScriptLex.LexTypes) '!');
a = Factor(ref execute);
if (execute)
{
var zero = new ScriptVar(0);
var res = a.Var.MathsOp(zero, ScriptLex.LexTypes.Equal);
CreateLink(ref a, res);
}
}
else if (currentLexer.TokenType == ScriptLex.LexTypes.RTypeOf)
{
currentLexer.Match(ScriptLex.LexTypes.RTypeOf);
a = Factor(ref execute);
if (execute)
{
var varType = new ScriptVar(a.Var.GetObjectType());
CreateLink(ref a, varType);
}
}
else if (currentLexer.TokenType == ScriptLex.LexTypes.PlusPlus || currentLexer.TokenType == ScriptLex.LexTypes.MinusMinus)
{
var op = currentLexer.TokenType == ScriptLex.LexTypes.PlusPlus ? '+' : '-';
currentLexer.Match(currentLexer.TokenType);
a = Factor(ref execute);
if (execute)
{
var one = new ScriptVar(1);
var res = a.Var.MathsOp(one, (ScriptLex.LexTypes)op);
a.ReplaceWith(res);
//CreateLink(ref a, res);
}
}
else
{
a = Factor(ref execute);
}
return(a);
}
void Expr1(out ScriptVar v)
{
ScriptVar b; int op;
Expr2(out v);
while (la.kind == 14 || la.kind == 15)
{
if (la.kind == 14)
{
Get();
op = 0;
}
else
{
Get();
op = 1;
}
Expr2(out b);
if (!_isParsing)
{
switch (op)
{
case 0:
if (v.Type != b.Type)
{
v.AsNumber = 0f;
}
else
{
v.AsNumber = v.IsNumber ? (v.AsNumber == b.AsNumber ? 1f : 0f) : (v.AsString == b.AsString ? 1f : 0f);
}
break;
case 1:
if (v.Type != b.Type)
{
v.AsNumber = 1f;
}
else
{
v.AsNumber = v.IsNumber ? (v.AsNumber != b.AsNumber ? 1f : 0f) : (v.AsString != b.AsString ? 1f : 0f);
}
break;
}
}
}
}
void Expr3(out ScriptVar v)
{
ScriptVar b; bool isSub;
Expr4(out v);
while (la.kind == 20 || la.kind == 21) {
if (la.kind == 20) {
Get();
isSub = false;
} else {
Get();
isSub = true;
}
Expr4(out b);
if (!_isParsing) {
if (v.IsString || b.IsString) {
if (isSub) {
SemErr("Operator '-' cant be applied to strings");
} else {
v.AsString = v.AsString + b.AsString;
}
} else {
if (v.IsNumber || b.IsNumber) {
v.AsNumber = v.AsNumber + (isSub ? -b.AsNumber : b.AsNumber);
}
}
}
}
}
void Expr4(out ScriptVar v)
{
ScriptVar b;
Expr5(out v);
while (la.kind == 22 || la.kind == 23) {
bool isDiv;
if (la.kind == 22) {
Get();
isDiv = false;
} else {
Get();
isDiv = true;
}
Expr5(out b);
if (!_isParsing) {
if (!v.IsNumber || !b.IsNumber) {
SemErr(string.Format("Operator '{0}' cant be applied to numbers only", isDiv ? '/' : '*'));
}
v.AsNumber = isDiv ? (b.AsNumber == 0f ? 0f : v.AsNumber / b.AsNumber) : v.AsNumber * b.AsNumber;
}
}
}
void Expr5(out ScriptVar v)
{
v = new ScriptVar(); var isNegative = false;
if (la.kind == 21) {
Get();
isNegative = true;
}
if (la.kind == 5) {
Get();
Expr(out v);
Expect(7);
} else if (la.kind == 1 || la.kind == 2 || la.kind == 3) {
Term(out v);
} else SynErr(34);
if (!_isParsing) {
if (isNegative) {
if (v.IsNumber) {
v.AsNumber = -v.AsNumber;
} else {
SemErr("Minus can be applied only on numbers");
}
}
}
}
void Expr2(out ScriptVar v)
{
ScriptVar b; int mode;
Expr3(out v);
while (StartOf(3)) {
if (la.kind == 16) {
Get();
mode = 0;
} else if (la.kind == 17) {
Get();
mode = 1;
} else if (la.kind == 18) {
Get();
mode = 2;
} else {
Get();
mode = 3;
}
Expr3(out b);
if (!_isParsing) {
if (!v.IsNumber || !b.IsNumber) {
SemErr("'<' operator can be applied to numbers only");
}
switch (mode) {
case 0:
v.AsNumber = v.AsNumber < b.AsNumber ? 1f : 0f;
break;
case 1:
v.AsNumber = v.AsNumber > b.AsNumber ? 1f : 0f;
break;
case 2:
v.AsNumber = v.AsNumber <= b.AsNumber ? 1f : 0f;
break;
case 3:
v.AsNumber = v.AsNumber >= b.AsNumber ? 1f : 0f;
break;
}
}
}
}
void Term(out ScriptVar v)
{
v = new ScriptVar(); var callOffset = int.MaxValue; var isCall = false;
if (la.kind == 1) {
Get();
var identName = t.val;
if (la.kind == 5) {
Get();
ScriptVar p; isCall = true; if (!_isParsing) { callOffset = CallParams.Count; }
if (StartOf(2)) {
Expr(out p);
if (!_isParsing) { CallParams.Add(p); }
while (la.kind == 6) {
Get();
Expr(out p);
if (!_isParsing) { CallParams.Add(p); }
}
}
Expect(7);
}
if (isCall) {
if (!Vars.IsHostFunctionExists(identName)) {
SemErr(string.Format("Cant find host function with name '{0}'", identName));
}
}
if (!_isParsing) {
if (isCall) {
CallParamsOffset = callOffset;
v = Vars.CallHostFunction(identName);
while (CallParams.Count > callOffset) {
CallParams.RemoveAt(CallParams.Count - 1);
}
} else {
if (!Vars.IsVarExists(t.val)) {
SemErr(string.Format("Variable '{0}' not found", identName));
}
v = Vars.GetVar(identName);
}
}
} else if (la.kind == 2) {
Get();
if (!_isParsing) {
v.AsNumber = t.val.ToFloatUnchecked();
}
} else if (la.kind == 3) {
Get();
if (!_isParsing) {
v.AsString = t.val;
}
} else SynErr(35);
}
public string CallFunction()
{
la = Scanner.EmptyToken;
_isReturned = false;
RetVal = new ScriptVar();
try {
Get();
Block();
} catch (Exception ex) {
return ex.Message;
}
return null;
}
void Expr1(out ScriptVar v)
{
ScriptVar b; int op;
Expr2(out v);
while (la.kind == 14 || la.kind == 15) {
if (la.kind == 14) {
Get();
op = 0;
} else {
Get();
op = 1;
}
Expr2(out b);
if (!_isParsing) {
switch (op) {
case 0:
if (v.Type != b.Type) {
v.AsNumber = 0f;
} else {
v.AsNumber = v.IsNumber ? (v.AsNumber == b.AsNumber ? 1f : 0f) : (v.AsString == b.AsString ? 1f : 0f);
}
break;
case 1:
if (v.Type != b.Type) {
v.AsNumber = 1f;
} else {
v.AsNumber = v.IsNumber ? (v.AsNumber != b.AsNumber ? 1f : 0f) : (v.AsString != b.AsString ? 1f : 0f);
}
break;
}
}
}
}
void Expr(out ScriptVar v)
{
ScriptVar b; int op;
Expr1(out v);
while (la.kind == 12 || la.kind == 13) {
if (la.kind == 12) {
Get();
op = 0;
} else {
Get();
op = 1;
}
Expr1(out b);
if (!_isParsing) {
if (!v.IsNumber || !b.IsNumber) {
SemErr("'<' operator can be applied to numbers only");
}
switch (op) {
case 0:
v.AsNumber = v.AsNumber != 0f || b.AsNumber != 0f ? 1f : 0f;
break;
case 1:
v.AsNumber = v.AsNumber != 0f && b.AsNumber != 0f ? 1f : 0f;
break;
}
}
}
}
