public static Variable GetVariableFromString(string str, ParsingScript script, int startIndex = 0) { ParsingScript tempScript = script.GetTempScript(str, startIndex); Variable result = Utils.GetItem(tempScript); return(result); }
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); }
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. 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) { string search = Utils.GetItem(script).AsString(); List <string> patterns = Utils.GetFunctionArgs(script); bool ignoreCase = true; if (patterns.Count > 0 && patterns.Last().Equals("case")) { ignoreCase = false; patterns.RemoveAt(patterns.Count - 1); } if (patterns.Count == 0) { patterns.Add("*.*"); } List <Variable> results = null; try { string pwd = Directory.GetCurrentDirectory(); List <string> files = Utils.GetStringInFiles(pwd, search, patterns.ToArray(), ignoreCase); results = Utils.ConvertToResults(files.ToArray(), true); } catch (Exception exc) { throw new ArgumentException("Couldn't find pattern: " + exc.Message); } return(new Variable(results)); }
protected override Parser.Result Evaluate(string data, ref int from) { string processName = Utils.GetItem(data, ref from).String; if (string.IsNullOrWhiteSpace(processName)) { throw new ArgumentException("Couldn't extract process name"); } List <string> args = Utils.GetFunctionArgs(data, ref from); int processId = -1; try { Process pr = Process.Start(processName, string.Join("", args.ToArray())); processId = pr.Id; } catch (System.ComponentModel.Win32Exception exc) { throw new ArgumentException("Couldn't start [" + processName + "]: " + exc.Message); } m_interpreter.AppendOutput("Process " + processName + " started, id: " + processId); return(new Parser.Result(processId)); }
protected override Variable Evaluate(ParsingScript script) { string pathname = Utils.GetItem(script).AsString(); bool isFile = File.Exists(pathname); bool isDir = Directory.Exists(pathname); if (!isFile && !isDir) { throw new ArgumentException("[" + pathname + "] doesn't exist"); } try { if (isFile) { File.Delete(pathname); } else { Directory.Delete(pathname, true); } } catch (Exception exc) { throw new ArgumentException("Couldn't delete [" + pathname + "] :" + exc.Message); } return(Variable.EmptyInstance); }
public static List <Variable> GetArgs(string data, ref int from, char start, char end, out bool isList) { List <Variable> args = new List <Variable>(); isList = from < data.Length && data[from] == Constants.START_GROUP; if (from >= data.Length || data[from] == Constants.END_STATEMENT) { return(args); } int lastChar = from; Utils.GetBodyBetween(data, ref lastChar, start, end); while (from < lastChar) { Variable item = Utils.GetItem(data, ref from); if (item.Equals(Variable.EmptyInstance)) { break; } args.Add(item); } MoveForwardIf(data, ref from, end, Constants.SPACE); return(args); }
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)); }
public static List <string> GetFunctionArgs(string data, ref int from) { List <string> args = new List <string>(); bool moreArgs = true; while (moreArgs) { moreArgs = Utils.SeparatorExists(data, from); Parser.Result item = Utils.GetItem(data, ref from); // Separate treatment for an array. // Only 1-dimensional arrays are supported at the moment. if (item.Tuple != null && item.Tuple.Count > 0) { for (int i = 0; i < item.Tuple.Count; i++) { Parser.Result arg = item.Tuple[i]; args.Add((arg.String != null ? arg.String : arg.Value.ToString()) + '\n'); } continue; } if (item.String == null && Double.IsNaN(item.Value)) { break; } args.Add(item.String != null ? item.String : item.Value.ToString()); } return(args); }
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) { var objectName = m_processFirstToken ? Utils.GetItem(script).AsString() : ""; GetParameters(script); if (Name.ToUpper() == "MSG") { string caption = GetParameter("caption"); int duration = GetIntParameter("duration"); return(new Variable(objectName)); } if (Name.ToUpper() == "DEFINE") { string name = GetParameter("name"); double size = GetIntParameter("size"); string type = GetParameter("type"); double value = GetIntParameter("value"); string init = GetParameter("init"); Variable dup = GetVariableParameter("dup"); return(new Variable(objectName)); } if (Name.ToUpper() == "SET_OBJECT") { string prop = GetParameter("property"); bool val = GetBoolParameter("value"); return(new Variable(objectName)); } return(new Variable(objectName)); }
protected override Variable Evaluate(ParsingScript script) { string pathname = Utils.GetItem(script).AsString(); bool isFile = File.Exists(pathname); bool isDir = Directory.Exists(pathname); if (!isFile && !isDir) { throw new ArgumentException("[" + pathname + "] doesn't exist"); } bool exists = false; try { if (isFile) { exists = File.Exists(pathname); } else { exists = Directory.Exists(pathname); } } catch (Exception exc) { throw new ArgumentException("Couldn't delete [" + pathname + "] :" + exc.Message); } return(new Variable(Convert.ToDouble(exists))); }
protected override Variable Evaluate(ParsingScript script) { if (script.Substr().StartsWith(" ..")) { script.Forward(); } string newDir = Utils.GetItem(script).AsString(); try { if (newDir == "..") { string pwd = Directory.GetCurrentDirectory(); DirectoryInfo parent = Directory.GetParent(pwd); if (parent == null) { throw new ArgumentException("No parent exists."); } newDir = parent.FullName; } if (newDir.Length == 0) { newDir = Environment.GetEnvironmentVariable("HOME"); } Directory.SetCurrentDirectory(newDir); newDir = Directory.GetCurrentDirectory(); } catch (Exception exc) { throw new ArgumentException("Couldn't change directory: " + exc.Message); } return(new Variable(newDir)); }
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); }
public static List <Variable> GetArgs(ParsingScript script, char start, char end, Action <bool> outList) { List <Variable> args = new List <Variable>(); bool isList = script.StillValid() && script.Current == Constants.START_GROUP; if (!script.StillValid() || script.Current == Constants.END_STATEMENT) { return(args); } ParsingScript tempScript = script.GetTempScript(script.String, script.Pointer); /*ParsingScript tempScript = new ParsingScript(script.String, script.Pointer); * tempScript.ParentScript = script; * tempScript.InTryBlock = script.InTryBlock;*/ if (script.Current != start && script.TryPrev() != start && (script.Current == ' ' || script.TryPrev() == ' ')) { // Allow functions with space separated arguments start = ' '; end = Constants.END_STATEMENT; } // ScriptingEngine - body is unsed (used in Debugging) but GetBodyBetween has sideeffects #pragma warning disable 219 string body = Utils.GetBodyBetween(tempScript, start, end); #pragma warning restore 219 // After the statement above tempScript.Parent will point to the last // character belonging to the body between start and end characters. while (script.Pointer < tempScript.Pointer) { Variable item = Utils.GetItem(script, false); args.Add(item); if (script.Pointer < tempScript.Pointer) { script.MoveForwardIf(Constants.END_GROUP); script.MoveForwardIf(Constants.NEXT_ARG); } if (script.Pointer == tempScript.Pointer - 1) { script.MoveForwardIf(Constants.END_ARG, Constants.END_GROUP); } } if (script.Pointer <= tempScript.Pointer) { // Eat closing parenthesis, if there is one, but only if it closes // the current argument list, not one after it. script.MoveForwardIf(Constants.END_ARG, end); } script.MoveForwardIf(Constants.SPACE); //script.MoveForwardIf(Constants.SPACE, Constants.END_STATEMENT); outList(isList); return(args); }
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); }
protected override Variable Evaluate(ParsingScript script) { string filename = Utils.GetStringOrVarValue(script); Variable line = Utils.GetItem(script); Utils.WriteFileText(filename, line.AsString() + Environment.NewLine); return(Variable.EmptyInstance); }
protected override Variable Evaluate(ParsingScript script) { Variable sleepms = Utils.GetItem(script); Utils.CheckPosInt(sleepms, script); Thread.Sleep((int)sleepms.Value); return Variable.EmptyInstance; }
protected override Variable Evaluate(ParsingScript script) { string filename = Utils.GetItem(script).AsString(); string lines = Utils.GetLinesFromList(script); Utils.AppendFileText(filename, lines); return(Variable.EmptyInstance); }
protected override Variable Evaluate(ParsingScript script) { Variable varName = Utils.GetItem(script); Utils.CheckNotNull(varName, m_name); List <Variable> results = varName.GetAllKeys(); return(new Variable(results)); }
protected override Variable Evaluate(ParsingScript script) { string filename = Utils.GetItem(script).AsString(); string[] lines = Utils.GetFileLines(filename); List <Variable> results = Utils.ConvertToResults(lines); return(new Variable(results)); }
void ProcessArrayFor(ParsingScript script, string forString) { var tokens = forString.Split(' '); var sep = tokens.Length > 2 ? tokens[1] : ""; string varName = tokens[0]; if (sep != Constants.FOR_EACH && sep != Constants.FOR_IN && sep != Constants.FOR_OF) { int index = forString.IndexOf(Constants.FOR_EACH); if (index <= 0 || index == forString.Length - 1) { Utils.ThrowErrorMsg("Expecting: for(item :/in/of array)", script, Constants.FOR); } varName = forString.Substring(0, index); } ParsingScript forScript = script.GetTempScript(forString, varName.Length + sep.Length + 1); forScript.Debugger = script.Debugger; Variable arrayValue = Utils.GetItem(forScript); if (arrayValue.Type == Variable.VarType.STRING) { arrayValue = new Variable(new List <string>(arrayValue.ToString().ToCharArray().Select(c => c.ToString()))); } int cycles = arrayValue.Count; 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) { Variable portRes = Utils.GetItem(script); Utils.CheckPosInt(portRes, script); int port = (int)portRes.Value; try { IPHostEntry ipHostInfo = Dns.GetHostEntry(Dns.GetHostName()); IPAddress ipAddress = ipHostInfo.AddressList[0]; IPEndPoint localEndPoint = new IPEndPoint(ipAddress, port); Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp); listener.Bind(localEndPoint); listener.Listen(10); Socket handler = null; while (true) { Interpreter.Instance.AppendOutput("Waiting for connections on " + port + " ...", true); handler = listener.Accept(); // Data buffer for incoming data. byte[] bytes = new byte[1024]; int bytesRec = handler.Receive(bytes); string received = Encoding.UTF8.GetString(bytes, 0, bytesRec); Interpreter.Instance.AppendOutput("Received from " + handler.RemoteEndPoint.ToString() + ": [" + received + "]", true); byte[] msg = Encoding.UTF8.GetBytes(received); handler.Send(msg); if (received.Contains("<EOF>")) { break; } } if (handler != null) { handler.Shutdown(SocketShutdown.Both); handler.Close(); } } catch (Exception exc) { throw new ArgumentException("Couldn't start server: (" + exc.Message + ")"); } return(Variable.EmptyInstance); }
protected override Variable Evaluate(string data, ref int from) { Utils.MoveForwardIf(data, ref from, Constants.SPACE); Variable result = Utils.GetItem(data, ref from); // Ако сме в завръщането, ние сме готови: from = data.Length; return(result); }
void GetParameters(ParsingScript script) { m_parameters = new Dictionary <string, Variable>(); while (script.Current != Constants.END_STATEMENT) { var labelName = Utils.GetToken(script, Constants.TOKEN_SEPARATION); var value = script.Current == Constants.END_STATEMENT ? Variable.EmptyInstance : Utils.GetItem(script, false); m_parameters[labelName.ToLower()] = value; } }
protected override Variable Evaluate(ParsingScript script) { // 1. Extract what to throw. Variable arg = Utils.GetItem(script); // 2. Convert it to a string. string result = arg.AsString(); // 3. Throw it! throw new ArgumentException(result); }
protected override Variable Evaluate(ParsingScript script) { string varName = Utils.GetToken(script, Constants.NEXT_ARG_ARRAY); Utils.CheckNotEmpty(script, varName, m_name); Variable varValue = Utils.GetItem(script); string strValue = varValue.AsString(); Environment.SetEnvironmentVariable(varName, strValue); return new Variable(varName); }
protected override Variable Evaluate(ParsingScript script) { string pattern = Utils.GetItem(script).String; if (string.IsNullOrWhiteSpace(pattern)) { throw new ArgumentException("Couldn't extract process name"); } int MAX_PROC_NAME = 26; Interpreter.Instance.AppendOutput(Utils.GetLine(), true); Interpreter.Instance.AppendOutput(String.Format("{0} {1} {2} {3} {4} {5}", "Process Id".PadRight(15), "Process Name".PadRight(MAX_PROC_NAME), "Working Set".PadRight(15), "Virt Mem".PadRight(15), "Start Time".PadRight(15), "CPU Time".PadRight(25)), true); Process[] processes = Process.GetProcessesByName(pattern); List <Variable> results = new List <Variable>(processes.Length); for (int i = 0; i < processes.Length; i++) { Process pr = processes[i]; int workingSet = (int)(((double)pr.WorkingSet64) / 1000000.0); int virtMemory = (int)(((double)pr.VirtualMemorySize64) / 1000000.0); string procTitle = pr.ProcessName + " " + pr.MainWindowTitle.Split(null)[0]; string startTime = pr.StartTime.ToString(); if (procTitle.Length > MAX_PROC_NAME) { procTitle = procTitle.Substring(0, MAX_PROC_NAME); } string procTime = string.Empty; try { procTime = pr.TotalProcessorTime.ToString().Substring(0, 11); } catch (Exception) { } results.Add(new Variable( string.Format("{0,15} {1," + MAX_PROC_NAME + "} {2,15} {3,15} {4,15} {5,25}", pr.Id, procTitle, workingSet, virtMemory, startTime, procTime))); Interpreter.Instance.AppendOutput(results.Last().String, true); } Interpreter.Instance.AppendOutput(Utils.GetLine(), true); if (script.TryCurrent() == Constants.NEXT_ARG) { script.Forward(); // eat end of statement semicolon } return(new Variable(results)); }
protected override Variable Evaluate(ParsingScript script) { script.MoveForwardIf(Constants.SPACE); Variable result = Utils.GetItem(script); // If we are in Return, we are done: script.SetDone(); result.IsReturn = true; return(result); }