public static bool Tcl_SetCommandInfo(Interp interp, string command, WrappedCommand value)
{
try
{
value = interp.getObjCommand(command);
return(false);
}
catch
{
return(true);
}
}
/// <summary>----------------------------------------------------------------------
///
/// disposeCmd --
///
/// Invoked when an object command for a slave interpreter is deleted;
/// cleans up all state associated with the slave interpreter and destroys
/// the slave interpreter.
///
/// Results:
/// None.
///
/// Side effects:
/// Cleans up all state associated with the slave interpreter and
/// destroys the slave interpreter.
///
/// ----------------------------------------------------------------------
/// </summary>
public void disposeCmd()
{
// Unlink the slave from its master interpreter.
SupportClass.HashtableRemove(masterInterp.slaveTable, path);
// Set to null so that when the InterpInfo is cleaned up in the slave
// it does not try to delete the command causing all sorts of grief.
// See SlaveRecordDeleteProc().
interpCmd = null;
if (slaveInterp != null)
{
slaveInterp.dispose();
}
}
internal static bool isProc(WrappedCommand cmd)
{
return(cmd.cmd is Procedure);
/*
* // FIXME: do we really want to get the original command
* // and test that? Methods like InfoCmd.InfoProcsCmd seem
* // to do this already.
*
* WrappedCommand origCmd;
*
* origCmd = NamespaceCmd.getOriginalCommand(cmd);
* if (origCmd != null) {
* cmd = origCmd;
* }
* return (cmd.cmd instanceof Procedure);
*/
}
/// <summary>----------------------------------------------------------------------
///
/// disposeCmd --
///
/// Invoked when an object command for a slave interpreter is deleted;
/// cleans up all state associated with the slave interpreter and destroys
/// the slave interpreter.
///
/// Results:
/// None.
///
/// Side effects:
/// Cleans up all state associated with the slave interpreter and
/// destroys the slave interpreter.
///
/// ----------------------------------------------------------------------
/// </summary>
public void disposeCmd()
{
// Unlink the slave from its master interpreter.
SupportClass.HashtableRemove( masterInterp.slaveTable, path );
// Set to null so that when the InterpInfo is cleaned up in the slave
// it does not try to delete the command causing all sorts of grief.
// See SlaveRecordDeleteProc().
interpCmd = null;
if ( slaveInterp != null )
{
slaveInterp.dispose();
}
}
internal static bool isProc( WrappedCommand cmd )
{
return ( cmd.cmd is Procedure );
/*
// FIXME: do we really want to get the original command
// and test that? Methods like InfoCmd.InfoProcsCmd seem
// to do this already.
WrappedCommand origCmd;
origCmd = NamespaceCmd.getOriginalCommand(cmd);
if (origCmd != null) {
cmd = origCmd;
}
return (cmd.cmd instanceof Procedure);
*/
}
public void createObjCommand( string cmdName, dxObjCmdProc proc, object clientData, dxCmdDeleteProc deleteProc )
// Command object to associate with cmdName.
{
ImportRef oldRef = null;
NamespaceCmd.Namespace ns;
WrappedCommand cmd, refCmd;
string tail;
ImportedCmdData data;
int _new;
if ( deleted )
{
// The interpreter is being deleted. Don't create any new
// commands; it's not safe to muck with the interpreter anymore.
return;
}
// Determine where the command should reside. If its name contains
// namespace qualifiers, we put it in the specified namespace;
// otherwise, we always put it in the global namespace.
if ( cmdName.IndexOf( "::" ) != -1 )
{
// 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[] dummyArr = new NamespaceCmd.Namespace[1];
string[] tailArr = new string[1];
NamespaceCmd.getNamespaceForQualName( this, cmdName, null, TCL.VarFlag.CREATE_NS_IF_UNKNOWN, nsArr, dummyArr, dummyArr, tailArr );
ns = nsArr[0];
tail = tailArr[0];
if ( ( ns == null ) || ( (System.Object)tail == null ) )
{
return;
}
}
else
{
ns = globalNs;
tail = cmdName;
}
cmd = (WrappedCommand)ns.cmdTable[tail];
if ( cmd != null )
{
/*
* Command already exists. If its object-based Tcl_ObjCmdProc is
* TclInvokeStringCommand, we just set its Tcl_ObjCmdProc to the
* argument "proc". Otherwise, we delete the old command.
*/
if ( cmd.objProc != null && cmd.objProc.GetType().Name == "TclInvokeStringCommand" )
{
cmd.objProc = proc;
cmd.objClientData = clientData;
cmd.deleteProc = deleteProc;
cmd.deleteData = clientData;
return;
}
/*
* Otherwise, we delete the old command. Be careful to preserve
* any existing import links so we can restore them down below.
* That way, you can redefine a command and its import status
* will remain intact.
*/
oldRef = cmd.importRef;
cmd.importRef = null;
deleteCommandFromToken( cmd );
// FIXME : create a test case for this condition!
cmd = (WrappedCommand)ns.cmdTable[tail];
if ( cmd != null )
{
// If the deletion callback recreated the command, just throw
// away the new command (if we try to delete it again, we
// could get stuck in an infinite loop).
SupportClass.HashtableRemove( cmd.table, cmd.hashKey );
}
}
cmd = new WrappedCommand();
ns.cmdTable.Add( tail, cmd );
cmd.table = ns.cmdTable;
cmd.hashKey = tail;
cmd.ns = ns;
cmd.cmd = null;
cmd.deleted = false;
// FIXME : import feature not implemented
//cmd.importRef = null;
// TODO -- Determine if this is all correct
cmd.objProc = proc;
cmd.objClientData = clientData;
//cmd.proc = TclInvokeObjectCommand;
cmd.clientData = (object)cmd;
cmd.deleteProc = deleteProc;
cmd.deleteData = clientData;
cmd.flags = 0;
// Plug in any existing import references found above. Be sure
// to update all of these references to point to the new command.
if ( oldRef != null )
{
cmd.importRef = oldRef;
while ( oldRef != null )
{
refCmd = oldRef.importedCmd;
data = (ImportedCmdData)refCmd.cmd;
data.realCmd = cmd;
oldRef = oldRef.next;
}
}
// There are no shadowed commands in Jacl because they are only
// used in the 8.0 compiler
return;
}
internal void preventAliasLoop( Interp cmdInterp, WrappedCommand cmd )
{
// If we are not creating or renaming an alias, then it is
// always OK to create or rename the command.
if ( !( cmd.cmd is InterpAliasCmd ) )
{
return;
}
// OK, we are dealing with an alias, so traverse the chain of aliases.
// If we encounter the alias we are defining (or renaming to) any in
// the chain then we have a loop.
InterpAliasCmd alias = (InterpAliasCmd)cmd.cmd;
InterpAliasCmd nextAlias = alias;
while ( true )
{
// If the target of the next alias in the chain is the same as
// the source alias, we have a loop.
WrappedCommand aliasCmd = nextAlias.getTargetCmd( this );
if ( aliasCmd == null )
{
return;
}
if ( aliasCmd.cmd == cmd.cmd )
{
throw new TclException( this, "cannot define or rename alias \"" + alias.name + "\": would create a loop" );
}
// Otherwise, follow the chain one step further. See if the target
// command is an alias - if so, follow the loop to its target
// command. Otherwise we do not have a loop.
if ( !( aliasCmd.cmd is InterpAliasCmd ) )
{
return;
}
nextAlias = (InterpAliasCmd)aliasCmd.cmd;
}
}
protected internal int deleteCommandFromToken( WrappedCommand cmd )
// Wrapper Token for command to delete.
{
if ( cmd == null )
{
return -1;
}
ImportRef ref_Renamed, nextRef;
WrappedCommand importCmd;
// The code here is tricky. We can't delete the hash table entry
// before invoking the deletion callback because there are cases
// where the deletion callback needs to invoke the command (e.g.
// object systems such as OTcl). However, this means that the
// callback could try to delete or rename the command. The deleted
// flag allows us to detect these cases and skip nested deletes.
if ( cmd.deleted )
{
// Another deletion is already in progress. Remove the hash
// table entry now, but don't invoke a callback or free the
// command structure.
if ( (System.Object)cmd.hashKey != null && cmd.table != null )
{
SupportClass.HashtableRemove( cmd.table, cmd.hashKey );
cmd.table = null;
cmd.hashKey = null;
}
return 0;
}
cmd.deleted = true;
if ( cmd.cmd is CommandWithDispose )
{
( (CommandWithDispose)cmd.cmd ).disposeCmd();
}
if ( cmd.deleteProc != null )
{
cmd.deleteProc( ref cmd.objClientData );
}
// If this command was imported into other namespaces, then imported
// commands were created that refer back to this command. Delete these
// imported commands now.
for ( ref_Renamed = cmd.importRef; ref_Renamed != null; ref_Renamed = nextRef )
{
nextRef = ref_Renamed.next;
importCmd = ref_Renamed.importedCmd;
deleteCommandFromToken( importCmd );
}
// FIXME : what does this mean? Is this a mistake in the C comment?
// Don't use hPtr to delete the hash entry here, because it's
// possible that the deletion callback renamed the command.
// Instead, use cmdPtr->hptr, and make sure that no-one else
// has already deleted the hash entry.
if ( cmd.table != null )
{
SupportClass.HashtableRemove( cmd.table, cmd.hashKey );
cmd.table = null;
cmd.hashKey = null;
}
// Drop the reference to the Command instance inside the WrappedCommand
cmd.cmd = null;
// We do not need to cleanup the WrappedCommand because GC will get it.
return 0;
}
internal string getCommandFullName( WrappedCommand cmd )
// Token for the command.
{
Interp interp = this;
StringBuilder name = new StringBuilder();
// Add the full name of the containing namespace, followed by the "::"
// separator, and the command name.
if ( cmd != null )
{
if ( cmd.ns != null )
{
name.Append( cmd.ns.fullName );
if ( cmd.ns != interp.globalNs )
{
name.Append( "::" );
}
}
if ( cmd.table != null )
{
name.Append( cmd.hashKey );
}
}
return name.ToString();
}
/*
*----------------------------------------------------------------------
*
* TclGetOriginalCommand -> getOriginalCommand
*
* An imported command is created in a namespace when a "real" command
* is imported from another namespace. If the specified command is an
* imported command, this procedure returns the original command it
* refers to.
*
* Results:
* If the command was imported into a sequence of namespaces a, b,...,n
* where each successive namespace just imports the command from the
* previous namespace, this procedure returns the Tcl_Command token in
* the first namespace, a. Otherwise, if the specified command is not
* an imported command, the procedure returns null.
*
* Side effects:
* None.
*
*----------------------------------------------------------------------
*/
internal static WrappedCommand getOriginalCommand(WrappedCommand command)
{
WrappedCommand cmd = command;
ImportedCmdData data;
if (!(cmd.cmd is ImportedCmdData))
{
return null;
}
while (cmd.cmd is ImportedCmdData)
{
data = (ImportedCmdData) cmd.cmd;
cmd = data.realCmd;
}
return cmd;
}
static object sqlite3TestTextToPtr( Tcl_Interp interp, string z )
{
//object p ;
//u64[] v = new u64[1];
//u32 v2;
//int zIndex = 0;
//if ( z[0] == '0' && z[1] == 'x' )
//{
// zIndex += 2;
//}
//v[0] = 0;
//while ( zIndex < z.Length )* z )
//{
// v[0] = ( v[0] << 4 ) + (ulong)testHexToInt( z[zIndex] );
// zIndex++;
//}
//if ( sizeof( object ) == sizeof( u64 ) )
//{
// Marshal.Copy( v, 0, (IntPtr)p, 1 );// memcpy( &p, v, sizeof( p ) );
//}
//else
//{
// Debug.Assert( sizeof( p ) == sizeof( v2 ) );
// v2 = (u32)v;
// memcpy( &p, v2, sizeof( p ) );
//}
WrappedCommand cmdInfo = new WrappedCommand();
if ( TCL.Tcl_GetCommandInfo( interp, z, ref cmdInfo ) || cmdInfo == null )
{ return null; }
else
{
return cmdInfo.objClientData;
}
}
/*
** Decode a pointer to an sqlite3_stmt object.
*/
static int getStmtPointer(
Tcl_Interp interp,
string zArg,
ref sqlite3_stmt ppStmt
)
{
ppStmt = (sqlite3_stmt)sqlite3TestTextToPtr( interp, zArg );
WrappedCommand cmdInfo = new WrappedCommand();
if ( !TCL.Tcl_GetCommandInfo( interp, zArg, ref cmdInfo ) )
{
ppStmt = cmdInfo == null ? null : (sqlite3_stmt)cmdInfo.objClientData; ;
}
else
{
Debugger.Break();
}
return TCL.TCL_OK;
}
/*
** Decode a pointer to an sqlite3 object.
*/
static int getDbPointer( Tcl_Interp interp, string zA, ref sqlite3 ppDb )
{
SqliteDb p;
WrappedCommand cmdInfo = new WrappedCommand();
if ( !TCL.Tcl_GetCommandInfo( interp, zA, ref cmdInfo ) )
{
if ( cmdInfo == null )
{
ppDb = new sqlite3();
}
else
{
p = (SqliteDb)cmdInfo.objClientData;
ppDb = p.db;
}
}
else
{
Debugger.Break();// ppDb = (sqlite3)sqlite3TestTextToPtr( zA );
}
return TCL.TCL_OK;
}
/*
** Decode a pointer to an sqlite3_stmt object.
*/
static int getStmtPointer(
Tcl_Interp interp,
string zArg,
out sqlite3_stmt ppStmt
)
{
ppStmt = (sqlite3_stmt)sqlite3TestTextToPtr( interp, zArg );
WrappedCommand cmdInfo = new WrappedCommand();
TCL.Tcl_GetCommandInfo( interp, zArg, out cmdInfo );
ppStmt = cmdInfo == null ? null : (sqlite3_stmt)cmdInfo.objClientData;
return TCL.TCL_OK;
}
/*
** Decode a pointer to an sqlite3 object.
*/
static int getDbPointer( Tcl_Interp interp, string zA, out sqlite3 ppDb )
{
SqliteDb p;
WrappedCommand cmdInfo = new WrappedCommand();
if ( !TCL.Tcl_GetCommandInfo( interp, zA, out cmdInfo ) )
{
if ( cmdInfo == null )
{
ppDb = new sqlite3();
}
else
{
p = (SqliteDb)cmdInfo.objClientData;
ppDb = p.db;
}
}
else
{
ppDb = null;
}
return TCL.TCL_OK;
}
