static bool UpdateIfTernary(ParsingScript script, string token, char ch, List <Variable> listInput, Action <List <Variable> > listToMerge)
{
if (listInput.Count < 1 || ch != Constants.TERNARY_OPERATOR || token.Length > 0)
{
return(false);
}
Variable result;
Variable arg1 = MergeList(listInput, script);
script.MoveForwardIf(Constants.TERNARY_OPERATOR);
double condition = arg1.AsDouble();
if (condition != 0)
{
result = script.Execute(Constants.TERNARY_SEPARATOR);
script.MoveForwardIf(Constants.TERNARY_SEPARATOR);
Utils.SkipRestExpr(script, Constants.END_STATEMENT);
}
else
{
Utils.SkipRestExpr(script, Constants.TERNARY_SEPARATOR[0]);
script.MoveForwardIf(Constants.TERNARY_SEPARATOR);
result = script.Execute(Constants.NEXT_OR_END_ARRAY);
}
listInput.Clear();
listInput.Add(result);
listToMerge(listInput);
return(true);
}
protected override Variable Evaluate(ParsingScript script)
{
string funcReturn, funcName;
Utils.GetCompiledArgs(script, out funcReturn, out funcName);
#if __ANDROID__ == false && __IOS__ == false
Precompiler.RegisterReturnType(funcName, funcReturn);
Dictionary <string, Variable> argsMap;
string[] args = Utils.GetCompiledFunctionSignature(script, out argsMap);
script.MoveForwardIf(Constants.START_GROUP, Constants.SPACE);
int parentOffset = script.Pointer;
string body = Utils.GetBodyBetween(script, Constants.START_GROUP, Constants.END_GROUP);
Precompiler precompiler = new Precompiler(funcName, args, argsMap, body, script);
precompiler.Compile(m_scriptInCSharp);
CustomCompiledFunction customFunc = new CustomCompiledFunction(funcName, body, args, precompiler, argsMap, script);
customFunc.ParentScript = script;
customFunc.ParentOffset = parentOffset;
ParserFunction.RegisterFunction(funcName, customFunc, false /* not native */);
#endif
return(new Variable(funcName));
}
static Variable ExtractObject(ParsingScript script)
{
Variable newValue = new Variable(Variable.VarType.ARRAY);
while (script.StillValid() && (newValue.Count == 0 || script.Current == ','))
{
script.Forward();
string key = Utils.GetToken(script, SEP);
script.MoveForwardIf(':');
Variable valueVar = ExtractValue(script);
newValue.SetHashVariable(key, valueVar);
}
script.MoveForwardIf('}');
return(newValue);
}
protected override Variable Evaluate(ParsingScript script)
{
string methodName = Utils.GetItem(script).AsString();
Utils.CheckNotEmpty(script, methodName, m_name);
script.MoveForwardIf(Constants.NEXT_ARG);
string paramName = Utils.GetToken(script, Constants.NEXT_ARG_ARRAY);
Utils.CheckNotEmpty(script, paramName, m_name);
script.MoveForwardIf(Constants.NEXT_ARG);
Variable paramValueVar = Utils.GetItem(script);
string paramValue = paramValueVar.AsString();
var result = Statics.InvokeCall(typeof(Statics),
methodName, paramName, paramValue);
return(result);
}
static Variable ExtractArray(ParsingScript script)
{
Variable newValue = new Variable(Variable.VarType.ARRAY);
while (script.StillValid() && (newValue.Count == 0 || script.Current == ','))
{
script.Forward();
Variable addVariable = ExtractValue(script);
newValue.AddVariable(addVariable);
}
script.MoveForwardIf(']');
return(newValue);
}
static List <Variable> Split(ParsingScript script, char[] to)
{
List <Variable> listToMerge = new List <Variable>(16);
if (!script.StillValid() || to.Contains(script.Current))
{
listToMerge.Add(Variable.EmptyInstance);
script.Forward();
return(listToMerge);
}
int arrayIndexDepth = 0;
bool inQuotes = false;
int negated = 0;
char ch;
string action;
do
{ // Main processing cycle of the first part.
string token = ExtractNextToken(script, to, ref inQuotes, ref arrayIndexDepth, ref negated, out ch, out action);
bool ternary = UpdateIfTernary(script, token, ch, listToMerge, (List <Variable> newList) => { listToMerge = newList; });
if (ternary)
{
return(listToMerge);
}
bool negSign = CheckConsistencyAndSign(script, listToMerge, action, ref token);
// We are done getting the next token. The GetValue() call below may
// recursively call SplitAndMerge(). This will happen if extracted
// item is a function or if the next item is starting with a START_ARG '('.
ParserFunction func = new ParserFunction(script, token, ch, ref action);
Variable current = func.GetValue(script);
if (UpdateResult(script, to, listToMerge, token, negSign, ref current, ref negated, ref action))
{
return(listToMerge);
}
} while (script.StillValid() &&
(inQuotes || arrayIndexDepth > 0 || !to.Contains(script.Current)));
// This happens when called recursively inside of the math expression:
script.MoveForwardIf(Constants.END_ARG);
return(listToMerge);
}
static async Task <List <Variable> > SplitAsync(ParsingScript script, char[] to)
{
List <Variable> listToMerge = new List <Variable>(16);
if (!script.StillValid() || to.Contains(script.Current))
{
listToMerge.Add(Variable.EmptyInstance);
script.Forward();
return(listToMerge);
}
int arrayIndexDepth = 0;
bool inQuotes = false;
int negated = 0;
char ch;
string action;
do
{ // Main processing cycle of the first part.
string token = ExtractNextToken(script, to, ref inQuotes, ref arrayIndexDepth, ref negated, out ch, out action);
bool ternary = UpdateIfTernary(script, token, ch, listToMerge, (List <Variable> newList) => { listToMerge = newList; });
if (ternary)
{
return(listToMerge);
}
bool negSign = CheckConsistencyAndSign(script, listToMerge, action, ref token);
ParserFunction func = new ParserFunction(script, token, ch, ref action);
Variable current = await func.GetValueAsync(script);
if (UpdateResult(script, to, listToMerge, token, negSign, ref current, ref negated, ref action))
{
return(listToMerge);
}
} while (script.StillValid() &&
(inQuotes || arrayIndexDepth > 0 || !to.Contains(script.Current)));
// This happens when called recursively inside of the math expression:
script.MoveForwardIf(Constants.END_ARG);
return(listToMerge);
}
protected override Variable Evaluate(ParsingScript script)
{
string source = Utils.GetItem(script).AsString();
script.MoveForwardIf(Constants.NEXT_ARG, Constants.SPACE);
string dest = Utils.GetItem(script).AsString();
string src = Path.GetFullPath(source);
string dst = Path.GetFullPath(dest);
bool isFile = File.Exists(src);
bool isDir = Directory.Exists(src);
if (!isFile && !isDir)
{
throw new ArgumentException("[" + src + "] doesn't exist");
}
if (isFile && Directory.Exists(dst))
{
// If filename is missing in the destination file,
// add it from the source.
dst = Path.Combine(dst, Path.GetFileName(src));
}
try
{
if (isFile)
{
File.Move(src, dst);
}
else
{
Directory.Move(src, dst);
}
}
catch (Exception exc)
{
throw new ArgumentException("Couldn't copy: " + exc.Message);
}
return(Variable.EmptyInstance);
}
protected override Variable Evaluate(ParsingScript script)
{
string source = Utils.GetItem(script).AsString();
script.MoveForwardIf(Constants.NEXT_ARG, Constants.SPACE);
string dest = Utils.GetItem(script).AsString();
string src = Path.GetFullPath(source);
string dst = Path.GetFullPath(dest);
List <Variable> srcPaths = Utils.GetPathnames(src);
bool multipleFiles = srcPaths.Count > 1;
if (dst.EndsWith("*"))
{
dst = dst.Remove(dst.Count() - 1);
}
if ((multipleFiles || Directory.Exists(src)) &&
!Directory.Exists(dst))
{
try
{
Directory.CreateDirectory(dst);
}
catch (Exception exc)
{
throw new ArgumentException("Couldn't create [" + dst + "] :" + exc.Message);
}
}
foreach (Variable srcPath in srcPaths)
{
string filename = Path.GetFileName(srcPath.String);
//string dstPath = Path.Combine(dst, filename);
Utils.Copy(srcPath.String, dst);
}
return(Variable.EmptyInstance);
}
static bool CheckConsistencyAndSign(ParsingScript script, List <Variable> listToMerge, string action, ref string token)
{
if (Constants.CONTROL_FLOW.Contains(token) && listToMerge.Count > 0)
{//&&
//item != Constants.RETURN) {
// This can happen when the end of statement ";" is forgotten.
listToMerge.Clear();
//throw new ArgumentException("Token [" +
// item + "] can't be part of an expression. Check \";\". Stopped at [" +
// script.Rest + " ...]");
}
script.MoveForwardIf(Constants.SPACE);
if (action != null && action.Length > 1)
{
script.Forward(action.Length - 1);
}
bool negSign = CheckNegativeSign(ref token);
return(negSign);
}
static bool UpdateResult(ParsingScript script, char[] to, List <Variable> listToMerge, string token, bool negSign,
ref Variable current, ref int negated, ref string action)
{
if (current == null)
{
current = Variable.EmptyInstance;
}
current.ParsingToken = token;
if (negSign)
{
current = new Variable(-1 * current.Value);
}
if (negated > 0 && current.Type == Variable.VarType.NUMBER)
{
// If there has been a NOT sign, this is a boolean.
// Use XOR (true if exactly one of the arguments is true).
bool neg = !((negated % 2 == 0) ^ Convert.ToBoolean(current.Value));
current = new Variable(Convert.ToDouble(neg));
negated = 0;
}
if (script.Current == '.')
{
bool inQuotes = false;
int arrayIndexDepth = 0;
script.Forward();
string property = ExtractNextToken(script, to, ref inQuotes, ref arrayIndexDepth, ref negated, out _, out action);
Variable propValue = current.Type == Variable.VarType.ENUM ?
current.GetEnumProperty(property, script) :
current.GetProperty(property, script);
current = propValue;
}
if (action == null)
{
action = UpdateAction(script, to);
}
else
{
script.MoveForwardIf(action[0]);
}
char next = script.TryCurrent(); // we've already moved forward
bool done = listToMerge.Count == 0 &&
(next == Constants.END_STATEMENT ||
(action == Constants.NULL_ACTION && current.Type != Variable.VarType.NUMBER) ||
current.IsReturn);
if (done)
{
if (action != null && action != Constants.END_ARG_STR && token != Constants.DEFAULT)
{
throw new ArgumentException("Action [" +
action + "] without an argument.");
}
// If there is no numerical result, we are not in a math expression.
listToMerge.Add(current);
return(true);
}
Variable cell = current.Clone();
cell.Action = action;
bool addIt = UpdateIfBool(script, cell, (Variable newCell) => { cell = newCell; }, listToMerge, (List <Variable> var) => { listToMerge = var; });
if (addIt)
{
listToMerge.Add(cell);
}
return(false);
}