Esempio n. 1
0
        /**
         * Cmd_RemoveCommand
         */
        public static void RemoveCommand(string cmd_name)
        {
            cmd_function_t cmd, back = null;

            back = cmd = Cmd.cmd_functions;

            while (true)
            {
                if (cmd == null)
                {
                    Com.Printf("Cmd_RemoveCommand: " + cmd_name + " not added\n");

                    return;
                }

                if (0 == Lib.strcmp(cmd_name, cmd.name))
                {
                    if (cmd == Cmd.cmd_functions)
                    {
                        Cmd.cmd_functions = cmd.next;
                    }
                    else
                    {
                        back.next = cmd.next;
                    }

                    return;
                }

                back = cmd;
                cmd  = cmd.next;
            }
        }
Esempio n. 2
0
        public static void AddCommand(String cmd_name, xcommand_t function)
        {
            cmd_function_t cmd;

            if ((Cvar.VariableString(cmd_name)).Length > 0)
            {
                Com.Printf("Cmd_AddCommand: " + cmd_name + " already defined as a var\\n");
                return;
            }

            for (cmd = cmd_functions; cmd != null; cmd = cmd.next)
            {
                if (cmd_name.Equals(cmd.name))
                {
                    Com.Printf("Cmd_AddCommand: " + cmd_name + " already defined\\n");
                    return;
                }
            }

            cmd           = new cmd_function_t();
            cmd.name      = cmd_name;
            cmd.function  = function;
            cmd.next      = cmd_functions;
            cmd_functions = cmd;
        }
Esempio n. 3
0
        public static void AddCommand(string cmd_name, Action function)
        {
            cmd_function_t cmd;

            //Com.DPrintf("Cmd_AddCommand: " + cmd_name + "\n");
            // fail if the command is a variable name
            if (Cvar.VariableString(cmd_name).Length > 0)
            {
                Com.Printf("Cmd_AddCommand: " + cmd_name + " already defined as a var\n");

                return;
            }

            // fail if the command already exists
            for (cmd = Cmd.cmd_functions; cmd != null; cmd = cmd.next)
            {
                if (cmd_name.Equals(cmd.name))
                {
                    Com.Printf("Cmd_AddCommand: " + cmd_name + " already defined\n");

                    return;
                }
            }

            cmd      = new();
            cmd.name = cmd_name;

            cmd.function      = function;
            cmd.next          = Cmd.cmd_functions;
            Cmd.cmd_functions = cmd;
        }
Esempio n. 4
0
        /*
         * ============
         * Cmd_AddCommand
         * ============
         */
        public static void      Cmd_AddCommand(string cmd_name, xcommand_t function)
        {
            cmd_function_t cmd;

            if (host.host_initialized)          // because hunk allocation would get stomped
            {
                sys_linux.Sys_Error("Cmd_AddCommand after host_initialized");
            }

            // fail if the command is a variable name
            if (cvar_t.Cvar_VariableString(cmd_name).Length != 0)
            {
                console.Con_Printf("Cmd_AddCommand: " + cmd_name + " already defined as a var\n");
                return;
            }

            // fail if the command already exists
            for (cmd = cmd_functions; cmd != null; cmd = cmd.next)
            {
                if (cmd_name.CompareTo(cmd.name) == 0)
                {
                    console.Con_Printf("Cmd_AddCommand: " + cmd_name + " already defined\n");
                    return;
                }
            }

            cmd           = new cmd_function_t();
            cmd.name      = cmd_name;
            cmd.function  = function;
            cmd.next      = cmd_functions;
            cmd_functions = cmd;
        }
Esempio n. 5
0
            public override void Execute( )
            {
                cmd_function_t cmd = Cmd.cmd_functions;
                var            i   = 0;

                while (cmd != null)
                {
                    Com.Printf(cmd.name + '\\');
                    i++;
                    cmd = cmd.next;
                }

                Com.Printf(i + " commands\\n");
            }
Esempio n. 6
0
        public static ArrayList CompleteCommand(String partial)
        {
            ArrayList cmds = new ArrayList();

            for (cmd_function_t cmd = cmd_functions; cmd != null; cmd = cmd.next)
            {
                if (cmd.name.StartsWith(partial))
                {
                    cmds.Add(cmd.name);
                }
            }
            for (cmdalias_t a = Globals.cmd_alias; a != null; a = a.next)
            {
                if (a.name.StartsWith(partial))
                {
                    cmds.Add(a.name);
                }
            }
            return(cmds);
        }
Esempio n. 7
0
    /*
     * ============
     * Cmd_AddCommand
     * ============
     */
    static void Cmd_AddCommand(string cmd_name, xcommand_t function)
    {
        // fail if the command already exists
        foreach (cmd_function_t cmd in cmd_functions)
        {
            if (cmd.name == cmd_name)
            {
                if (function != null)
                {
                    Com_Printf("Cmd_AddCommand: %s already defined\n", cmd_name);
                }

                return;
            }
        }

        cmd_function_t newcmd = new cmd_function_t();

        newcmd.name     = cmd_name;
        newcmd.function = function;

        cmd_functions.Add(newcmd);
    }
Esempio n. 8
0
        /*
        ============
        Cmd_AddCommand
        ============
        */
        public static void Cmd_AddCommand(string cmd_name, xcommand_t function)
        {
            cmd_function_t	cmd;

            if (host.host_initialized)	// because hunk allocation would get stomped
                sys_linux.Sys_Error ("Cmd_AddCommand after host_initialized");

            // fail if the command is a variable name
            if (cvar_t.Cvar_VariableString(cmd_name).Length != 0)
            {
                console.Con_Printf("Cmd_AddCommand: " + cmd_name + " already defined as a var\n");
                return;
            }

            // fail if the command already exists
            for (cmd=cmd_functions ; cmd != null ; cmd=cmd.next)
            {
                if (cmd_name.CompareTo(cmd.name) == 0)
                {
                    console.Con_Printf ("Cmd_AddCommand: " + cmd_name + " already defined\n");
                    return;
                }
            }

            cmd = new cmd_function_t();
            cmd.name = cmd_name;
            cmd.function = function;
            cmd.next = cmd_functions;
            cmd_functions = cmd;
        }