示例#1
0
        private void RunCommandsFromParser(CommandStringParser parser)
        {
            CommandExecutionContext context = new CommandExecutionContext();

            foreach (string cmdString in parser.Parse())
            {
                Command parsedCmd = null;
                string  errorDescr;
                bool    valid = parser.ParseCommand(cmdString, false, out parsedCmd, out errorDescr);
                if (valid)
                {
                    context.Parsed(cmdString, parsedCmd);
                }
                else
                {
                    // forward parse error to hooks
                    foreach (CommandHook hook in m_hooks)
                    {
                        hook.ParseError(cmdString, errorDescr);
                    }
                    // we can not execute this command
                    continue;
                }
            }

            context.SetLabels();
            context.ExecuteAll();
        }
示例#2
0
        // Wrapper=false to keek CommandTrace updates

        protected override void DoCommandAction()
        {
            // internal
            bool exists = Objects.VariableManager.Instance.IsSet(Variable);

            // environement
            string value = Environment.GetEnvironmentVariable(Variable);

            if (value != null)
            {
                exists = true;
            }

            CommandStringParser parser = new CommandStringParser(exists ? Then : Else);

            foreach (string cmdString in parser.Parse())
            {
                Command cmd        = null;
                string  errorDescr = "";
                parser.ParseCommand(cmdString, true, out cmd, out errorDescr);
                // only the alias it self shall appear in the command trace
                cmd.UpdateCommandTrace = false;
                CommandExecuter.Instance.Execute(cmd);
            }
        }
示例#3
0
        protected override void DoCommandAction()
        {
            try
            {
                Regex.IsMatch(Filter, "");
            }
            catch (Exception error)
            {
                throw new ArgumentException("No valid regular expression given: " + Filter + " " + error.Message);
            }

            foreach (Type type in CommandStringParser.GetAllCommandTypes().Where(t => string.IsNullOrEmpty(Filter) ? true : Regex.IsMatch(t.Name, Filter)).OrderBy(t => t.Name))
            {
                OutputManager.WriteOutput(type.Name);
            }
        }
示例#4
0
        protected override void DoCommandAction()
        {
            CommandStringParser parser = new CommandStringParser(Commands);

            foreach (string cmdString in parser.Parse())
            {
                Command cmd        = null;
                string  errorDescr = "";
                parser.ParseCommand(cmdString, true, out cmd, out errorDescr);
                // only the alias it self shall appear in the command trace
                cmd.UpdateCommandTrace = false;
                string errorDescription = "";
                parser.SetParamters(cmd, true, m_overriddenDefaults, ref errorDescription);
                CommandExecuter.Instance.Execute(cmd);
            }
        }
示例#5
0
        /// <summary>
        /// No labels here!!
        /// </summary>
        public void ExecuteWithOutContext(string commandString)
        {
            CommandStringParser parser = new CommandStringParser(commandString);

            foreach (string cmdString in parser.Parse())
            {
                Command parsedCmd = null;
                string  errorDescr;
                bool    valid = parser.ParseCommand(cmdString, true, out parsedCmd, out errorDescr);
                if (valid)
                {
                    Execute(parsedCmd);
                }
                else
                {
                    throw new ArgumentException(errorDescr);
                }
            }
        }
示例#6
0
        public List <string> ReadCommandFile(string commandFile)
        {
            List <string> commandString = new List <string>();

            FileStream fs = File.OpenRead(commandFile);

            byte[] byteBuffer = new byte[fs.Length];
            int    length     = Convert.ToInt32(fs.Length);

            fs.Read(byteBuffer, 0, length);
            fs.Close();

            CommandStringParser parser = new CommandStringParser(byteBuffer, length);

            foreach (string cmd in parser.Parse())
            {
                commandString.Add(cmd);
            }

            return(commandString);
        }
示例#7
0
        protected override void DoCommandAction()
        {
            Dictionary <string, int> cmds = new Dictionary <string, int>();

            TextReader tr   = new StreamReader(CommandCoverageFile);
            string     line = "";

            while ((line = tr.ReadLine()) != null)
            {
                string[] atoms    = Regex.Split(line, ";");
                string   cmdName  = atoms[0];
                int      cmdCount = int.Parse(atoms[1]);
                cmds[cmdName] = cmdCount;
            }
            tr.Close();

            foreach (Type type in CommandStringParser.GetAllCommandTypes().Where(t => !cmds.ContainsKey(t.Name)).OrderBy(t => t.Name))
            {
                OutputManager.WriteOutput("Command " + type.Name + " is uncovered");
            }
        }
示例#8
0
        protected override void DoCommandAction()
        {
            foreach (Type type in CommandStringParser.GetAllCommandTypes().OrderBy(t => t.Name))
            {
                Command command = (Command)Activator.CreateInstance(type);
                if (!command.PublishCommand)
                {
                    continue;
                }

                string helpFile = command.GetHelpFilePath();

                if (!File.Exists(helpFile))
                {
                    OutputManager.WriteOutput("Creating " + helpFile);
                    File.Create(helpFile);
                }
                else
                {
                    OutputManager.WriteOutput("File " + helpFile + " already exists");
                }
            }
        }
示例#9
0
        protected override void DoCommandAction()
        {
            ExpressionParser ep   = new ExpressionParser();
            int  evaluationResult = 0;
            bool valid            = ep.Evaluate(Condition, out evaluationResult);

            if (!valid)
            {
                throw new ArgumentException("Condition" + Condition + " is not a valid arithmetic expression");
            }

            CommandStringParser parser = new CommandStringParser(evaluationResult != 0 ? Then : Else);

            foreach (string cmdString in parser.Parse())
            {
                Command cmd        = null;
                string  errorDescr = "";
                parser.ParseCommand(cmdString, true, out cmd, out errorDescr);
                // only the alias it self shall appear in the command trace
                cmd.UpdateCommandTrace = false;
                CommandExecuter.Instance.Execute(cmd);
            }
        }
        protected override void DoCommandAction()
        {
            SortedDictionary <string, string> parameters = new SortedDictionary <string, string>();

            foreach (Type type in CommandStringParser.GetAllCommandTypes())
            {
                foreach (FieldInfo fi in type.GetFields())
                {
                    // find ParamterField attr
                    foreach (object obj in fi.GetCustomAttributes(true))
                    {
                        if (obj is Parameter && !parameters.ContainsKey(fi.Name))
                        {
                            parameters.Add(fi.Name, fi.Name);
                        }
                    }
                }
            }

            foreach (string s in parameters.Keys)
            {
                OutputManager.WriteOutput(s);
            }
        }
        protected override void DoCommandAction()
        {
            foreach (Type type in CommandStringParser.GetAllCommandTypes().OrderBy(t => t.Name))
            {
                // create instance to get default value
                Command cmd = (Command)Activator.CreateInstance(type);

                bool commandDescriptionFound = false;
                foreach (Attribute attr in Attribute.GetCustomAttributes(type).Where(a => a is CommandDescription))
                {
                    CommandDescription descr = (CommandDescription)attr;
                    if (!string.IsNullOrEmpty(descr.Description))
                    {
                        commandDescriptionFound = true;
                        break;
                    }
                }
                if (!commandDescriptionFound)

                {
                    OutputManager.WriteOutput(type.Name + " has no Command Description");
                }
            }
        }
示例#12
0
        public void Execute(string commandString)
        {
            CommandStringParser parser = new CommandStringParser(commandString);

            RunCommandsFromParser(parser);
        }
示例#13
0
        public void Execute(FileInfo fi)
        {
            CommandStringParser parser = new CommandStringParser(fi);

            RunCommandsFromParser(parser);
        }