Exemplo n.º 1
0
        /// <summary> 
        /// Tcl_ProcObjCmd -> ProcCmd.cmdProc
        /// 
        /// Creates a new Tcl procedure.
        /// 
        /// </summary>
        /// <param name="interp">the current interpreter.
        /// </param>
        /// <param name="objv">command arguments.
        /// </param>
        /// <exception cref=""> TclException If incorrect number of arguments.
        /// </exception>

        public TCL.CompletionCode CmdProc(Interp interp, TclObject[] objv)
        {
            Procedure proc;
            string fullName, procName;
            NamespaceCmd.Namespace ns, altNs, cxtNs;
            ICommand cmd;
            StringBuilder ds;

            if (objv.Length != 4)
            {
                throw new TclNumArgsException(interp, 1, objv, "name args body");
            }

            // Determine the namespace where the procedure should reside. Unless
            // the command name includes namespace qualifiers, this will be the
            // current namespace.


            fullName = objv[1].ToString();

            // Java does not support passing an address so we pass
            // an array of size 1 and then assign arr[0] to the value
            NamespaceCmd.Namespace[] nsArr = new NamespaceCmd.Namespace[1];
            NamespaceCmd.Namespace[] altNsArr = new NamespaceCmd.Namespace[1];
            NamespaceCmd.Namespace[] cxtNsArr = new NamespaceCmd.Namespace[1];
            string[] procNameArr = new string[1];

            NamespaceCmd.getNamespaceForQualName(interp, fullName, null, 0, nsArr, altNsArr, cxtNsArr, procNameArr);

            // Get the values out of the arrays
            ns = nsArr[0];
            altNs = altNsArr[0];
            cxtNs = cxtNsArr[0];
            procName = procNameArr[0];

            if (ns == null)
            {
                throw new TclException(interp, "can't create procedure \"" + fullName + "\": unknown namespace");
            }
            if ((System.Object)procName == null)
            {
                throw new TclException(interp, "can't create procedure \"" + fullName + "\": bad procedure name");
            }
            // FIXME : could there be a problem with a command named ":command" ?
            if ((ns != NamespaceCmd.getGlobalNamespace(interp)) && ((System.Object)procName != null) && ((procName.Length > 0) && (procName[0] == ':')))
            {
                throw new TclException(interp, "can't create procedure \"" + procName + "\" in non-global namespace with name starting with \":\"");
            }

            //  Create the data structure to represent the procedure.

            proc = new Procedure(interp, ns, procName, objv[2], objv[3], interp.ScriptFile, interp.getArgLineNumber(3));

            // Now create a command for the procedure. This will initially be in
            // the current namespace unless the procedure's name included namespace
            // qualifiers. To create the new command in the right namespace, we
            // generate a fully qualified name for it.

            ds = new StringBuilder();
            if (ns != NamespaceCmd.getGlobalNamespace(interp))
            {
                ds.Append(ns.fullName);
                ds.Append("::");
            }
            ds.Append(procName);

            interp.CreateCommand(ds.ToString(), proc);

            // Now initialize the new procedure's cmdPtr field. This will be used
            // later when the procedure is called to determine what namespace the
            // procedure will run in. This will be different than the current
            // namespace if the proc was renamed into a different namespace.

            // FIXME : we do not handle renaming into another namespace correctly yet!
            //procPtr->cmdPtr = (Command *) cmd;

            return TCL.CompletionCode.RETURN;
        }
Exemplo n.º 2
0
 /// <summary>
 /// Load the class that implements the given command and execute it.
 /// </summary>
 /// <param name="interp">
 /// the current interpreter.
 /// </param>
 /// <param name="argv">
 /// command arguments.
 /// </param>
 /// <exception cref="">
 /// TclException if error happens inside the real command proc.
 /// </exception>
 public TCL.CompletionCode CmdProc(Interp interp, TclObject[] argv)
 {
     Type cmdClass = null;
     ICommand cmd;
     try { cmdClass = Type.GetType(className, true); }
     catch (Exception) { throw new TclException(interp, "ClassNotFoundException for class \"" + className + "\""); }
     try { cmd = (ICommand)SupportClass.CreateNewInstance(cmdClass); }
     catch (UnauthorizedAccessException) { throw new TclException(interp, "IllegalAccessException for class \"" + cmdClass.FullName + "\""); }
     catch (InvalidCastException) { throw new TclException(interp, "ClassCastException for class \"" + cmdClass.FullName + "\""); }
     catch (Exception) { throw new TclException(interp, "InstantiationException for class \"" + cmdClass.FullName + "\""); }
     interp.CreateCommand(argv[0].ToString(), cmd);
     TCL.CompletionCode rc = cmd.CmdProc(interp, argv);
     return (rc == TCL.CompletionCode.EXIT ? TCL.CompletionCode.EXIT : TCL.CompletionCode.RETURN);
 }
Exemplo n.º 3
0
 /// <summary>
 /// Create a stub command which autoloads the real command the first time the stub command is invoked. Register the stub command in the	 interpreter.
 /// </summary>
 /// <param name="interp">
 /// current interp.
 /// </param>
 /// <param name="cmdName">
 /// name of the command, e.g., "after".
 /// </param>
 /// <param name="clsName">
 /// name of the Java class that implements this command, e.g. "tcl.lang.AfterCmd"
 /// </param>
 public static void LoadOnDemand(Interp interp, string cmdName, string clsName)
 {
     interp.CreateCommand(cmdName, new AutoloadStub(clsName));
 }
Exemplo n.º 4
0
 internal static void Init(Interp interp)
 // Current interpreter. 
 {
     interp.CreateCommand("regexp", new Tcl.Lang.RegexpCmd());
     interp.CreateCommand("regsub", new Tcl.Lang.RegsubCmd());
 }