protected override Variable Evaluate(ParsingScript script) { // Value to be added to the variable: Variable right = Utils.GetItem(script); List <Variable> arrayIndices = Utils.GetArrayIndices(ref m_name); ParserFunction func = ParserFunction.GetFunction(m_name); Utils.CheckNotNull(m_name, func); Variable currentValue = func.GetValue(script); Variable left = currentValue; if (arrayIndices.Count > 0)// array element { left = Utils.ExtractArrayElement(currentValue, arrayIndices); script.MoveForwardIf(Constants.END_ARRAY); } if (left.Type == Variable.VarType.NUMBER) { NumberOperator(left, right, m_action); } else { StringOperator(left, right, m_action); } if (arrayIndices.Count > 0)// array element { AssignFunction.ExtendArray(currentValue, arrayIndices, 0, left); ParserFunction.AddGlobalOrLocalVariable(m_name, new GetVarFunction(currentValue)); } else { ParserFunction.AddGlobalOrLocalVariable(m_name, new GetVarFunction(left)); } return(left); }
protected override Variable Evaluate(ParsingScript script) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 3, m_name); string varName = Utils.GetSafeString(args, 0); Variable lines = Utils.GetSafeVariable(args, 1); int fromLine = Utils.GetSafeInt(args, 2); string hash2 = Utils.GetSafeString(args, 3); string sepStr = Utils.GetSafeString(args, 4, "\t"); if (sepStr == "\\t") { sepStr = "\t"; } char[] sep = sepStr.ToCharArray(); var function = ParserFunction.GetFunction(varName); Variable mapVar = function != null?function.GetValue(script) : new Variable(Variable.VarType.ARRAY); for (int counter = fromLine; counter < lines.Tuple.Count; counter++) { Variable lineVar = lines.Tuple[counter]; Variable toAdd = new Variable(counter - fromLine); string line = lineVar.AsString(); var tokens = line.Split(sep); string hash = tokens[0]; mapVar.AddVariableToHash(hash, toAdd); if (!string.IsNullOrWhiteSpace(hash2) && !hash2.Equals(hash, StringComparison.OrdinalIgnoreCase)) { mapVar.AddVariableToHash(hash2, toAdd); } } ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(mapVar)); return(Variable.EmptyInstance); }
void ProcessArrayFor(ParsingScript script,string forString) { int index = forString.IndexOf(Constants.FOR_EACH); if (index <= 0 || index == forString.Length - 1) { throw new ArgumentException("Expecting: for(item : array)"); } string varName = forString.Substring(0,index); ParsingScript forScript = new ParsingScript(forString); Variable arrayValue = forScript.ExecuteFrom(index + 1); int cycles = arrayValue.TotalElements(); if (cycles == 0) { SkipBlock(script); return; } int startForCondition = script.Pointer; for (int i = 0; i < cycles; i++) { script.Pointer = startForCondition; Variable current = arrayValue.GetValue(i); ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(current)); Variable result = ProcessBlock(script); if (result.IsReturn || result.Type == Variable.VarType.BREAK) { //script.Pointer = startForCondition; //SkipBlock(script); //return; break; } } script.Pointer = startForCondition; SkipBlock(script); }
protected override Variable Evaluate(ParsingScript script) { bool isList = false; List <Variable> args = Utils.GetArgs(script, Constants.START_ARG, Constants.END_ARG, out isList); Utils.CheckArgs(args.Count, 3, m_name); string varName = Utils.GetSafeString(args, 0); Variable lines = Utils.GetSafeVariable(args, 1); int fromLine = Utils.GetSafeInt(args, 2); string sepStr = Utils.GetSafeString(args, 3, "\t"); if (sepStr == "\\t") { sepStr = "\t"; } char[] sep = sepStr.ToCharArray(); var function = ParserFunction.GetFunction(varName); Variable allTokensVar = new Variable(Variable.VarType.ARRAY); for (int counter = fromLine; counter < lines.Tuple.Count; counter++) { Variable lineVar = lines.Tuple[counter]; Variable toAdd = new Variable(counter - fromLine); string line = lineVar.AsString(); var tokens = line.Split(sep); Variable tokensVar = new Variable(Variable.VarType.ARRAY); foreach (string token in tokens) { tokensVar.Tuple.Add(new Variable(token)); } allTokensVar.Tuple.Add(tokensVar); } ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(allTokensVar)); return(Variable.EmptyInstance); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.NEXT_OR_END_ARRAY); Utils.CheckNotEnd(script, Constants.CONTAINS); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable currentValue = func.GetValue(script); // 3. Get the variable to add. Variable item = Utils.GetItem(script); // 4. Add it to the tuple. currentValue.AddVariable(item); ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(currentValue)); return(currentValue); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.NEXT_OR_END_ARRAY); Utils.CheckNotEnd(script, m_name); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable currentValue = func.GetValue(script); Utils.CheckArray(currentValue, varName); // 3. Get the variable to remove. Variable item = Utils.GetItem(script); bool removed = currentValue.Tuple.Remove(item); ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(currentValue)); return(new Variable(removed)); }
internal async Task <Variable> ProcessTryAsync(ParsingScript script) { int startTryCondition = script.Pointer - 1; int currentStackLevel = ParserFunction.GetCurrentStackLevel(); Exception exception = null; Variable result = null; bool alreadyInTryBlock = script.InTryBlock; script.InTryBlock = true; try { result = await ProcessBlockAsync(script); } catch (Exception exc) { exception = exc; } finally { script.InTryBlock = alreadyInTryBlock; } if (exception != null || result.IsReturn || result.Type == Variable.VarType.BREAK || result.Type == Variable.VarType.CONTINUE) { // We are here from the middle of the try-block either because // an exception was thrown or because of a Break/Continue. Skip it. script.Pointer = startTryCondition; SkipBlock(script); } string catchToken = Utils.GetNextToken(script); script.Forward(); // skip opening parenthesis // The next token after the try block must be a catch. if (Constants.CATCH != catchToken) { throw new ArgumentException("Expecting a 'catch()' but got [" + catchToken + "]"); } string exceptionName = Utils.GetNextToken(script); script.Forward(); // skip closing parenthesis if (exception != null) { string excStack = CreateExceptionStack(exceptionName, currentStackLevel); ParserFunction.InvalidateStacksAfterLevel(currentStackLevel); GetVarFunction excMsgFunc = new GetVarFunction(new Variable(exception.Message)); ParserFunction.AddGlobalOrLocalVariable(exceptionName, excMsgFunc); GetVarFunction excStackFunc = new GetVarFunction(new Variable(excStack)); ParserFunction.AddGlobalOrLocalVariable(exceptionName + ".Stack", excStackFunc); result = await ProcessBlockAsync(script); ParserFunction.PopLocalVariable(exceptionName); } else { SkipBlock(script); } SkipRestBlocks(script); return(result); }