/*
* InterpSlaveCmd.java --
*
*	Implements the built-in "interp" Tcl command.
*
* Copyright (c) 2000 Christian Krone.
*
* 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: InterpSlaveCmd.java,v 1.1 2000/08/20 06:08:43 mo Exp $
*
*/
using System;
using System.Collections;

namespace tcl.lang
{

  /// <summary> This class implements the slave interpreter commands, which are created
  /// in response to the built-in "interp create" command in Tcl.
  /// 
  /// It is also used by the "interp" command to record and find information
  /// about slave interpreters. Maps from a command name in the master to
  /// information about a slave interpreter, e.g. what aliases are defined
  /// in it.
  /// </summary>

  class InterpSlaveCmd : CommandWithDispose, AssocData
  {

    private static readonly string[] options = new string[] { "alias", "aliases", "eval", "expose", "hide", "hidden", "issafe", "invokehidden", "marktrusted" };
    private const int OPT_ALIAS = 0;
    private const int OPT_ALIASES = 1;
    private const int OPT_EVAL = 2;
    private const int OPT_EXPOSE = 3;
    private const int OPT_HIDE = 4;
    private const int OPT_HIDDEN = 5;
    private const int OPT_ISSAFE = 6;
    private const int OPT_INVOKEHIDDEN = 7;
    private const int OPT_MARKTRUSTED = 8;

    private static readonly string[] hiddenOptions = new string[] { "-global", "--" };
    private const int OPT_HIDDEN_GLOBAL = 0;
    private const int OPT_HIDDEN_LAST = 1;

    // Master interpreter for this slave.

    internal Interp masterInterp;

    // Hash entry in masters slave table for this slave interpreter.
    // Used to find this record, and used when deleting the slave interpreter
    // to delete it from the master's table.

    internal string path;

    // The slave interpreter.

    internal Interp slaveInterp;

    // Interpreter object command.

