//Get Array Function public static ParserFunction GetArrayFunction(string name, ref int from, string action) { if (!string.IsNullOrWhiteSpace(action)) { return(null); } int arrayStart = name.IndexOf(Constants.START_ARRAY); if (arrayStart <= 0) { return(null); } int origLength = name.Length; int arrayIndex = Utils.ExtractArrayElement(ref name); if (arrayIndex < 0) { return(null); } ParserFunction pf = ParserFunction.GetFunction(name); if (pf == null) { return(null); } from -= (origLength - arrayStart - 1); return(pf); }
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 toAdd = Utils.GetSafeVariable(args, 1); string hash = Utils.GetSafeString(args, 2); var function = ParserFunction.GetFunction(varName); Variable mapVar = function != null?function.GetValue(script) : new Variable(Variable.VarType.ARRAY); mapVar.AddVariableToHash(hash, toAdd); for (int i = 3; i < args.Count; i++) { string hash2 = Utils.GetSafeString(args, 3); if (!string.IsNullOrWhiteSpace(hash2) && !hash2.Equals(hash, StringComparison.OrdinalIgnoreCase)) { mapVar.AddVariableToHash(hash2, toAdd); } } ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(mapVar)); 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, 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_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); }
static ParserFunction GetObjectFunction(string name, ParsingScript script) { if (script.CurrentClass != null && script.CurrentClass.Name == name) { script.Backward(name.Length + 1); return(new FunctionCreator()); } if (script.ClassInstance != null && (script.ClassInstance.PropertyExists(name) || script.ClassInstance.FunctionExists(name))) { name = script.ClassInstance.InstanceName + "." + name; } //int ind = name.LastIndexOf('.'); int ind = name.IndexOf('.'); if (ind <= 0) { return(null); } string baseName = name.Substring(0, ind); if (s_namespaces.ContainsKey(baseName)) { int ind2 = name.IndexOf('.', ind + 1); if (ind2 > 0) { ind = ind2; baseName = name.Substring(0, ind); } } string prop = name.Substring(ind + 1); ParserFunction pf = ParserFunction.GetFromNamespace(prop, baseName, script); if (pf != null) { return(pf); } pf = ParserFunction.GetVariable(baseName, script, true); if (pf == null || !(pf is GetVarFunction)) { pf = ParserFunction.GetFunction(baseName, script); if (pf == null) { pf = Utils.ExtractArrayElement(baseName); } } GetVarFunction varFunc = pf as GetVarFunction; if (varFunc == null) { return(null); } varFunc.PropertyName = prop; return(varFunc); }
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 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 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, 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 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 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); }
// Translation public void AddTranslation(NameValueCollection languageDictionary, string originalName) { string translation = languageDictionary[originalName]; if (string.IsNullOrWhiteSpace(translation)) { // Преводът не е предвиден за тази функция. return; } if (translation.IndexOfAny((" \t\r\n").ToCharArray()) >= 0) { throw new ArgumentException("Превод на [" + translation + "] съдържа бели полета"); } ParserFunction originalFunction = ParserFunction.GetFunction(originalName); ParserFunction.AddGlobal(translation, originalFunction); // Ако списъкът с функции, след които може да има интервал (освен скоби) // съдържа оригиналната функция, също добавете превод към списъка. if (Constants.FUNCT_WITH_SPACE.Contains(originalName)) { Constants.FUNCT_WITH_SPACE.Add(translation); } }
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); }
public static Variable GetVariable(string varName, ParsingScript script) { ParserFunction func = ParserFunction.GetFunction(varName); Utils.CheckNotNull(varName, func); Variable varValue = func.GetValue(script); return(varValue); }
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); }
Variable.VarType GetVariableType(string paramName) { if (IsNumber(paramName)) { return(Variable.VarType.NUMBER); } else if (IsString(paramName)) { return(Variable.VarType.STRING); } if (Constants.RESERVED.Contains(paramName) || Constants.TOKEN_SEPARATION_STR.Contains(paramName)) { return(Variable.VarType.NONE); } var functionReturnType = GetReturnType(paramName); if (functionReturnType != Variable.VarType.NONE) { return(functionReturnType); } Variable arg; if (m_argsMap.TryGetValue(paramName, out arg)) { return(arg.Type); } ParserFunction function = ParserFunction.GetFunction(paramName, m_parentScript); if (function == null) { return(Variable.VarType.NONE); } if (function is INumericFunction) { return(Variable.VarType.NUMBER); } else if (function is IStringFunction) { return(Variable.VarType.STRING); } else if (function is IArrayFunction) { return(Variable.VarType.ARRAY); } return(Variable.VarType.NONE); }
protected override Variable Evaluate(string data, ref int from) { bool prefix = string.IsNullOrWhiteSpace(_name); if (prefix) // Ако е префикс, все още нямаме име на променлива. { _name = Utils.GetToken(data, ref from, Constants.TOKEN_SEPARATION); } // Стойност, която трябва да се добави към променливата: int valueDelta = _action == Constants.INCREMENT ? 1 : -1; int returnDelta = prefix ? valueDelta : 0; // Проверете дали променливата, която трябва да бъде настроена, има формата на x (0), // означава, че това е масив елемент. double newValue = 0; int arrayIndex = Utils.ExtractArrayElement(ref _name); bool exists = ParserFunction.FunctionExists(_name); if (!exists) { throw new ArgumentException("Variable [" + _name + "] не съществува"); } Variable currentValue = ParserFunction.GetFunction(_name).GetValue(data, ref from); if (arrayIndex >= 0) // Променлива с индекс (масив елемент). { if (currentValue.Tuple == null) { throw new ArgumentException("Tuple [" + _name + "] не съществува"); } if (currentValue.Tuple.Count <= arrayIndex) { throw new ArgumentException("Tuple [" + _name + "] има само " + currentValue.Tuple.Count + " елементи"); } newValue = currentValue.Tuple[arrayIndex].Value + returnDelta; currentValue.Tuple[arrayIndex].Value += valueDelta; } else // Нормална променлива. { newValue = currentValue.Value + returnDelta; currentValue.Value += valueDelta; } Variable varValue = new Variable(newValue); ParserFunction.AddGlobalOrLocalVariable(_name, new GetVarFunction(currentValue)); return(varValue); }
static string TranslateScript(string script, string fromLang, string toLang, ParsingScript parentScript) { StringBuilder result = new StringBuilder(); StringBuilder item = new StringBuilder(); Dictionary <string, string> keywordsDict = KeywordsDictionary(fromLang, toLang); Dictionary <string, string> transDict = TranslationDictionary(fromLang, toLang); bool inQuotes = false; for (int i = 0; i < script.Length; i++) { char ch = script[i]; inQuotes = ch == Constants.QUOTE ? !inQuotes : inQuotes; if (inQuotes) { result.Append(ch); continue; } if (!Constants.TOKEN_SEPARATION.Contains(ch)) { item.Append(ch); continue; } if (item.Length > 0) { string token = item.ToString(); string translation = string.Empty; if (toLang == Constants.ENGLISH) { ParserFunction func = ParserFunction.GetFunction(token, parentScript); if (func != null) { translation = func.Name; } } if (string.IsNullOrEmpty(translation) && !keywordsDict.TryGetValue(token, out translation) && !transDict.TryGetValue(token, out translation)) { translation = token;//TryTranslit (fromLang, toLang, token); } result.Append(translation); item.Clear(); } result.Append(ch); } return(result.ToString()); }
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)); }
protected override Variable Evaluate(ParsingScript script) { string funcName = Utils.GetToken(script, Constants.TOKEN_SEPARATION); ParserFunction function = ParserFunction.GetFunction(funcName); CustomFunction custFunc = function as CustomFunction; Utils.CheckNotNull(funcName, custFunc); string body = Utils.BeautifyScript(custFunc.Body, custFunc.Header); Translation.PrintScript(body); return(new Variable(body)); }
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); Variable varValue = func.GetValue(script); Utils.CheckNotNull(varValue, varName); return(varValue); }
public static async Task <Variable> GetVariableAsync(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 = await func.GetValueAsync(script); Utils.CheckNotNull(varValue, varName, script); return(varValue); }
protected override Variable Evaluate(string data, ref int from) { // Стойност, която трябва да се добави към променливата: Variable valueB = Utils.GetItem(data, ref from); // Проверете дали променливата, която трябва да бъде настроена, има формата на x (0), // означава, че това е масив елемент. int arrayIndex = Utils.ExtractArrayElement(ref _name); bool exists = ParserFunction.FunctionExists(_name); if (!exists) { throw new ArgumentException("Променлив [" + _name + "] не съществува"); } Variable currentValue = ParserFunction.GetFunction(_name).GetValue(data, ref from); Variable valueA = currentValue; if (arrayIndex >= 0) // Променлива с индекс. { if (currentValue.Tuple == null) { throw new ArgumentException("Tuple [" + _name + "] не съществува"); } if (currentValue.Tuple.Count <= arrayIndex) { throw new ArgumentException("Tuple [" + _name + "] има само " + currentValue.Tuple.Count + " елементи"); } valueA = currentValue.Tuple[arrayIndex]; } if (valueA.Type == Variable.VarType.NUMBER) { NumberOperator(valueA, valueB, _action); } else { StringOperator(valueA, valueB, _action); } Variable varValue = new Variable(valueA); ParserFunction.AddGlobalOrLocalVariable(_name, new GetVarFunction(varValue)); return(valueA); }
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); }
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, 2, m_name); Variable all = Utils.GetSafeVariable(args, 0); string varName = Utils.GetSafeString(args, 1); int index = Utils.GetSafeInt(args, 2); var function = ParserFunction.GetFunction(varName); Variable mapVar = new Variable(Variable.VarType.ARRAY); if (all.Tuple == null) { return(Variable.EmptyInstance); } string currentValue = ""; int currentCount = 0; int globalCount = 0; for (int i = 0; i < all.Tuple.Count; i++) { Variable current = all.Tuple[i]; if (current.Tuple == null || current.Tuple.Count < index) { break; } string newValue = current.Tuple[index].AsString(); if (currentValue != newValue) { currentValue = newValue; currentCount = 0; } mapVar.Tuple.Add(new Variable(currentCount)); currentCount++; globalCount++; } ParserFunction.AddGlobalOrLocalVariable(varName, new GetVarFunction(mapVar)); return(mapVar); }
protected override Parser.Result Evaluate(string data, ref int from) { string varName = Utils.GetToken(data, ref from, Constants.END_ARG_ARRAY); if (from >= data.Length) { throw new ArgumentException("Couldn't set variable before end of line"); } NameVar nv = new NameVar(varName); Parser.Result varValue = new Parser.Result(); string value = ScDumper.GetValue(nv); varValue.Value = Double.Parse(value); // Check if the variable to be set has the form of x(0), // meaning that this is an array element. int arrayIndex = Utils.ExtractArrayElement(ref varName); if (arrayIndex >= 0) { bool exists = ParserFunction.FunctionExists(varName); Parser.Result currentValue = exists ? ParserFunction.GetFunction(varName).GetValue(data, ref from) : new Parser.Result(); List <Parser.Result> tuple = currentValue.Tuple ?? new List <Parser.Result>(); if (tuple.Count > arrayIndex) { tuple[arrayIndex] = varValue; } else { for (int i = tuple.Count; i < arrayIndex; i++) { tuple.Add(new Parser.Result(Double.NaN, string.Empty)); } tuple.Add(varValue); } varValue = new Parser.Result(Double.NaN, null, tuple); } ParserFunction.AddFunction(varName, new GetVarFunction(varValue)); return(new Parser.Result(Double.NaN, varName)); }
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); }
public void AddTranslation(NameValueCollection languageDictionary, string originalName) { string translation = languageDictionary[originalName]; if (string.IsNullOrWhiteSpace(translation)) { // The translation is not provided for this function. return; } if (translation.IndexOfAny((" \t\r\n").ToCharArray()) >= 0) { throw new ArgumentException("Translation of [" + translation + "] contains white spaces"); } ParserFunction originalFunction = ParserFunction.GetFunction(originalName); ParserFunction.AddFunction(translation, originalFunction); }
public static bool ExtractParameterNames(List <Variable> args, string functionName, ParsingScript script) { CustomFunction custFunc = ParserFunction.GetFunction(functionName, script) as CustomFunction; if (custFunc == null) { return(false); } var realArgs = custFunc.RealArgs; for (int i = 0; i < args.Count && i < realArgs.Length; i++) { string name = args[i].CurrentAssign; args[i].ParamName = string.IsNullOrWhiteSpace(name) ? realArgs[i] : name; } return(true); }