static string CreateVariableEntry(Variable var, string name, bool isLocal = false) { try { string value = var.AsString(true, true, 16); string localGlobal = isLocal ? "0" : "1"; string varData = name + ":" + localGlobal + ":" + Constants.TypeToString(var.Type).ToLower() + ":" + value; return(varData.Trim()); } catch (Exception exc) { // TODO: Clean up not used objects. bool removed = isLocal ? PopLocalVariable(name) : RemoveGlobal(name); Console.WriteLine("Object {0} is probably dead ({1}): {2}. Removing it.", name, removed, exc); return(null); } }
static void MergeStrings(Variable leftCell, Variable rightCell) { switch (leftCell.Action) { case "+": leftCell.String = leftCell.AsString() + rightCell.AsString(); break; case "<": string arg1 = leftCell.AsString(); string arg2 = rightCell.AsString(); leftCell.Value = Convert.ToDouble(string.Compare(arg1, arg2) < 0); break; case ">": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) > 0); break; case "<=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) <= 0); break; case ">=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) >= 0); break; case "==": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) == 0); break; case "!=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) != 0); break; case ")": break; default: throw new ArgumentException("Can't perform action [" + leftCell.Action + "] on strings"); } }
// Merge Strings // Сливане на Strings private static void MergeStrings(Variable leftCell, Variable rightCell) { switch (leftCell.Action) { case "+": leftCell.String += rightCell.AsString(); break; case "<": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.String, rightCell.String) < 0); break; case ">": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.String, rightCell.String) > 0); break; case "<=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.String, rightCell.String) <= 0); break; case ">=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.String, rightCell.String) >= 0); break; case "==": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.String, rightCell.String) == 0); break; case "!=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.String, rightCell.String) != 0); break; default: throw new ArgumentException("Can't perform action [" + leftCell.Action + "] on strings"); } }
async Task <string> DebugScript() { if (string.IsNullOrWhiteSpace(m_script)) { return(null); } m_debugging = new ParsingScript(m_script, 0, m_char2Line); m_debugging.OriginalScript = m_script; Variable result = Variable.EmptyInstance; while (m_debugging.Pointer < m_script.Length) { result = await ProcessNext(); } return(result.AsString()); }
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) { 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) { 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 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); }
public static double GetSafeDouble(List <Variable> args, int index, double defaultValue = 0.0) { if (args.Count <= index) { return(defaultValue); } Variable numberVar = args[index]; if (numberVar.Type != Variable.VarType.NUMBER) { double num; if (!CanConvertToDouble(numberVar.String, out num)) { throw new ArgumentException("Expected a double instead of [" + numberVar.AsString() + "]"); } return(num); } return(numberVar.AsDouble()); }
public static Variable ExtractArrayElement(Variable array, List <Variable> indices) { Variable currLevel = array; for (int i = 0; i < indices.Count; i++) { Variable index = indices [i]; int arrayIndex = currLevel.GetArrayIndex(index); int tupleSize = currLevel.Tuple != null ? currLevel.Tuple.Count : 0; if (arrayIndex < 0 || arrayIndex >= tupleSize) { throw new ArgumentException("Unknown index [" + index.AsString() + "] for tuple of size " + tupleSize); } currLevel = currLevel.Tuple [arrayIndex]; } return(currLevel); }
public static int GetSafeInt(List <Variable> args, int index, int defaultValue = 0) { if (args.Count <= index) { return(defaultValue); } Variable numberVar = args[index]; if (numberVar.Type != Variable.VarType.NUMBER) { int num; if (!Int32.TryParse(numberVar.String, NumberStyles.Number, CultureInfo.InvariantCulture, out num)) { throw new ArgumentException("Expected an integer instead of [" + numberVar.AsString() + "]"); } return(num); } return(numberVar.AsInt()); }
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); }
public void Sort() { if (Tuple == null || Tuple.Count <= 1) { return; } List <double> numbers = new List <double>(); List <string> strings = new List <string>(); for (int i = 0; i < Tuple.Count; i++) { Variable arg = Tuple[i]; if (arg.Tuple != null) { arg.Sort(); } else if (arg.Type == VarType.NUMBER) { numbers.Add(arg.AsDouble()); } else { strings.Add(arg.AsString()); } } List <Variable> newTuple = new List <Variable>(Tuple.Count); numbers.Sort(); strings.Sort(); for (int i = 0; i < numbers.Count; i++) { newTuple.Add(new Variable(numbers[i])); } for (int i = 0; i < strings.Count; i++) { newTuple.Add(new Variable(strings[i])); } Tuple = newTuple; }
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); }
public virtual string AsString(bool isList = true, bool sameLine = true) { if (Type == VarType.NUMBER) { return(Value.ToString()); } if (Type == VarType.STRING) { return(m_string == null ? "" : m_string); } if (Type == VarType.NONE || m_tuple == null) { return(string.Empty); } StringBuilder sb = new StringBuilder(); if (isList) { sb.Append(Constants.START_GROUP.ToString() + (sameLine ? "" : Environment.NewLine)); } for (int i = 0; i < m_tuple.Count; i++) { Variable arg = m_tuple[i]; sb.Append(arg.AsString(isList, sameLine)); if (i != m_tuple.Count - 1) { sb.Append(sameLine ? " " : Environment.NewLine); } } if (isList) { sb.Append(Constants.END_GROUP.ToString() + (sameLine ? " " : Environment.NewLine)); } return(sb.ToString()); }
private static void ProcessScript(string script, string filename = "") { s_PrintingCompleted = false; string errorMsg = null; Variable result = null; try { result = System.Threading.Tasks.Task.Run(() => Interpreter.Instance.Process(script, filename)).Result; //result = Interpreter.Instance.Process(script); } catch (Exception exc) { errorMsg = exc.InnerException != null ? exc.InnerException.Message : exc.Message; ParserFunction.InvalidateStacksAfterLevel(0); } if (!s_PrintingCompleted) { string output = Interpreter.Instance.Output; if (!string.IsNullOrWhiteSpace(output)) { Console.WriteLine(output); } else if (result != null) { output = result.AsString(false, false); if (!string.IsNullOrWhiteSpace(output)) { Console.WriteLine(output); } } } if (!string.IsNullOrWhiteSpace(errorMsg)) { Utils.PrintColor(errorMsg + Environment.NewLine, ConsoleColor.Red); errorMsg = string.Empty; } }
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)); }
public static double GetSafeDouble(List <Variable> args, int index, double defaultValue = 0.0) { if (args.Count <= index) { return(defaultValue); } Variable numberVar = args[index]; if (numberVar.Type != Variable.VarType.NUMBER) { double num; if (!Double.TryParse(numberVar.String, NumberStyles.Number | NumberStyles.AllowExponent | NumberStyles.Float, CultureInfo.InvariantCulture, out num)) { throw new ArgumentException("Expected a double instead of [" + numberVar.AsString() + "]"); } return(num); } return(numberVar.AsDouble()); }
private static int ExtendArrayHelper(Variable parent, Variable indexVar) { parent.SetAsArray(); int arrayIndex = parent.GetArrayIndex(indexVar); if (arrayIndex < 0) { // This is not a "normal index" but a new string for the dictionary. string hash = indexVar.AsString(); arrayIndex = parent.SetHashVariable(hash, Variable.NewEmpty()); return(arrayIndex); } if (parent.Tuple.Count <= arrayIndex) { for (int i = parent.Tuple.Count; i <= arrayIndex; i++) { parent.Tuple.Add(Variable.NewEmpty()); } } return(arrayIndex); }
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); }
public int GetArrayIndex(Variable indexVar) { if (this.Type != VarType.ARRAY) { return(-1); } if (indexVar.Type == VarType.NUMBER) { Utils.CheckNonNegativeInt(indexVar); return((int)indexVar.Value); } string hash = indexVar.AsString(); int ptr = m_tuple.Count; if (m_dictionary.TryGetValue(hash, out ptr) && ptr < m_tuple.Count) { return(ptr); } return(-1); }
string ProcessRepl(string repl) { ReplMode = true; Dictionary <int, int> char2Line; string script = Utils.ConvertToScript(repl, out char2Line); ParsingScript tempScript = new ParsingScript(script, 0, char2Line); tempScript.OriginalScript = repl; tempScript.Debugger = this; Variable result = null; try { while (tempScript.Pointer < script.Length) { result = DebuggerUtils.Execute(tempScript); tempScript.GoToNextStatement(); } } catch (Exception exc) { return("Exception thrown: " + exc.Message); } finally { ReplMode = false; } string stringRes = Output + "\n"; stringRes += result == null ? "" : result.AsString(); return(stringRes); }
public virtual string AsString(bool isList = true, bool sameLine = true, int maxCount = -1) { if (Type == VarType.NUMBER) { return(Value.ToString()); } if (Type == VarType.STRING) { return(m_string == null ? "" : m_string); } if (Type == VarType.OBJECT) { return(ObjectToString()); } StringBuilder sb = new StringBuilder(); if (Type == VarType.ENUM) { sb.Append(Constants.START_GROUP.ToString() + " "); foreach (string key in m_propertyMap.Keys) { sb.Append(key + " "); } sb.Append(Constants.END_GROUP.ToString()); return(sb.ToString()); } if (Type == VarType.NONE || m_tuple == null) { return(string.Empty); } if (isList) { sb.Append(Constants.START_GROUP.ToString() + (sameLine ? "" : Environment.NewLine)); } int count = maxCount < 0 ? m_tuple.Count : Math.Min(maxCount, m_tuple.Count); int i = 0; if (m_dictionary.Count > 0) { count = maxCount < 0 ? m_dictionary.Count : Math.Min(maxCount, m_dictionary.Count); foreach (KeyValuePair <string, int> entry in m_dictionary) { if (entry.Value >= 0 || entry.Value < m_tuple.Count) { string value = m_tuple[entry.Value].AsString(isList, sameLine, maxCount); string realKey = entry.Key; m_keyMappings.TryGetValue(entry.Key.ToLower(), out realKey); sb.Append("\"" + realKey + "\" : " + value); if (i++ < count - 1) { sb.Append(sameLine ? ", " : Environment.NewLine); } else { break; } } } } else { for (; i < count; i++) { Variable arg = m_tuple[i]; sb.Append(arg.AsString(isList, sameLine, maxCount)); if (i != count - 1) { sb.Append(sameLine ? ", " : Environment.NewLine); } } } if (count < m_tuple.Count) { sb.Append(" ..."); } if (isList) { sb.Append(Constants.END_GROUP.ToString() + (sameLine ? "" : Environment.NewLine)); } return(sb.ToString()); }
static void MergeStrings(Variable leftCell, Variable rightCell, ParsingScript script) { switch (leftCell.Action) { case "+": leftCell.String = leftCell.AsString() + rightCell.AsString(); break; case "<": string arg1 = leftCell.AsString(); string arg2 = rightCell.AsString(); leftCell.Value = Convert.ToDouble(string.Compare(arg1, arg2) < 0); break; case ">": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) > 0); break; case "<=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) <= 0); break; case ">=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) >= 0); break; case "===": leftCell.Value = Convert.ToDouble( (leftCell.Type == rightCell.Type && leftCell.AsString() == rightCell.AsString()) || (leftCell.Type == Variable.VarType.UNDEFINED && rightCell.AsString() == Constants.UNDEFINED) || (rightCell.Type == Variable.VarType.UNDEFINED && leftCell.AsString() == Constants.UNDEFINED)); break; case "!==": leftCell.Value = Convert.ToDouble( leftCell.Type != rightCell.Type || leftCell.AsString() != rightCell.AsString()); break; case "==": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) == 0); break; case "!=": leftCell.Value = Convert.ToDouble( string.Compare(leftCell.AsString(), rightCell.AsString()) != 0); break; case ":": leftCell.SetHashVariable(leftCell.AsString(), rightCell); break; case ")": break; default: Utils.ThrowErrorMsg("Can't process operation [" + leftCell.Action + "] on strings.", script, leftCell.Action); break; } }
public Variable Translate(Variable aVariable) { return(new Variable(m_name + "_" + m_color + "_" + aVariable.AsString())); }
private static void MergeNumbers(Variable leftCell, Variable rightCell) { if (rightCell.Type != Variable.VarType.NUMBER) { rightCell.Value = rightCell.AsDouble(); } switch (leftCell.Action) { case "%": leftCell.Value %= rightCell.Value; break; case "*": leftCell.Value *= rightCell.Value; break; case "/": if (rightCell.Value == 0.0) { throw new ArgumentException("Division by zero"); } leftCell.Value /= rightCell.Value; break; case "+": if (rightCell.Type != Variable.VarType.NUMBER) { leftCell.String = leftCell.AsString() + rightCell.String; } else { leftCell.Value += rightCell.Value; } break; case "-": leftCell.Value -= rightCell.Value; break; case "<": leftCell.Value = Convert.ToDouble(leftCell.Value < rightCell.Value); break; case ">": leftCell.Value = Convert.ToDouble(leftCell.Value > rightCell.Value); break; case "<=": leftCell.Value = Convert.ToDouble(leftCell.Value <= rightCell.Value); break; case ">=": leftCell.Value = Convert.ToDouble(leftCell.Value >= rightCell.Value); break; case "==": leftCell.Value = Convert.ToDouble(leftCell.Value == rightCell.Value); break; case "!=": leftCell.Value = Convert.ToDouble(leftCell.Value != rightCell.Value); break; case "&": leftCell.Value = (int)leftCell.Value & (int)rightCell.Value; break; case "^": leftCell.Value = (int)leftCell.Value ^ (int)rightCell.Value; break; case "|": leftCell.Value = (int)leftCell.Value | (int)rightCell.Value; break; case "&&": leftCell.Value = Convert.ToDouble( Convert.ToBoolean(leftCell.Value) && Convert.ToBoolean(rightCell.Value)); break; case "||": leftCell.Value = Convert.ToDouble( Convert.ToBoolean(leftCell.Value) || Convert.ToBoolean(rightCell.Value)); break; } }
private static void MergeNumbers(Variable leftCell, Variable rightCell, ParsingScript script) { if (rightCell.Type != Variable.VarType.NUMBER) { rightCell.Value = rightCell.AsDouble(); } switch (leftCell.Action) { case "%": leftCell.Value %= rightCell.Value; break; case "*": leftCell.Value *= rightCell.Value; break; case "/": if (rightCell.Value == 0.0) { throw new ArgumentException("Division by zero"); } leftCell.Value /= rightCell.Value; break; case "+": if (rightCell.Type != Variable.VarType.NUMBER) { leftCell.String = leftCell.AsString() + rightCell.String; } else { leftCell.Value += rightCell.Value; } break; case "-": leftCell.Value -= rightCell.Value; break; case "<": leftCell.Value = Convert.ToDouble(leftCell.Value < rightCell.Value); break; case ">": leftCell.Value = Convert.ToDouble(leftCell.Value > rightCell.Value); break; case "<=": leftCell.Value = Convert.ToDouble(leftCell.Value <= rightCell.Value); break; case ">=": leftCell.Value = Convert.ToDouble(leftCell.Value >= rightCell.Value); break; case "==": leftCell.Value = Convert.ToDouble(leftCell.Value == rightCell.Value); break; case "!=": leftCell.Value = Convert.ToDouble(leftCell.Value != rightCell.Value); break; case "&": leftCell.Value = (int)leftCell.Value & (int)rightCell.Value; break; case "^": leftCell.Value = (int)leftCell.Value ^ (int)rightCell.Value; break; case "|": leftCell.Value = (int)leftCell.Value | (int)rightCell.Value; break; case "&&": leftCell.Value = Convert.ToDouble( Convert.ToBoolean(leftCell.Value) && Convert.ToBoolean(rightCell.Value)); break; case "||": leftCell.Value = Convert.ToDouble( Convert.ToBoolean(leftCell.Value) || Convert.ToBoolean(rightCell.Value)); break; case "**": leftCell.Value = Math.Pow(leftCell.Value, rightCell.Value); break; case ")": Utils.ThrowErrorMsg("Can't process last token [" + rightCell.Value + "] in the expression.", script, script.Current.ToString()); break; default: Utils.ThrowErrorMsg("Can't process operation [" + leftCell.Action + "] in the expression.", script, leftCell.Action); break; } }
public static string GetString(string paramName, ParsingScript script = null) { Variable result = GetVar(paramName, script); return(result.AsString()); }
Variable GetCoreProperty(string propName, ParsingScript script = null) { Variable result = Variable.EmptyInstance; if (m_propertyMap.TryGetValue(propName, out result) || m_propertyMap.TryGetValue(GetRealName(propName), out result)) { return(result); } else if (propName.Equals(Constants.OBJECT_PROPERTIES, StringComparison.OrdinalIgnoreCase)) { return(new Variable(GetProperties())); } else if (propName.Equals(Constants.OBJECT_TYPE, StringComparison.OrdinalIgnoreCase)) { return(new Variable((int)Type)); } else if (propName.Equals(Constants.SIZE, StringComparison.OrdinalIgnoreCase)) { return(new Variable(GetSize())); } else if (propName.Equals(Constants.UPPER, StringComparison.OrdinalIgnoreCase)) { return(new Variable(AsString().ToUpper())); } else if (propName.Equals(Constants.LOWER, StringComparison.OrdinalIgnoreCase)) { return(new Variable(AsString().ToLower())); } else if (propName.Equals(Constants.STRING, StringComparison.OrdinalIgnoreCase)) { return(new Variable(AsString())); } else if (propName.Equals(Constants.FIRST, StringComparison.OrdinalIgnoreCase)) { if (Tuple != null && Tuple.Count > 0) { return(Tuple[0]); } return(AsString().Length > 0 ? new Variable("" + AsString()[0]) : Variable.EmptyInstance); } else if (propName.Equals(Constants.LAST, StringComparison.OrdinalIgnoreCase)) { if (Tuple != null && Tuple.Count > 0) { return(Tuple.Last <Variable>()); } return(AsString().Length > 0 ? new Variable("" + AsString().Last <char>()) : Variable.EmptyInstance); } else if (script != null && propName.Equals(Constants.INDEX_OF, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); string search = Utils.GetSafeString(args, 0); int startFrom = Utils.GetSafeInt(args, 1, 0); string param = Utils.GetSafeString(args, 2, "no_case"); StringComparison comp = param.Equals("case", StringComparison.OrdinalIgnoreCase) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; return(new Variable(AsString().IndexOf(search, startFrom, comp))); } else if (script != null && propName.Equals(Constants.SUBSTRING, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); int startFrom = Utils.GetSafeInt(args, 0, 0); int length = Utils.GetSafeInt(args, 1, AsString().Length); length = Math.Min(length, AsString().Length - startFrom); return(new Variable(AsString().Substring(startFrom, length))); } else if (script != null && propName.Equals(Constants.REVERSE, StringComparison.OrdinalIgnoreCase)) { script.GetFunctionArgs(); if (Tuple != null) { Tuple.Reverse(); } else if (Type == VarType.STRING) { char[] charArray = AsString().ToCharArray(); Array.Reverse(charArray); String = new string(charArray); } return(this); } else if (script != null && propName.Equals(Constants.SORT, StringComparison.OrdinalIgnoreCase)) { script.GetFunctionArgs(); Sort(); return(this); } else if (script != null && propName.Equals(Constants.SPLIT, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); string sep = Utils.GetSafeString(args, 0, " "); var option = Utils.GetSafeString(args, 1); return(TokenizeFunction.Tokenize(AsString(), sep, option)); } else if (script != null && propName.Equals(Constants.JOIN, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); string sep = Utils.GetSafeString(args, 0, " "); if (Tuple == null) { return(new Variable(AsString())); } var join = string.Join(sep, Tuple); return(new Variable(join)); } else if (script != null && propName.Equals(Constants.ADD, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); Variable var = Utils.GetSafeVariable(args, 0); if (Tuple != null) { Tuple.Add(var); } else if (Type == VarType.NUMBER) { Value += var.AsDouble(); } else { String += var.AsString(); } return(var); } else if (script != null && propName.Equals(Constants.AT, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); int at = Utils.GetSafeInt(args, 0); if (Tuple != null && Tuple.Count > 0) { return(Tuple.Count > at ? Tuple[at] : Variable.EmptyInstance); } string str = AsString(); return(str.Length > at ? new Variable("" + str[at]) : Variable.EmptyInstance); } else if (script != null && propName.Equals(Constants.REPLACE, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 2, propName); string oldVal = Utils.GetSafeString(args, 0); string newVal = Utils.GetSafeString(args, 1); return(new Variable(AsString().Replace(oldVal, newVal))); } else if (propName.Equals(Constants.EMPTY_WHITE, StringComparison.OrdinalIgnoreCase)) { bool isEmpty = string.IsNullOrWhiteSpace(AsString()); return(new Variable(isEmpty)); } else if (script != null && propName.Equals(Constants.REPLACE_TRIM, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 2, propName); string currentValue = AsString(); for (int i = 0; i < args.Count; i += 2) { string oldVal = Utils.GetSafeString(args, i); string newVal = Utils.GetSafeString(args, i + 1); currentValue = currentValue.Replace(oldVal, newVal); } return(new Variable(currentValue.Trim())); } else if (script != null && propName.Equals(Constants.CONTAINS, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); string val = Utils.GetSafeString(args, 0); string param = Utils.GetSafeString(args, 1, "no_case"); StringComparison comp = param.Equals("case", StringComparison.OrdinalIgnoreCase) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; bool contains = false; if (Type == Variable.VarType.ARRAY) { string lower = val.ToLower(); contains = m_dictionary != null && m_dictionary.ContainsKey(lower); if (!contains && Tuple != null) { foreach (var item in Tuple) { if (item.AsString().Equals(val, comp)) { contains = true; break; } } } } else { contains = val != "" && AsString().IndexOf(val, comp) >= 0; } return(new Variable(contains)); } else if (script != null && propName.Equals(Constants.EQUALS, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); string val = Utils.GetSafeString(args, 0); string param = Utils.GetSafeString(args, 1, "no_case"); StringComparison comp = param.Equals("case", StringComparison.OrdinalIgnoreCase) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; return(new Variable(AsString().Equals(val, comp))); } else if (script != null && propName.Equals(Constants.STARTS_WITH, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); string val = Utils.GetSafeString(args, 0); string param = Utils.GetSafeString(args, 1, "no_case"); StringComparison comp = param.Equals("case", StringComparison.OrdinalIgnoreCase) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; return(new Variable(AsString().StartsWith(val, comp))); } else if (script != null && propName.Equals(Constants.ENDS_WITH, StringComparison.OrdinalIgnoreCase)) { List <Variable> args = script.GetFunctionArgs(); Utils.CheckArgs(args.Count, 1, propName); string val = Utils.GetSafeString(args, 0); string param = Utils.GetSafeString(args, 1, "no_case"); StringComparison comp = param.Equals("case", StringComparison.OrdinalIgnoreCase) ? StringComparison.CurrentCulture : StringComparison.CurrentCultureIgnoreCase; return(new Variable(AsString().EndsWith(val, comp))); } else if (script != null && propName.Equals(Constants.TRIM, StringComparison.OrdinalIgnoreCase)) { script.GetFunctionArgs(); return(new Variable(AsString().Trim())); } else if (propName.Equals(Constants.KEYS, StringComparison.OrdinalIgnoreCase)) { List <Variable> results = GetAllKeys(); return(new Variable(results)); } return(result); }
public static async Task <string> GetString(string paramName, ParsingScript script = null) { Variable result = await GetVar(paramName, script); return(result.AsString()); }