/TCL/src/commands/InfoCmd.cs

/*
* InfoCmd.java
*
* Copyright (c) 1997 Cornell University.
* Copyright (c) 1997 Sun Microsystems, Inc.
*
* See the file "license.terms" for information on usage and
* redistribution of this file, and for a DISCLAIMER OF ALL
* WARRANTIES.
* 
* Included in SQLite3 port to C# for use in testharness only;  2008 Noah B Hart
*
* RCS @(#) $Id: InfoCmd.java,v 1.8 2001/11/16 23:57:13 mdejong Exp $
*
*/
using System;
using System.Collections;

namespace tcl.lang
{

  /// <summary> This class implements the built-in "info" command in Tcl.</summary>

  class InfoCmd : Command
  {
    private static readonly string[] validCmds = new string[] { "args", "body", "cmdcount", "commands", "complete", "default", "exists", "globals", "hostname", "level", "library", "loaded", "locals", "nameofexecutable", "patchlevel", "procs", "script", "sharedlibextension", "tclversion", "vars" };

    internal const int OPT_ARGS = 0;
    internal const int OPT_BODY = 1;
    internal const int OPT_CMDCOUNT = 2;
    internal const int OPT_COMMANDS = 3;
    internal const int OPT_COMPLETE = 4;
    internal const int OPT_DEFAULT = 5;
    internal const int OPT_EXISTS = 6;
    internal const int OPT_GLOBALS = 7;
    internal const int OPT_HOSTNAME = 8;
    internal const int OPT_LEVEL = 9;
    internal const int OPT_LIBRARY = 10;
    internal const int OPT_LOADED = 11;
    internal const int OPT_LOCALS = 12;
    internal const int OPT_NAMEOFEXECUTABLE = 13;
    internal const int OPT_PATCHLEVEL = 14;
    internal const int OPT_PROCS = 15;
    internal const int OPT_SCRIPT = 16;
    internal const int OPT_SHAREDLIBEXTENSION = 17;
    internal const int OPT_TCLVERSION = 18;
    internal const int OPT_VARS = 19;