    internal WrappedCommand interpCmd;
    public TCL.CompletionCode cmdProc( Interp interp, TclObject[] objv )
    {
      if ( objv.Length < 2 )
      {
        throw new TclNumArgsException( interp, 1, objv, "cmd ?arg ...?" );
      }
      int cmd = TclIndex.get( interp, objv[1], options, "option", 0 );

      switch ( cmd )
      {

        case OPT_ALIAS:
          if ( objv.Length == 3 )
          {
            InterpAliasCmd.describe( interp, slaveInterp, objv[2] );
            return TCL.CompletionCode.RETURN;
          }

          if ( "".Equals( objv[3].ToString() ) )
          {
            if ( objv.Length == 4 )
            {
              InterpAliasCmd.delete( interp, slaveInterp, objv[2] );
              return TCL.CompletionCode.RETURN;
            }
          }
          else
          {
            InterpAliasCmd.create( interp, slaveInterp, interp, objv[2], objv[3], 4, objv );
            return TCL.CompletionCode.RETURN;
          }
          throw new TclNumArgsException( interp, 2, objv, "aliasName ?targetName? ?args..?" );

        case OPT_ALIASES:
          InterpAliasCmd.list( interp, slaveInterp );
          break;

        case OPT_EVAL:
          if ( objv.Length < 3 )
          {
            throw new TclNumArgsException( interp, 2, objv, "arg ?arg ...?" );
          }
          eval( interp, slaveInterp, 2, objv );
          break;

        case OPT_EXPOSE:
          if ( objv.Length < 3 || objv.Length > 4 )
          {
            throw new TclNumArgsException( interp, 2, objv, "hiddenCmdName ?cmdName?" );
          }
          expose( interp, slaveInterp, 2, objv );
          break;

        case OPT_HIDE:
          if ( objv.Length < 3 || objv.Length > 4 )
          {
            throw new TclNumArgsException( interp, 2, objv, "cmdName ?hiddenCmdName?" );
          }
          hide( interp, slaveInterp, 2, objv );
          break;

        case OPT_HIDDEN:
          if ( objv.Length != 2 )
          {
            throw new TclNumArgsException( interp, 2, objv, null );
          }
          InterpSlaveCmd.hidden( interp, slaveInterp );
          break;

        case OPT_ISSAFE:
          interp.setResult( slaveInterp.isSafe );
          break;

        case OPT_INVOKEHIDDEN:
          bool global = false;
          int i;
          for ( i = 2; i < objv.Length; i++ )
          {

            if ( objv[i].ToString()[0] != '-' )
            {
              break;
            }
            int index = TclIndex.get( interp, objv[i], hiddenOptions, "option", 0 );
            if ( index == OPT_HIDDEN_GLOBAL )
            {
              global = true;
            }
            else
            {
              i++;
              break;
            }
          }
          if ( objv.Length - i < 1 )
          {
            throw new TclNumArgsException( interp, 2, objv, "?-global? ?--? cmd ?arg ..?" );
          }
          InterpSlaveCmd.invokeHidden( interp, slaveInterp, global, i, objv );
          break;

        case OPT_MARKTRUSTED:
          if ( objv.Length != 2 )
          {
            throw new TclNumArgsException( interp, 2, objv, null );
          }
          markTrusted( interp, slaveInterp );
          break;
      }
      return TCL.CompletionCode.RETURN;
    }
    /// <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();
      }
    }
    public void disposeAssocData( Interp interp )
    // Current interpreter.
    {
      // There shouldn't be any commands left.

      if ( !( interp.slaveTable.Count == 0 ) )
      {
        System.Console.Error.WriteLine( "InterpInfoDeleteProc: still exist commands" );
      }
      interp.slaveTable = null;

      // Tell any interps that have aliases to this interp that they should
      // delete those aliases.  If the other interp was already dead, it
      // would have removed the target record already. 

      // TODO ATK
      foreach ( WrappedCommand slaveCmd in new ArrayList( interp.targetTable.Keys ) )
      {
        Interp slaveInterp = (Interp)interp.targetTable[slaveCmd];
        slaveInterp.deleteCommandFromToken( slaveCmd );
      }
      interp.targetTable = null;

      if ( interp.interpChanTable != null )
      {
        foreach ( Channel channel in new ArrayList( interp.interpChanTable.Values ) )
        {
          TclIO.unregisterChannel( interp, channel );
        }
      }

      if ( interp.slave.interpCmd != null )
      {
        // Tcl_DeleteInterp() was called on this interpreter, rather
        // "interp delete" or the equivalent deletion of the command in the
        // master.  First ensure that the cleanup callback doesn't try to
        // delete the interp again.

        interp.slave.slaveInterp = null;
        interp.slave.masterInterp.deleteCommandFromToken( interp.slave.interpCmd );
      }

      // There shouldn't be any aliases left.

      if ( !( interp.aliasTable.Count == 0 ) )
      {
        System.Console.Error.WriteLine( "InterpInfoDeleteProc: still exist aliases" );
      }
      interp.aliasTable = null;
    }
    internal static Interp create( Interp interp, TclObject path, bool safe )
    {
      Interp masterInterp;
      string pathString;

      TclObject[] objv = TclList.getElements( interp, path );

      if ( objv.Length < 2 )
      {
        masterInterp = interp;

        pathString = path.ToString();
      }
      else
      {
        TclObject obj = TclList.newInstance();

        TclList.insert( interp, obj, 0, objv, 0, objv.Length - 2 );
        masterInterp = InterpCmd.getInterp( interp, obj );

        pathString = objv[objv.Length - 1].ToString();
      }
      if ( !safe )
      {
        safe = masterInterp.isSafe;
      }

      if ( masterInterp.slaveTable.ContainsKey( pathString ) )
      {
        throw new TclException( interp, "interpreter named \"" + pathString + "\" already exists, cannot create" );
      }

      Interp slaveInterp = new Interp();
      InterpSlaveCmd slave = new InterpSlaveCmd();

      slaveInterp.slave = slave;
      slaveInterp.setAssocData( "InterpSlaveCmd", slave );

      slave.masterInterp = masterInterp;
      slave.path = pathString;
      slave.slaveInterp = slaveInterp;

      masterInterp.createCommand( pathString, slaveInterp.slave );
      slaveInterp.slave.interpCmd = NamespaceCmd.findCommand( masterInterp, pathString, null, 0 );

      SupportClass.PutElement( masterInterp.slaveTable, pathString, slaveInterp.slave );

      slaveInterp.setVar( "tcl_interactive", "0", TCL.VarFlag.GLOBAL_ONLY );

      // Inherit the recursion limit.

      slaveInterp.maxNestingDepth = masterInterp.maxNestingDepth;

      if ( safe )
      {
        try
        {
          makeSafe( slaveInterp );
        }
        catch ( TclException e )
        {
          SupportClass.WriteStackTrace( e, Console.Error );
        }
      }
      else
      {
        //Tcl_Init(slaveInterp);
      }

      return slaveInterp;
    }
    internal static void eval( Interp interp, Interp slaveInterp, int objIx, TclObject[] objv )
    {
      TCL.CompletionCode result;

      slaveInterp.preserve();
      slaveInterp.allowExceptions();

      try
      {
        if ( objIx + 1 == objv.Length )
        {
          slaveInterp.eval( objv[objIx], 0 );
        }
        else
        {
          TclObject obj = TclList.newInstance();
          for ( int ix = objIx; ix < objv.Length; ix++ )
          {
            TclList.append( interp, obj, objv[ix] );
          }
          obj.preserve();
          slaveInterp.eval( obj, 0 );
          obj.release();
        }
        result = slaveInterp.returnCode;
      }
      catch ( TclException e )
      {
        result = e.getCompletionCode();
      }

      slaveInterp.release();
      interp.transferResult( slaveInterp, result );
    }
    internal static void expose( Interp interp, Interp slaveInterp, int objIx, TclObject[] objv )
    {
      if ( interp.isSafe )
      {
        throw new TclException( interp, "permission denied: " + "safe interpreter cannot expose commands" );
      }

      int nameIdx = objv.Length - objIx == 1 ? objIx : objIx + 1;

      try
      {

        slaveInterp.exposeCommand( objv[objIx].ToString(), objv[nameIdx].ToString() );
      }
      catch ( TclException e )
      {
        interp.transferResult( slaveInterp, e.getCompletionCode() );
        throw;
      }
    }
    internal static void hide( Interp interp, Interp slaveInterp, int objIx, TclObject[] objv )
    {
      if ( interp.isSafe )
      {
        throw new TclException( interp, "permission denied: " + "safe interpreter cannot hide commands" );
      }

      int nameIdx = objv.Length - objIx == 1 ? objIx : objIx + 1;

      try
      {

        slaveInterp.hideCommand( objv[objIx].ToString(), objv[nameIdx].ToString() );
      }
      catch ( TclException e )
      {
        interp.transferResult( slaveInterp, e.getCompletionCode() );
        throw;
      }
    }
    internal static void hidden( Interp interp, Interp slaveInterp )
    {
      if ( slaveInterp.hiddenCmdTable == null )
      {
        return;
      }

      TclObject result = TclList.newInstance();
      interp.setResult( result );

      IEnumerator hiddenCmds = slaveInterp.hiddenCmdTable.Keys.GetEnumerator();
      while ( hiddenCmds.MoveNext() )
      {
        string cmdName = (string)hiddenCmds.Current;
        TclList.append( interp, result, TclString.newInstance( cmdName ) );
      }
    }
    internal static void invokeHidden( Interp interp, Interp slaveInterp, bool global, int objIx, TclObject[] objv )
    {
      TCL.CompletionCode result;

      if ( interp.isSafe )
      {
        throw new TclException( interp, "not allowed to " + "invoke hidden commands from safe interpreter" );
      }

      slaveInterp.preserve();
      slaveInterp.allowExceptions();

      TclObject[] localObjv = new TclObject[objv.Length - objIx];
      for ( int i = 0; i < objv.Length - objIx; i++ )
      {
        localObjv[i] = objv[i + objIx];
      }

      try
      {
        if ( global )
        {
          slaveInterp.invokeGlobal( localObjv, Interp.INVOKE_HIDDEN );
        }
        else
        {
          slaveInterp.invoke( localObjv, Interp.INVOKE_HIDDEN );
        }
        result = slaveInterp.returnCode;
      }
      catch ( TclException e )
      {
        result = e.getCompletionCode();
      }

      slaveInterp.release();
      interp.transferResult( slaveInterp, result );
    }
    internal static void markTrusted( Interp interp, Interp slaveInterp )
    {
      if ( interp.isSafe )
      {
        throw new TclException( interp, "permission denied: " + "safe interpreter cannot mark trusted" );
      }
      slaveInterp.isSafe = false;
    }
    private static void makeSafe( Interp interp )
    {
      Channel chan; // Channel to remove from safe interpreter.

      interp.hideUnsafeCommands();

      interp.isSafe = true;

      //  Unsetting variables : (which should not have been set 
      //  in the first place, but...)

      // No env array in a safe slave.

      try
      {
        interp.unsetVar( "env", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }

      // Remove unsafe parts of tcl_platform

      try
      {
        interp.unsetVar( "tcl_platform", "os", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }
      try
      {
        interp.unsetVar( "tcl_platform", "osVersion", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }
      try
      {
        interp.unsetVar( "tcl_platform", "machine", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }
      try
      {
        interp.unsetVar( "tcl_platform", "user", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }

      // Unset path informations variables
      // (the only one remaining is [info nameofexecutable])

      try
      {
        interp.unsetVar( "tclDefaultLibrary", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }
      try
      {
        interp.unsetVar( "tcl_library", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }
      try
      {
        interp.unsetVar( "tcl_pkgPath", TCL.VarFlag.GLOBAL_ONLY );
      }
      catch ( TclException e )
      {
      }

      // Remove the standard channels from the interpreter; safe interpreters
      // do not ordinarily have access to stdin, stdout and stderr.
      //
      // NOTE: These channels are not added to the interpreter by the
      // Tcl_CreateInterp call, but may be added later, by another I/O
      // operation. We want to ensure that the interpreter does not have
      // these channels even if it is being made safe after being used for
      // some time..

      chan = TclIO.getStdChannel( StdChannel.STDIN );
      if ( chan != null )
      {
        TclIO.unregisterChannel( interp, chan );
      }
      chan = TclIO.getStdChannel( StdChannel.STDOUT );
      if ( chan != null )
      {
        TclIO.unregisterChannel( interp, chan );
      }
      chan = TclIO.getStdChannel( StdChannel.STDERR );
      if ( chan != null )
      {
        TclIO.unregisterChannel( interp, chan );
      }
    }
  } // end InterpSlaveCmd
}