protected override Parser.Result Evaluate(string data, ref int from) { // 1. Get the name of the variable. string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Couldn't append variable"); } // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Parser.Result currentValue = func.GetValue(data, ref from); // 3. Get the value to be looked for. Parser.Result searchValue = Utils.GetItem(data, ref from); // 4. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string basePart = currentValue.String != null ? currentValue.String : currentValue.Value.ToString(); string search = searchValue.String != null ? searchValue.String : searchValue.Value.ToString(); int result = basePart.IndexOf(search); return(new Parser.Result(result, null)); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 2, m_name, true); string varName = args[0].AsString(); // 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 = args[1]; bool removed = currentValue.Tuple.Remove(item); ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(currentValue)); return(new Variable(removed)); }
protected override Parser.Result Evaluate(string data, ref int from) { // 1. Get the name of the variable. string varName = Utils.GetToken(data, ref from, Constants.END_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Couldn't get variable"); } // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Parser.Result currentValue = func.GetValue(data, ref from); // 3. Take either the length of the underlying tuple or // string part if it is defined, // or the numerical part converted to a string otherwise. int size = currentValue.Tuple != null ? currentValue.Tuple.Count : currentValue.String != null ? currentValue.String.Length : currentValue.Value.ToString().Length; Parser.Result newValue = new Parser.Result(size); return(newValue); }
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); Utils.CheckNonNegativeInt(item); currentValue.Tuple.RemoveAt(item.AsInt()); ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(currentValue)); 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. List <Variable> arrayIndices = Utils.GetArrayIndices(ref varName); ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable currentValue = func.GetValue(script); // 2b. Special dealings with arrays: Variable query = arrayIndices.Count > 0 ? Utils.ExtractArrayElement(currentValue, arrayIndices) : currentValue; // 3. Get the value to be looked for. Variable searchValue = Utils.GetItem(script); Utils.CheckNotEnd(script, Constants.CONTAINS); // 4. Check if the value to search for exists. bool exists = query.Exists(searchValue, true /* notEmpty */); script.MoveBackIf(Constants.START_GROUP); return(new Variable(exists)); }
protected override Parser.Result Evaluate(string data, ref int from) { // 1. Get the name of the variable. string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Couldn't append variable"); } // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Parser.Result currentValue = func.GetValue(data, ref from); // 3. Get the value to be added or appended. Parser.Result newValue = Utils.GetItem(data, ref from); // 4. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string arg1 = currentValue.String != null ? currentValue.String : currentValue.Value.ToString(); string arg2 = newValue.String != null ? newValue.String : newValue.Value.ToString(); // 5. The variable becomes a string after adding a string to it. newValue.Reset(); newValue.String = arg1 + arg2; ParserFunction.AddFunction(varName, new GetVarFunction(newValue)); return(newValue); }
protected override Variable Evaluate(ParsingScript script) { Variable varValue = Utils.GetItem(script); // Check if the variable to be set has the form of x[a][b]..., // meaning that this is an array element. List <Variable> arrayIndices = Utils.GetArrayIndices(ref m_name); if (arrayIndices.Count == 0) { ParserFunction.AddGlobalOrLocalVariable(m_name, new GetVarFunction(varValue)); return(varValue); } Variable array; ParserFunction pf = ParserFunction.GetFunction(m_name); if (pf != null) { array = pf.GetValue(script); } else { array = new Variable(); } ExtendArray(array, arrayIndices, 0, varValue); ParserFunction.AddGlobalOrLocalVariable(m_name, new GetVarFunction(array)); return(array); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.END_ARG_ARRAY); Utils.CheckNotEnd(script, m_name); List <Variable> arrayIndices = Utils.GetArrayIndices(ref varName); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable currentValue = func.GetValue(script); Variable element = currentValue; // 2b. Special case for an array. if (arrayIndices.Count > 0)// array element { element = Utils.ExtractArrayElement(currentValue, arrayIndices); script.MoveForwardIf(Constants.END_ARRAY); } // 3. Convert type to string. string type = Constants.TypeToString(element.Type); script.MoveForwardIf(Constants.END_ARG, Constants.SPACE); Variable newValue = new Variable(type); return(newValue); }
protected override Variable Evaluate(string data, ref int from) { // 1. Получете името на променливата. string varName = Utils.GetToken(data, ref from, Constants.END_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Променливата не можа да се получи"); } // 2. Получете текущата стойност на променливата. ParserFunction func = ParserFunction.GetFunction(varName); Variable currentValue = func.GetValue(data, ref from); // 3. Вземете дължината на основната тона или // низовата част, ако е дефинирана, // или цифровата част, превърната в низ по друг начин. int size = currentValue.Tuple != null ? currentValue.Tuple.Count : currentValue.AsString().Length; Utils.MoveForwardIf(data, ref from, Constants.END_ARG, Constants.SPACE); Variable newValue = new Variable(size); return(newValue); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.NEXT_ARG_ARRAY); Utils.CheckNotEmpty(script, varName, m_name); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName, script); Variable currentValue = func.GetValue(script); // 3. Get the value to be added or appended. Variable newValue = Utils.GetItem(script); // 4. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string arg1 = currentValue.AsString(); string arg2 = newValue.AsString(); // 5. The variable becomes a string after adding a string to it. newValue.Reset(); newValue.String = arg1 + arg2; ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(newValue)); return(newValue); }
public static Result LoadAndCalculate(string data, ref int from, char[] to) { if (from >= data.Length || to.Contains(data[from])) { return(new Result()); } List <Cell> listToMerge = new List <Cell>(16); StringBuilder item = new StringBuilder(); do { // Main processing cycle of the first part. char ch = data[from++]; if (StillCollecting(item.ToString(), ch, to)) { // The char still belongs to the previous operand. item.Append(ch); if (from < data.Length && !to.Contains(data[from])) { continue; } } // We are done getting the next token. The getValue() call below may // recursively call loadAndCalculate(). This will happen if extracted // item is a function or if the next item is starting with a START_ARG '('. string parsingItem = item.ToString(); ParserFunction func = new ParserFunction(data, ref from, parsingItem, ch); Result current = func.GetValue(data, ref from); if (Double.IsNaN(current.Value)) { // If there is no numerical result, we are not in a math expression. return(current); } char action = ValidAction(ch) ? ch : UpdateAction(data, ref from, ch, to); listToMerge.Add(new Cell(current.Value, action)); item.Clear(); } while (from < data.Length && !to.Contains(data[from])); if (from < data.Length && data[from] == Constants.END_ARG) { // This happens when called recursively inside of the math expression: // move one char forward. from++; } Cell baseCell = listToMerge[0]; int index = 1; Result result = new Result { Value = Merge(baseCell, ref index, listToMerge) }; return(result); }
protected override Variable Evaluate(string data, ref int from) { Variable varValue = Utils.GetItem(data, ref from); // Специален случай за добавяне на низ (или число) към низ. while (varValue.Type != Variable.VarType.NUMBER && from > 0 && data[from - 1] == '+') { Variable addition = Utils.GetItem(data, ref from); varValue.String += addition.AsString(); } // Проверете дали променливата, която трябва да бъде настроена, има формата на x (0), // означава, че това е масив елемент. int arrayIndex = Utils.ExtractArrayElement(ref _name); if (arrayIndex < 0) { ParserFunction.AddGlobalOrLocalVariable(_name, new GetVarFunction(varValue)); return(varValue); } Variable currentValue; ParserFunction pf = ParserFunction.GetFunction(_name); if (pf != null) { currentValue = pf.GetValue(data, ref from); } else { currentValue = new Variable(); } List <Variable> tuple = currentValue.Tuple == null ? new List <Variable>() : currentValue.Tuple; if (tuple.Count > arrayIndex) { tuple[arrayIndex] = varValue; } else { for (int i = tuple.Count; i < arrayIndex; i++) { tuple.Add(Variable.EmptyInstance); } tuple.Add(varValue); } currentValue.Tuple = tuple; ParserFunction.AddGlobalOrLocalVariable(_name, new GetVarFunction(currentValue)); return(currentValue); }
public static Variable Calculate(string functionName, string argsStr) { ParsingScript script = new ParsingScript(argsStr); string action = ""; ParserFunction func = new ParserFunction(script, functionName, Constants.EMPTY, ref action); Variable current = func.GetValue(script); return(current); }
public static Variable GetVariable(string varName, ParsingScript script) { ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable varValue = func.GetValue(script); return(varValue); }
public static Variable GetVariable(string varName, ParsingScript script, bool testNull = true) { ParserFunction func = ParserFunction.GetFunction(varName, script); if (!testNull && func == null) { return(null); } Utils.CheckNotNull(varName, func, script); Variable varValue = func.GetValue(script); Utils.CheckNotNull(varValue, varName, script); return(varValue); }
protected override Variable Evaluate(ParsingScript script) { bool prefix = string.IsNullOrWhiteSpace(m_name); if (prefix)// If it is a prefix we do not have the variable name yet. { m_name = Utils.GetToken(script, Constants.TOKEN_SEPARATION); } // Value to be added to the variable: int valueDelta = m_action == Constants.INCREMENT ? 1 : -1; int returnDelta = prefix ? valueDelta : 0; // Check if the variable to be set has the form of x[a][b], // meaning that this is an array element. double newValue = 0; List <Variable> arrayIndices = Utils.GetArrayIndices(ref m_name); ParserFunction func = ParserFunction.GetFunction(m_name); Utils.CheckNotNull(m_name, func); Variable currentValue = func.GetValue(script); if (arrayIndices.Count > 0 || script.TryCurrent() == Constants.START_ARRAY) { if (prefix) { string tmpName = m_name + script.Rest; int delta = 0; arrayIndices = Utils.GetArrayIndices(ref tmpName, ref delta); script.Forward(Math.Max(0, delta - tmpName.Length)); } Variable element = Utils.ExtractArrayElement(currentValue, arrayIndices); script.MoveForwardIf(Constants.END_ARRAY); newValue = element.Value + returnDelta; element.Value += valueDelta; } else // A normal variable. { newValue = currentValue.Value + returnDelta; currentValue.Value += valueDelta; } ParserFunction.AddGlobalOrLocalVariable(m_name, new GetVarFunction(currentValue)); return(new Variable(newValue)); }
public static Variable GetVar(string paramName, ParsingScript script = null) { if (script == null) { script = new ParsingScript(""); } ParserFunction function = ParserFunction.GetFunction(paramName); if (function == null) { throw new ArgumentException("Variable [" + paramName + "] not found."); } Variable result = function.GetValue(script); return(result); }
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); }
protected override Parser.Result Evaluate(string data, ref int from) { string substring; // 1. Get the name of the variable. string varName = Utils.GetToken(data, ref from, Constants.NEXT_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Couldn't get variable"); } // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Parser.Result currentValue = func.GetValue(data, ref from); // 3. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string arg = currentValue.String != null ? currentValue.String : currentValue.Value.ToString(); // 4. Get the initial index of the substring. bool lengthAvailable = Utils.SeparatorExists(data, from); Parser.Result init = Utils.GetItem(data, ref from, true /* expectInt */); // 5. Get the length of the substring if available. if (lengthAvailable) { Parser.Result length = Utils.GetItem(data, ref from, true /* expectInt */); if (init.Value + length.Value > arg.Length) { throw new ArgumentException("The total substring length is larger than [" + arg + "]"); } substring = arg.Substring((int)init.Value, (int)length.Value); } else { substring = arg.Substring((int)init.Value); } Parser.Result newValue = new Parser.Result(Double.NaN, substring); return(newValue); }
protected override Variable Evaluate(ParsingScript script) { string substring; // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.NEXT_ARG_ARRAY); Utils.CheckNotEmpty(script, varName, m_name); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Variable currentValue = func.GetValue(script); // 3. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string arg = currentValue.AsString(); // 4. Get the initial index of the substring. Variable init = Utils.GetItem(script); Utils.CheckNonNegativeInt(init); // 5. Get the length of the substring if available. bool lengthAvailable = Utils.SeparatorExists(script); if (lengthAvailable) { Variable length = Utils.GetItem(script); Utils.CheckPosInt(length); if (init.Value + length.Value > arg.Length) { throw new ArgumentException("The total substring length is larger than [" + arg + "]"); } substring = arg.Substring((int)init.Value, (int)length.Value); } else { substring = arg.Substring((int)init.Value); } Variable newValue = new Variable(substring); return(newValue); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.END_ARG_ARRAY); Utils.CheckNotEmpty(script, varName, m_name); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Variable currentValue = func.GetValue(script); // 3. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string arg = currentValue.AsString(); Variable newValue = new Variable(arg.ToLower()); return(newValue); }
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); }
public static Variable GetVariable(string varName, ParsingScript script = null, bool testNull = true) { varName = varName.ToLower(); if (script == null) { script = new ParsingScript(""); } ParserFunction func = ParserFunction.GetVariable(varName, script); if (!testNull && func == null) { return(null); } Utils.CheckNotNull(varName, func, script); Variable varValue = func.GetValue(script); Utils.CheckNotNull(varValue, varName, script); return(varValue); }
protected override Parser.Result Evaluate(string data, ref int from) { // 1. Get the name of the variable. string varName = Utils.GetToken(data, ref from, Constants.END_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Couldn't get variable"); } // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Parser.Result currentValue = func.GetValue(data, ref from); // 3. Take either the string part if it is defined, // or the numerical part converted to a string otherwise. string arg = currentValue.String ?? currentValue.Value.ToString(); Parser.Result newValue = new Parser.Result(Double.NaN, arg.ToLower()); return(newValue); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.NEXT_ARG_ARRAY); Utils.CheckNotEmpty(script, varName, m_name); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Variable currentValue = func.GetValue(script); // 3. Get the value to be looked for. Variable searchValue = Utils.GetItem(script); // 4. Apply the corresponding C# function. string basePart = currentValue.AsString(); string search = searchValue.AsString(); int result = basePart.IndexOf(search); return(new Variable(result)); }
protected override Variable Evaluate(ParsingScript script) { // 1. Get the name of the variable. string varName = Utils.GetToken(script, Constants.END_ARG_ARRAY); Utils.CheckNotEnd(script, m_name); List <Variable> arrayIndices = Utils.GetArrayIndices(ref varName); // 2. Get the current value of the variable. ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable currentValue = func.GetValue(script); Variable element = currentValue; // 2b. Special case for an array. if (arrayIndices.Count > 0)// array element { element = Utils.ExtractArrayElement(currentValue, arrayIndices); script.MoveForwardIf(Constants.END_ARRAY); } // 3. Take either the length of the underlying tuple or // string part if it is defined, // or the numerical part converted to a string otherwise. int size = element.Type == Variable.VarType.ARRAY ? element.Tuple.Count : element.AsString().Length; script.MoveForwardIf(Constants.END_ARG, Constants.SPACE); Variable newValue = new Variable(size); return(newValue); }
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); }
// Calculate // Изчисли private static List <Variable> Calculate(string data, ref int from, char[] to) { List <Variable> listToMerge = new List <Variable>(); // 32 // Console.WriteLine(forum); if (from >= data.Length || to.Contains(data[from])) { listToMerge.Add(Variable.EmptyInstance); return(listToMerge); } StringBuilder item = new StringBuilder(); int negated = 0; // отказване bool inQuotes = false; // в Цитати do { // Основен цикъл на обработка на първата част. // string negateSymbol = Utils.IsNotSign(data.Substring(from)); // // //Console.WriteLine(negateSymbol); // // if (negateSymbol != null) // { // negated++; // from += negateSymbol.Length; // continue; // } char ch = data[from++]; inQuotes = ch == Constants.QUOTE && (from == 0 || data[from] != '\\') ? !inQuotes : inQuotes; string action = null; bool keepCollecting = inQuotes || StillCollecting(item.ToString(), to, data, from, ref action); //Console.WriteLine(ch); if (keepCollecting) { // Char отново принадлежи към предишния операнд. item.Append(ch); if (from < data.Length && (inQuotes || !to.Contains(data[from]))) { continue; } } string parsingItem = item.ToString(); // CheckConsistency(parsingItem, listToMerge, data, from); Utils.MoveForwardIf(data, ref from, Constants.SPACE); if (action != null && action.Length > 1) { from += (action.Length - 1); } // Ние сме готови да получим следващия знак. Призивът getValue () може да е по-долу // рекурсивно извиква loadAndCalculate (). Това ще стане, ако се извлече // елементът е функция или ако следващият елемент започва с START_ARG '('. ParserFunction func = new ParserFunction(data, ref from, parsingItem, ch, ref action); Variable current = func.GetValue(data, ref from); if (negated > 0 && current.Type == Variable.VarType.NUMBER) { // Ако има знак NOT, това е булев. // Използвайте XOR (вярно, ако точно един от аргументите е вярно). bool boolRes = !((negated % 2 == 0) ^ Convert.ToBoolean(current.Value)); current = new Variable(Convert.ToDouble(boolRes)); negated = 0; } if (action == null) { action = UpdateAction(data, ref from, to); } char next = from < data.Length ? data[from] : Constants.EMPTY; bool done = listToMerge.Count == 0 && ((action == Constants.END_ARG_STR && current.Type != Variable.VarType.NUMBER) || next == Constants.END_STATEMENT); if (done) { // Ако няма числен резултат, ние не сме в математически израз. listToMerge.Add(current); return(listToMerge); } Variable cell = new Variable(current); cell.Action = action; listToMerge.Add(cell); item.Clear(); } while (from < data.Length && (inQuotes || !to.Contains(data[from]))); // Това се случва, когато се нарича рекурсивно вътре в математическия израз: Utils.MoveForwardIf(data, ref from, Constants.END_ARG); return(listToMerge); }
private 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); } StringBuilder item = new StringBuilder(); int arrayIndexDepth = 0; bool inQuotes = false; int negated = 0; string rest = script.Rest; //if (rest == "b[a[0]];") { // int stop = 1; //} do // Main processing cycle of the first part. { string negateSymbol = Utils.IsNotSign(script.Rest); if (negateSymbol != null && !inQuotes) { negated++; script.Forward(negateSymbol.Length); continue; } char ch = script.CurrentAndForward(); CheckQuotesIndices(script, ch, ref inQuotes, ref arrayIndexDepth); string action = null; bool keepCollecting = inQuotes || arrayIndexDepth > 0 || StillCollecting(item.ToString(), to, script, ref action); if (keepCollecting) { // The char still belongs to the previous operand. item.Append(ch); bool goForMore = script.StillValid() && (inQuotes || arrayIndexDepth > 0 || !to.Contains(script.Current)); if (goForMore) { continue; } } if (SkipOrAppendIfNecessary(item, ch, to)) { continue; } string token = item.ToString(); bool ternary = UpdateIfTernary(script, token, ch, ref listToMerge); if (ternary) { return(listToMerge); } CheckConsistency(token, listToMerge, script); script.MoveForwardIf(Constants.SPACE); if (action != null && action.Length > 1) { script.Forward(action.Length - 1); } // We are done getting the next token. The getValue() call below may // recursively call loadAndCalculate(). 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); current.ParsingToken = token; 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 (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) { 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(listToMerge); } Variable cell = current.Clone(); cell.Action = action; bool addIt = UpdateIfBool(script, ref cell, ref listToMerge); if (addIt) { listToMerge.Add(cell); } item.Clear(); } 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); }