wasCSharpSQLite – Rev 1
?pathlinks?
/*
* 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;
}
}
}