    /// <summary> Tcl_InfoObjCmd -> InfoCmd.cmdProc
    /// 
    /// This procedure is invoked to process the "info" Tcl command.
    /// See the user documentation for details on what it does.
    /// 
    /// </summary>
    /// <param name="interp">the current interpreter.
    /// </param>
    /// <param name="argv">command arguments.
    /// </param>
    /// <exception cref=""> TclException if wrong # of args or invalid argument(s).
    /// </exception>
    public TCL.CompletionCode cmdProc( Interp interp, TclObject[] objv )
    {
      int index;

      if ( objv.Length < 2 )
      {
        throw new TclNumArgsException( interp, 1, objv, "option ?arg arg ...?" );
      }
      index = TclIndex.get( interp, objv[1], validCmds, "option", 0 );

      switch ( index )
      {

        case OPT_ARGS:
          InfoArgsCmd( interp, objv );
          break;

        case OPT_BODY:
          InfoBodyCmd( interp, objv );
          break;

        case OPT_CMDCOUNT:
          InfoCmdCountCmd( interp, objv );
          break;

        case OPT_COMMANDS:
          InfoCommandsCmd( interp, objv );
          break;

        case OPT_COMPLETE:
          InfoCompleteCmd( interp, objv );
          break;

        case OPT_DEFAULT:
          InfoDefaultCmd( interp, objv );
          break;

        case OPT_EXISTS:
          InfoExistsCmd( interp, objv );
          break;

        case OPT_GLOBALS:
          InfoGlobalsCmd( interp, objv );
          break;

        case OPT_HOSTNAME:
          InfoHostnameCmd( interp, objv );
          break;

        case OPT_LEVEL:
          InfoLevelCmd( interp, objv );
          break;

        case OPT_LIBRARY:
          InfoLibraryCmd( interp, objv );
          break;

        case OPT_LOADED:
          InfoLoadedCmd( interp, objv );
          break;

        case OPT_LOCALS:
          InfoLocalsCmd( interp, objv );
          break;

        case OPT_NAMEOFEXECUTABLE:
          InfoNameOfExecutableCmd( interp, objv );
          break;

        case OPT_PATCHLEVEL:
          InfoPatchLevelCmd( interp, objv );
          break;

        case OPT_PROCS:
          InfoProcsCmd( interp, objv );
          break;

        case OPT_SCRIPT:
          InfoScriptCmd( interp, objv );
          break;

        case OPT_SHAREDLIBEXTENSION:
          InfoSharedlibCmd( interp, objv );
          break;

        case OPT_TCLVERSION:
          InfoTclVersionCmd( interp, objv );
          break;

        case OPT_VARS:
          InfoVarsCmd( interp, objv );
          break;
      }
      return TCL.CompletionCode.RETURN;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoArgsCmd --
    *
    *      Called to implement the "info args" command that returns the
    *      argument list for a procedure. Handles the following syntax:
    *
    *          info args procName
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoArgsCmd( Interp interp, TclObject[] objv )
    {
      string name;
      Procedure proc;
      TclObject listObj;

      if ( objv.Length != 3 )
      {
        throw new TclNumArgsException( interp, 2, objv, "procname" );
      }

      name = objv[2].ToString();
      proc = Procedure.findProc( interp, name );
      if ( proc == null )
      {
        throw new TclException( interp, "\"" + name + "\" isn't a procedure" );
      }

      // Build a return list containing the arguments.

      listObj = TclList.newInstance();
      for ( int i = 0; i < proc.argList.Length; i++ )
      {
        TclObject s = TclString.newInstance( proc.argList[i][0] );
        TclList.append( interp, listObj, s );
      }
      interp.setResult( listObj );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoBodyCmd --
    *
    *      Called to implement the "info body" command that returns the body
    *      for a procedure. Handles the following syntax:
    *
    *          info body procName
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoBodyCmd( Interp interp, TclObject[] objv )
    {
      string name;
      Procedure proc;
      //TclObject body, result;

      if ( objv.Length != 3 )
      {
        throw new TclNumArgsException( interp, 2, objv, "procname" );
      }

      name = objv[2].ToString();
      proc = Procedure.findProc( interp, name );
      if ( proc == null )
      {
        throw new TclException( interp, "\"" + name + "\" isn't a procedure" );
      }


      interp.setResult( proc.body.ToString() );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoCmdCountCmd --
    *
    *      Called to implement the "info cmdcount" command that returns the
    *      number of commands that have been executed. Handles the following
    *      syntax:
    *
    *          info cmdcount
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoCmdCountCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }
      interp.setResult( interp.cmdCount );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoCommandsCmd --
    *
    *	Called to implement the "info commands" command that returns the
    *	list of commands in the interpreter that match an optional pattern.
    *	The pattern, if any, consists of an optional sequence of namespace
    *	names separated by "::" qualifiers, which is followed by a
    *	glob-style pattern that restricts which commands are returned.
    *	Handles the following syntax:
    *
    *          info commands ?pattern?
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoCommandsCmd( Interp interp, TclObject[] objv )
    {
      string cmdName, pattern, simplePattern;
      IDictionaryEnumerator search;
      NamespaceCmd.Namespace ns;
      NamespaceCmd.Namespace globalNs = NamespaceCmd.getGlobalNamespace( interp );
      NamespaceCmd.Namespace currNs = NamespaceCmd.getCurrentNamespace( interp );
      TclObject list, elemObj;
      bool specificNsInPattern = false; // Init. to avoid compiler warning.
      WrappedCommand cmd;

      // Get the pattern and find the "effective namespace" in which to
      // list commands.

      if ( objv.Length == 2 )
      {
        simplePattern = null;
        ns = currNs;
        specificNsInPattern = false;
      }
      else if ( objv.Length == 3 )
      {
        // From the pattern, get the effective namespace and the simple
        // pattern (no namespace qualifiers or ::'s) at the end. If an
        // error was found while parsing the pattern, return it. Otherwise,
        // if the namespace wasn't found, just leave ns NULL: we will
        // return an empty list since no commands there can be found.


        pattern = objv[2].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[] dummy1Arr = new NamespaceCmd.Namespace[1];
        NamespaceCmd.Namespace[] dummy2Arr = new NamespaceCmd.Namespace[1];
        string[] simplePatternArr = new string[1];

        NamespaceCmd.getNamespaceForQualName( interp, pattern, null, 0, nsArr, dummy1Arr, dummy2Arr, simplePatternArr );

        // Get the values out of the arrays!
        ns = nsArr[0];
        simplePattern = simplePatternArr[0];

        if ( ns != null )
        {
          // we successfully found the pattern's ns
          specificNsInPattern = ( simplePattern.CompareTo( pattern ) != 0 );
        }
      }
      else
      {
        throw new TclNumArgsException( interp, 2, objv, "?pattern?" );
      }

      // Scan through the effective namespace's command table and create a
      // list with all commands that match the pattern. If a specific
      // namespace was requested in the pattern, qualify the command names
      // with the namespace name.

      list = TclList.newInstance();

      if ( ns != null )
      {
        search = ns.cmdTable.GetEnumerator();
        while ( search.MoveNext() )
        {
          cmdName = ( (string)search.Key );
          if ( ( (System.Object)simplePattern == null ) || Util.stringMatch( cmdName, simplePattern ) )
          {
            if ( specificNsInPattern )
            {
              cmd = (WrappedCommand)search.Value;
              elemObj = TclString.newInstance( interp.getCommandFullName( cmd ) );
            }
            else
            {
              elemObj = TclString.newInstance( cmdName );
            }
            TclList.append( interp, list, elemObj );
          }
        }

        // If the effective namespace isn't the global :: namespace, and a
        // specific namespace wasn't requested in the pattern, then add in
        // all global :: commands that match the simple pattern. Of course,
        // we add in only those commands that aren't hidden by a command in
        // the effective namespace.

        if ( ( ns != globalNs ) && !specificNsInPattern )
        {
          search = globalNs.cmdTable.GetEnumerator();
          while ( search.MoveNext() )
          {
            cmdName = ( (string)search.Key );
            if ( ( (System.Object)simplePattern == null ) || Util.stringMatch( cmdName, simplePattern ) )
            {
              if ( ns.cmdTable[cmdName] == null )
              {
                TclList.append( interp, list, TclString.newInstance( cmdName ) );
              }
            }
          }
        }
      }

      interp.setResult( list );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoCompleteCmd --
    *
    *      Called to implement the "info complete" command that determines
    *      whether a string is a complete Tcl command. Handles the following
    *      syntax:
    *
    *          info complete command
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoCompleteCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 3 )
      {
        throw new TclNumArgsException( interp, 2, objv, "command" );
      }


      interp.setResult( tcl.lang.Interp.commandComplete( objv[2].ToString() ) );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoDefaultCmd --
    *
    *      Called to implement the "info default" command that returns the
    *      default value for a procedure argument. Handles the following
    *      syntax:
    *
    *          info default procName arg varName
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoDefaultCmd( Interp interp, TclObject[] objv )
    {
      string procName, argName, varName;
      Procedure proc;
      //TclObject valueObj;

      if ( objv.Length != 5 )
      {
        throw new TclNumArgsException( interp, 2, objv, "procname arg varname" );
      }


      procName = objv[2].ToString();

      argName = objv[3].ToString();
      proc = Procedure.findProc( interp, procName );
      if ( proc == null )
      {
        throw new TclException( interp, "\"" + procName + "\" isn't a procedure" );
      }

      for ( int i = 0; i < proc.argList.Length; i++ )
      {

        if ( argName.Equals( proc.argList[i][0].ToString() ) )
        {

          varName = objv[4].ToString();
          try
          {
            if ( proc.argList[i][1] != null )
            {
              interp.setVar( varName, proc.argList[i][1], 0 );
              interp.setResult( 1 );
            }
            else
            {
              interp.setVar( varName, "", 0 );
              interp.setResult( 0 );
            }
          }
          catch ( TclException excp )
          {
            throw new TclException( interp, "couldn't store default value in variable \"" + varName + "\"" );
          }
          return;
        }
      }
      throw new TclException( interp, "procedure \"" + procName + "\" doesn't have an argument \"" + argName + "\"" );
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoExistsCmd --
    *
    *      Called to implement the "info exists" command that determines
    *      whether a variable exists. Handles the following syntax:
    *
    *          info exists varName
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoExistsCmd( Interp interp, TclObject[] objv )
    {
      string varName;
      Var var = null;

      if ( objv.Length != 3 )
      {
        throw new TclNumArgsException( interp, 2, objv, "varName" );
      }


      varName = objv[2].ToString();
      Var[] result = Var.lookupVar( interp, varName, null, 0, "access", false, false );
      if ( result != null )
      {
        var = result[0];
      }

      if ( ( var != null ) && !var.isVarUndefined() )
      {
        interp.setResult( true );
      }
      else
      {
        interp.setResult( false );
      }

      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    *  InfoGlobalsCmd --
    *
    *      Called to implement the "info globals" command that returns the list
    *      of global variables matching an optional pattern. Handles the
    *      following syntax:
    *
    *          info globals ?pattern?*
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoGlobalsCmd( Interp interp, TclObject[] objv )
    {
      string varName, pattern;
      NamespaceCmd.Namespace globalNs = NamespaceCmd.getGlobalNamespace( interp );
      IDictionaryEnumerator search;
      Var var;
      TclObject list;

      if ( objv.Length == 2 )
      {
        pattern = null;
      }
      else if ( objv.Length == 3 )
      {

        pattern = objv[2].ToString();
      }
      else
      {
        throw new TclNumArgsException( interp, 2, objv, "?pattern?" );
      }

      // Scan through the global :: namespace's variable table and create a
      // list of all global variables that match the pattern.

      list = TclList.newInstance();

      for ( search = globalNs.varTable.GetEnumerator(); search.MoveNext(); )
      {
        varName = ( (string)search.Key );
        var = (Var)search.Value;
        if ( var.isVarUndefined() )
        {
          continue;
        }
        if ( ( (System.Object)pattern == null ) || Util.stringMatch( varName, pattern ) )
        {
          TclList.append( interp, list, TclString.newInstance( varName ) );
        }
      }

      interp.setResult( list );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoHostnameCmd --
    *
    *      Called to implement the "info hostname" command that returns the
    *      host name. Handles the following syntax:
    *
    *          info hostname
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoHostnameCmd( Interp interp, TclObject[] objv )
    {
      string name;

      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }

      // FIXME : how can we find the hostname

      name = null;

      if ( (System.Object)name != null )
      {
        interp.setResult( name );
        return;
      }
      else
      {
        interp.setResult( "unable to determine name of host" );
        return;
      }
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoLevelCmd --
    *
    *      Called to implement the "info level" command that returns
    *      information about the call stack. Handles the following syntax:
    *
    *          info level ?number?
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoLevelCmd( Interp interp, TclObject[] objv )
    {
      int level;
      CallFrame frame;
      TclObject list;

      if ( objv.Length == 2 )
      {
        // just "info level"
        if ( interp.varFrame == null )
        {
          interp.setResult( 0 );
        }
        else
        {
          interp.setResult( interp.varFrame.level );
        }
        return;
      }
      else if ( objv.Length == 3 )
      {
        level = TclInteger.get( interp, objv[2] );

        if ( level <= 0 )
        {
          if ( interp.varFrame == null )
          {

            throw new TclException( interp, "bad level \"" + objv[2].ToString() + "\"" );
          }

          level += interp.varFrame.level;
        }

        for ( frame = interp.varFrame; frame != null; frame = frame.callerVar )
        {
          if ( frame.level == level )
          {
            break;
          }
        }
        if ( ( frame == null ) || frame.objv == null )
        {

          throw new TclException( interp, "bad level \"" + objv[2].ToString() + "\"" );
        }

        list = TclList.newInstance();
        for ( int i = 0; i < frame.objv.Length; i++ )
        {
          TclList.append( interp, list, TclString.newInstance( frame.objv[i] ) );
        }
        interp.setResult( list );
        return;
      }

      throw new TclNumArgsException( interp, 2, objv, "?number?" );
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoLibraryCmd --
    *
    *      Called to implement the "info library" command that returns the
    *      library directory for the Tcl installation. Handles the following
    *      syntax:
    *
    *          info library
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoLibraryCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }
      try
      {
        interp.setResult( interp.getVar( "tcl_library", TCL.VarFlag.GLOBAL_ONLY ) );
        return;
      }
      catch ( TclException e )
      {
        // If the variable has not been defined
        throw new TclException( interp, "no library has been specified for Tcl" );
      }
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoLoadedCmd --
    *
    *      Called to implement the "info loaded" command that returns the
    *      packages that have been loaded into an interpreter. Handles the
    *      following syntax:
    *
    *          info loaded ?interp?
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoLoadedCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 && objv.Length != 3 )
      {
        throw new TclNumArgsException( interp, 2, objv, "?interp?" );
      }
      // FIXME : what should "info loaded" return?
      throw new TclException( interp, "info loaded not implemented" );
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoLocalsCmd --
    *
    *      Called to implement the "info locals" command to return a list of
    *      local variables that match an optional pattern. Handles the
    *      following syntax:
    *
    *          info locals ?pattern?
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoLocalsCmd( Interp interp, TclObject[] objv )
    {
      string pattern;
      TclObject list;

      if ( objv.Length == 2 )
      {
        pattern = null;
      }
      else if ( objv.Length == 3 )
      {

        pattern = objv[2].ToString();
      }
      else
      {
        throw new TclNumArgsException( interp, 2, objv, "?pattern?" );
      }

      if ( interp.varFrame == null || !interp.varFrame.isProcCallFrame )
      {
        return;
      }

      // Return a list containing names of first the compiled locals (i.e. the
      // ones stored in the call frame), then the variables in the local hash
      // table (if one exists).

      list = TclList.newInstance();
      AppendLocals( interp, list, pattern, false );
      interp.setResult( list );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * AppendLocals --
    *
    *	Append the local variables for the current frame to the
    *	specified list object.
    *
    * Results:
    *	None.
    *
    * Side effects:
    *	None.
    *
    *----------------------------------------------------------------------
    */

    private static void AppendLocals( Interp interp, TclObject list, string pattern, bool includeLinks )
    {
      Var var;
      string varName;
      Hashtable localVarTable;
      IDictionaryEnumerator search;

      localVarTable = interp.varFrame.varTable;

      // Compiled locals do not exist in Jacl

      if ( localVarTable != null )
      {
        for ( search = localVarTable.GetEnumerator(); search.MoveNext(); )
        {
          var = (Var)search.Value;
          varName = (string)search.Key;
          if ( !var.isVarUndefined() && ( includeLinks || !var.isVarLink() ) )
          {
            if ( ( (System.Object)pattern == null ) || Util.stringMatch( varName, pattern ) )
            {
              TclList.append( interp, list, TclString.newInstance( varName ) );
            }
          }
        }
      }
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoNameOfExecutableCmd --
    *
    *      Called to implement the "info nameofexecutable" command that returns
    *      the name of the binary file running this application. Handles the
    *      following syntax:
    *
    *          info nameofexecutable
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoNameOfExecutableCmd( Interp interp, TclObject[] objv )
    {

      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }

      // We depend on a user defined property named "JAVA" since
      // the JDK provides no means to learn the name of the executable
      // that launched the application.

      string nameOfExecutable = "nacl";

      if ( (System.Object)nameOfExecutable != null )
      {
        TclObject result = TclList.newInstance();
        TclList.append( interp, result, TclString.newInstance( nameOfExecutable ) );
        TclList.append( interp, result, TclString.newInstance( "tcl.lang.Shell" ) );
        interp.setResult( result );
      }

      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoPatchLevelCmd --
    *
    *      Called to implement the "info patchlevel" command that returns the
    *      default value for an argument to a procedure. Handles the following
    *      syntax:
    *
    *          info patchlevel
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoPatchLevelCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }

      interp.setResult( interp.getVar( "tcl_patchLevel", TCL.VarFlag.GLOBAL_ONLY ) );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoProcsCmd --
    *
    *      Called to implement the "info procs" command that returns the
    *      procedures in the current namespace that match an optional pattern.
    *      Handles the following syntax:
    *
    *          info procs ?pattern?
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoProcsCmd( Interp interp, TclObject[] objv )
    {
      string cmdName, pattern;
      NamespaceCmd.Namespace currNs = NamespaceCmd.getCurrentNamespace( interp );
      IDictionaryEnumerator search;
      WrappedCommand cmd, realCmd;
      TclObject list;

      if ( objv.Length == 2 )
      {
        pattern = null;
      }
      else if ( objv.Length == 3 )
      {

        pattern = objv[2].ToString();
      }
      else
      {
        throw new TclNumArgsException( interp, 2, objv, "?pattern?" );
      }

      // Scan through the current namespace's command table and return a list
      // of all procs that match the pattern.

      list = TclList.newInstance();
      for ( search = currNs.cmdTable.GetEnumerator(); search.MoveNext(); )
      {
        cmdName = ( (string)search.Key );
        cmd = (WrappedCommand)search.Value;

        // If the command isn't itself a proc, it still might be an
        // imported command that points to a "real" proc in a different
        // namespace.

        realCmd = NamespaceCmd.getOriginalCommand( cmd );

        if ( Procedure.isProc( cmd ) || ( ( realCmd != null ) && Procedure.isProc( realCmd ) ) )
        {
          if ( ( (System.Object)pattern == null ) || Util.stringMatch( cmdName, pattern ) )
          {
            TclList.append( interp, list, TclString.newInstance( cmdName ) );
          }
        }
      }

      interp.setResult( list );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoScriptCmd --
    *
    *      Called to implement the "info script" command that returns the
    *      script file that is currently being evaluated. Handles the
    *      following syntax:
    *
    *          info script
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoScriptCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }

      interp.setResult( interp.scriptFile );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoSharedlibCmd --
    *
    *      Called to implement the "info sharedlibextension" command that
    *      returns the file extension used for shared libraries. Handles the
    *      following syntax:
    *
    *          info sharedlibextension
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoSharedlibCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }
      interp.setResult( ".jar" );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoTclVersionCmd --
    *
    *      Called to implement the "info tclversion" command that returns the
    *      version number for this Tcl library. Handles the following syntax:
    *
    *          info tclversion
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoTclVersionCmd( Interp interp, TclObject[] objv )
    {
      if ( objv.Length != 2 )
      {
        throw new TclNumArgsException( interp, 2, objv, null );
      }

      interp.setResult( interp.getVar( "tcl_version", TCL.VarFlag.GLOBAL_ONLY ) );
      return;
    }

    /*
    *----------------------------------------------------------------------
    *
    * InfoVarsCmd --
    *
    *	Called to implement the "info vars" command that returns the
    *	list of variables in the interpreter that match an optional pattern.
    *	The pattern, if any, consists of an optional sequence of namespace
    *	names separated by "::" qualifiers, which is followed by a
    *	glob-style pattern that restricts which variables are returned.
    *	Handles the following syntax:
    *
    *          info vars ?pattern?
    *
    * Results:
    *      Returns if successful, raises TclException otherwise.
    *
    * Side effects:
    *      Returns a result in the interpreter's result object.
    *
    *----------------------------------------------------------------------
    */

    private static void InfoVarsCmd( Interp interp, TclObject[] objv )
    {
      string varName, pattern, simplePattern;
      IDictionaryEnumerator search;
      Var var;
      NamespaceCmd.Namespace ns;
      NamespaceCmd.Namespace globalNs = NamespaceCmd.getGlobalNamespace( interp );
      NamespaceCmd.Namespace currNs = NamespaceCmd.getCurrentNamespace( interp );
      TclObject list, elemObj;
      bool specificNsInPattern = false; // Init. to avoid compiler warning.

      // Get the pattern and find the "effective namespace" in which to
      // list variables. We only use this effective namespace if there's
      // no active Tcl procedure frame.

      if ( objv.Length == 2 )
      {
        simplePattern = null;
        ns = currNs;
        specificNsInPattern = false;
      }
      else if ( objv.Length == 3 )
      {
        // From the pattern, get the effective namespace and the simple
        // pattern (no namespace qualifiers or ::'s) at the end. If an
        // error was found while parsing the pattern, return it. Otherwise,
        // if the namespace wasn't found, just leave ns = null: we will
        // return an empty list since no variables there can be found.


        pattern = objv[2].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[] dummy1Arr = new NamespaceCmd.Namespace[1];
        NamespaceCmd.Namespace[] dummy2Arr = new NamespaceCmd.Namespace[1];
        string[] simplePatternArr = new string[1];

        NamespaceCmd.getNamespaceForQualName( interp, pattern, null, 0, nsArr, dummy1Arr, dummy2Arr, simplePatternArr );

        // Get the values out of the arrays!
        ns = nsArr[0];
        simplePattern = simplePatternArr[0];

        if ( ns != null )
        {
          // we successfully found the pattern's ns
          specificNsInPattern = ( simplePattern.CompareTo( pattern ) != 0 );
        }
      }
      else
      {
        throw new TclNumArgsException( interp, 2, objv, "?pattern?" );
      }

      // If the namespace specified in the pattern wasn't found, just return.

      if ( ns == null )
      {
        return;
      }

      list = TclList.newInstance();

      if ( ( interp.varFrame == null ) || !interp.varFrame.isProcCallFrame || specificNsInPattern )
      {
        // There is no frame pointer, the frame pointer was pushed only
        // to activate a namespace, or we are in a procedure call frame
        // but a specific namespace was specified. Create a list containing
        // only the variables in the effective namespace's variable table.

        search = ns.varTable.GetEnumerator();
        while ( search.MoveNext() )
        {
          varName = ( (string)search.Key );
          var = (Var)search.Value;
          if ( !var.isVarUndefined() || ( ( var.flags & VarFlags.NAMESPACE_VAR ) != 0 ) )
          {
            if ( ( (System.Object)simplePattern == null ) || Util.stringMatch( varName, simplePattern ) )
            {
              if ( specificNsInPattern )
              {
                elemObj = TclString.newInstance( Var.getVariableFullName( interp, var ) );
              }
              else
              {
                elemObj = TclString.newInstance( varName );
              }
              TclList.append( interp, list, elemObj );
            }
          }
        }

        // If the effective namespace isn't the global :: namespace, and a
        // specific namespace wasn't requested in the pattern (i.e., the
        // pattern only specifies variable names), then add in all global ::
        // variables that match the simple pattern. Of course, add in only
        // those variables that aren't hidden by a variable in the effective
        // namespace.

        if ( ( ns != globalNs ) && !specificNsInPattern )
        {
          search = globalNs.varTable.GetEnumerator();
          while ( search.MoveNext() )
          {
            varName = ( (string)search.Key );
            var = (Var)search.Value;
            if ( !var.isVarUndefined() || ( ( var.flags & VarFlags.NAMESPACE_VAR ) != 0 ) )
            {
              if ( ( (System.Object)simplePattern == null ) || Util.stringMatch( varName, simplePattern ) )
              {

                // Skip vars defined in current namespace
                if ( ns.varTable[varName] == null )
                {
                  TclList.append( interp, list, TclString.newInstance( varName ) );
                }
              }
            }
          }
        }
      }
      else
      {
        AppendLocals( interp, list, simplePattern, true );
      }

      interp.setResult( list );
      return;
    }
  }
}