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); }