/* exec.et
** Adapted from
**  D. Richard Hipp
**
** For the public domain...
*/
#include <tk.h>
#include <signal.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <stdlib.h>
#include <string.h>
#include <fcntl.h>
#include <stdio.h>
/* Interval between process check in milliseconds */
#define CHKPID_INTERVAL 100
/* Maximal number of registered processes */
#define MAXPROC 20

int InstallCommandsExec()
{
  ET_INSTALL_COMMANDS;
  return 0;
}

/* The following is the file descriptor used for communicating with the
** pseudo-tty and the process running on the other side of the pty. */
static int iChildFd;

/* Pids of Processes, 0 is Tty foreground process */


struct ProcessList {
  pid_t pid;
  char command[50];
} processList[MAXPROC];

int    noSigChld = 0; /* Number of sigchld Processes */
pid_t pidSigChld[10]; /* Pids of sigchld Processes */

/* File descriptors for background processes */
static int iFdOut[2];  /* Stdout pipe */
static int iFdErr[2];  /* Stderr pipe */

/* The following variables hold the width and height of the visible
** terminal screen, in characters.  These variables are linked to
** variables with the same name (expect the leading "i") in the Tcl/Tk
** code */
static int iWidth = 80;
static int iHeight = 24;

/* The following variables hold information about the current position
** of the cursor and the state of the virtual VT100 terminal.
**
** iCurX, iCurY     The location of the cursor in the text widget.  The
**                  text widgets address space is used.  This means that
**                  the top line is where iCurY==1 and the leftmost
**                  character is iCurX==0.  (The cursor is actually in the
**                  space immediately prior to iCurX,iCurY.)
**
** iBufX, iBufY     The place in the text widget where the text currently
**                  accumulating in zLineBuf[] should be written.
**
** iCurSavedX,      The saved location of the cursor.  Used by
** iCurSavedY       ESC-7 and ESC-8
**
** iBtm             The bottom line of text in the whole text widget.
**                  (This is NOT the bottom line of visible text.  The
**                  bottom line of visible text is iTop + iHeight).  This
**                  is always the same as "ET_INT(.t index end) - 1".
**
** iTop             The first line above the topmost visible line of text.
**                  This value can be 0 if the text widget is scrolled
**                  all the way to the top.  (This variable doesn't really
**                  exists.  It is used for commenting only.)
**
** xProcess         Pointer to the routine used to process the next
**                  character which is input to the vt100 emulator.
**
** iScrollTop,      The top and bottom of the scrolling region on the
** iScrollBtm       screen.  The numbers are stored as vt100 indices,
**                  so 1 means the top line and iHeight means the bottom
**                  line.   iScrollTop==1 && iScrollBtm==iHeight means
**                  the whole screen scrolls.
**
** bReplaceMode     If True, then new characters overwrite old ones.  When
**                  False, the new characters are inserted.
**
** iMaxLines        The number of lines of text to preserve in the scrollback.
*/
static int iBtm;              /* Bottom line of text in the text widget */
static int iCurX, iCurY;      /* X and Y coordinates of the cursor */
static int iBufX, iBufY;      /* X and Y coordinates at the beginning of
                              ** the line insertion buffer */
static int iCurSavedX,        /* Saved X and Y coordinates */
           iCurSavedY;
static void (*xProcess)(char);  /* Use this routine to process the next char */
static int iScrollTop = 1,    /* The bounds of the scrolling region */
           iScrollBtm = 24;  
static int bReplaceMode = 1;  /* True to overwrite characters */
static int iMaxLines = 1000;  /* Number of lines to preserve */ 

/* A NOTE ON INDEXING:
**
** The text widget calls its top line 1 and its leftmost character 0, but
** The vt100 escape codes use 1 for both the topmost and leftmost position.
** Furthermore, the vt100 position is relative to the topmost visible
** line of the screen, where the text widget refer to the topmost line 
** in the scrollback text.
**
** The following are invariants:
**
**        TextWidgetY = iCurY
**             Vt100Y = iCurY + iTop
**
**        TextWidgetX = iCurX
**             Vt100X = iCurX + 1
*/

/* Sanity checking
*/
#ifdef DEBUG
#define ASSERT(X)  if(!(X)){ShouldntHappen(__LINE__,__FILE__);}
#else
#define ASSERT(X)
#endif

/* The virtual VT100 mechanism uses line buffering to reduce the amount
** of calls to the text widget.  The following variables hold the line
** buffer.
*/
static char zLineBuf[200];
static int iBufWidth = 0;     /* Number of characters in the buffer */

/* The next variables are used to hold parameters specified in an
** ESC[Ps;Ps;...  control sequence.
*/
static int nParam;            /* Number of parameters seen */
static int aiParam[10];       /* Value of each parameter.  -1==default */

/* If the following variable is true, each character received by
** the vt100 emulator is printed on standard output.  This variable
** is linked to the Tcl/Tk variable named "Debug" so that it can
** be turned on and off using the "send" command. */
#ifdef DEBUG
static int bDebug = 0;
#endif

/* The following variables holds attributes of all characters which are
** to be inserted into the text widget
*/
static enum _BufTag {
  BT_Normal,
  BT_Underline,
  BT_Bold,
  BT_Inverse,
} eBufTag = BT_Normal;

#ifdef DEBUG
/* This routine should never be called */
static void ShouldntHappen(int line, char *file){
  fprintf(stderr,"Assertion failed on line %d of %s\n",line,file);
}
#endif

/* Forward declarations */
static void HandleTerm(void*,int);
static void HandleStdOut(void*,int);
static void HandleStdErr(void*,int);
/*###static Tcl_AsyncHandler asSigchld;*/
/*###static void CatchDeathOfChild(int nonsense);*/
/*###static Tcl_AsyncProc HandleSigchld;*/
static void chkpids(ClientData);
void CleanKill(void);
static int StopTty();

/* Procedures defined in getpty.c */
extern int RunCommand(char *, char **, int, int*);
extern void KillChildProcess(void);

void DebugProcessList()
{
  int i;
  fprintf(stderr, "Process list:\n");
  for (i = 0; i < 20; i++) {
    if (processList[i].pid)
      fprintf(stderr, "%6d %s\n", processList[i].pid, processList[i].command);
  }
  fprintf(stderr, "-------------\n");
}

void NewProcess(pid_t pid, char *command)
{
  int i;

#ifdef DEBUG
  fprintf(stderr, "NewProcess: %d %s\n", pid, command);
#endif
  for (i = 1; i < 20 && processList[i].pid; i++); 
  if (i < 20) {
    processList[i].pid = pid;
    strncpy(processList[i].command, command, 49);
    processList[i].command[49] = '\0';
    return;
  }
#ifdef DEBUG
  DebugProcessList();
#endif
}

void FreeProcess(pid_t pid) 
{
  int i;

#ifdef DEBUG
  fprintf(stderr, "FreeProcess: %d\n", pid);
  DebugProcessList();
#endif
  for (i = 0; i < MAXPROC; i++) {
    if (processList[i].pid == pid) {
      processList[i].pid = 0;
#ifdef DEBUG
      DebugProcessList();
#endif
      return;
    }
  }
}

void KillAllProcesses()
{
  int i;

  for (i = 0; i < MAXPROC; i++) {
    if (processList[i].pid > 0) {
#ifdef DEBUG
      fprintf(stderr, "KillAllProcesses: Kill %d %s\n", 
        processList[i].pid, processList[i].command);
#endif
      kill(processList[i].pid, SIGKILL);
    }
  }
}

/* Tcl/Tk will sometimes attempt to change environment variables.  Hence,
** the following string must be writeable -- it cannot be a string literal
** because string literals are read-only.
*/
static char zTermEnv[] = "TERM=xterm";

int CreateTerm()
{
  static void ProcessNormal(char);
  int i;

  Tcl_LinkVar(Et_Interp,"Width",(char*)&iWidth,TCL_LINK_INT);
  Tcl_LinkVar(Et_Interp,"Height",(char*)&iHeight,TCL_LINK_INT);
  Tcl_LinkVar(Et_Interp,"CurX",(char*)&iCurX,TCL_LINK_INT);
  Tcl_LinkVar(Et_Interp,"CurY",(char*)&iCurY,TCL_LINK_INT);
#ifdef DEBUG
  Tcl_LinkVar(Et_Interp,"Debug",(char*)&bDebug,TCL_LINK_BOOLEAN);
  Tcl_LinkVar(Et_Interp,"Btm",(char*)&iBtm,TCL_LINK_INT);
  Tcl_LinkVar(Et_Interp,"ScrollTop",(char*)&iScrollTop,TCL_LINK_INT);
  Tcl_LinkVar(Et_Interp,"ScrollBtm",(char*)&iScrollBtm,TCL_LINK_INT);
#endif
  iScrollTop = iCurY = iBtm = 1;
  iScrollBtm = iHeight;
  ET( CreateTermWin );
  putenv(zTermEnv);
  for (i = 0; i < MAXPROC; i++)
    processList[i].pid = 0;
/*
  * Install signal handler *
  asSigchld = Tcl_AsyncCreate(HandleSigchld, 0);
  signal(SIGCHLD, CatchDeathOfChild);
*/
  /* Install idle handler */
  Tk_CreateTimerHandler(CHKPID_INTERVAL, chkpids, (ClientData)0);
  return 0;
}

/*#############################################
static void CatchDeathOfChild(int nonsense)
{
  int pid;

  pid = wait((int *)0);
  if (pid > 0)
    pidSigChld[noSigChld++] = pid;
  signal(SIGCHLD, CatchDeathOfChild);
  Tcl_AsyncMark(asSigchld);
}
*/
/*##############################################
int HandleSigchld(ClientData clientData,
  Tcl_Interp *interp, int code)
{
  int pid;

  while (noSigChld > 0) {
    pid = pidSigChld[--noSigChld];
#ifdef DEBUG
    fprintf(stderr, "Process %d died\n", pid);
#endif
    if (pid == processList[0].pid) {
      processList[0].pid = 0;
      HandleTerm((ClientData)&iChildFd, 0);
      CleanKill();
      Tcl_SetVar(Et_Interp, "sigchld", "1", TCL_GLOBAL_ONLY);
    } else {
      FreeProcess(pid);
      HandleStdOut((ClientData)&iFdOut[0], 0);
      HandleStdErr((ClientData)&iFdErr[0], 0);
      ET( OutMsg "Process %d(pid) died.");
    }
  }
  return code;
}
*/

void chkpids(ClientData clientdata)
{
  int status, i;
  
  if (processList[0].pid > 0) {
    if (waitpid(processList[0].pid, &status, WNOHANG) != 0) {
      Tcl_SetVar(Et_Interp, "sigchld", "1", TCL_GLOBAL_ONLY);
      processList[0].pid = 0;
      HandleTerm((ClientData)&iChildFd, 0);
      CleanKill();
    }
  }
  for (i = 1; i < 20; i++) {
    if (processList[i].pid > 0) {
      if (waitpid(processList[i].pid, &status, WNOHANG) != 0) {
        HandleStdOut((ClientData)&iFdOut[0], 0);
        HandleStdErr((ClientData)&iFdErr[0], 0);
        ET( OutMsg "Process %d(processList[i].pid) died.");
        processList[i].pid = 0;
      }
    }
  }
  Tk_CreateTimerHandler(CHKPID_INTERVAL, chkpids, (ClientData)0);
}

ET_PROC( ExecCmd )
{
  static void ProcessNormal(char);

  if (argc < 2) {
    Tcl_AppendResult(interp, "wrong # args: should be \"",
      argv[0], " cmdlist\"", 0);
    return ET_ERROR;
  }
  if (processList[0].pid > 0) {
    ET( OutMsg "Cannot start new command because process is running.");
    return ET_OK;
  }
  iChildFd = RunCommand(argv[1], &argv[1], 0, &processList[0].pid);
#ifdef DEBUG
  fprintf(stderr, "RunCommand pid = %d\n", processList[0].pid);
#endif
  xProcess = ProcessNormal;
  if( iChildFd>=0 ){
    ET(TermBind);
    Tcl_CreateFileHandler(iChildFd,TK_READABLE,HandleTerm,
      (ClientData)&iChildFd);
    return ET_OK;
  } else {
    Tcl_AppendResult(interp, "RunCommand failed", 0);
    return ET_ERROR;
  } 
}

/* This routine is called when the child process dies in order to
** do a clean shutdown of the application */
void CleanKill(void){
  ET(TermUnbind);
  Tcl_DeleteFileHandler(iChildFd);
  close(iChildFd);
  KillChildProcess();
}

void CleanShutdown()
{
  StopTty();
}

/* Make sure the text position iX,iY really exists.  If the line iY
** doesn't exist, then add newlines until it does.  If character
** iX doesn't exists on line iY, then add spaces until it does.
** Return the actual length of line iY.
*/
static int MakePositionExist(int iX, int iY){
  int lineNum;
  int lineLen;
  int i;
  char zBuf[1000];  /* Number of elements must be greater than max width
                    ** and height of the text widget */

  if( iX > iWidth ) iX = iWidth;
  ASSERT( iY >= 1 && iX >= 0 );

  /* If line iY doesn't exists, then we'll have to create it. */  
  if( iBtm < iY ){
    for(i=0; i<iY - iBtm; i++) zBuf[i] = '\n';
    zBuf[i] = 0;
    ET(.term insert end {%s(zBuf)});
    iBtm = iY;
    lineLen = 0;
  }else{
    /* Find the amount of text on line iY. */
    sscanf( ET_STR(.term index {%d(iY).0 lineend}), "%d.%d", &lineNum,&lineLen);
    ASSERT( lineNum==iY );
    ASSERT( ET_INT(.term index end)==iBtm+1 );
  }

  /* If character position iX doesn't exists, add spaces until it does */
  if( iX > lineLen ){
    for(i=0; i<iX - lineLen; i++) zBuf[i] = ' ';
    zBuf[i] = 0;
    ET(.term insert %d(iY).%d(lineLen) {%s(zBuf)});
    lineLen = iX;
  }

  /* Return the actual length of line iY. */
  return lineLen;
}

/* Adjust the text widget so that it is scrolled all the way to the
** bottom.
*/
static void JumpToBottom(void){
  ET( .term yview moveto 1 );
}

/* Clip the number of lines in the text widget to keep the number
** of lines at or below iMaxLines
*/
static void ClipScrollback(void){
  if( iBtm > iMaxLines ){
    int extra = iBtm - iMaxLines - 1;
    iCurY -= extra;
    iBtm -= extra;
    if( iCurY<1 ) iCurY = 1;
    ET(.term delete 1.0 %d(extra+1).0);
  }
}

/* Transfer the text in zLineBuf[0..iBufWidth] into the text widget.
** at position iBufY.iBufX.
**
** If the number of lines in the text widget exceeds iMaxLines because of
** this operation, then lines are deleted from the beginning of the
** widget to get the total number of lines back to iMaxLines.
**
** This is the only way to remove characters from zLineBuf.  This is
** also the only way to add non-white-space characters to the screen.
*/
static void FlushBuffer(void){
  int lineLen;  /* The length of the line iBufY */

  /* Early out if nothing to do */
  if( iBufWidth==0 ) return;

  /* Make sure the position iBufX,iBufY really exists */
  lineLen = MakePositionExist(iBufX,iBufY);

  /* Prepare the line to receive text.  This may involve deleting some
  ** of the existing text (in overwrite mode), or deleting some text
  ** that will scroll off the right side of the screen in insert mode.
  */
  if( iBufX < lineLen ){
    if( bReplaceMode ){
      int end = iBufX + iBufWidth;
      if( end>lineLen ) end = lineLen;
      ET(.term delete %d(iBufY).%d(iBufX) %d(iBufY).%d(end));
    }else if( lineLen + iBufWidth > iWidth ){
      ET(.term delete %d(iBufY).%d(lineLen-iBufWidth) %d(iBufY).%d(lineLen));
    }
  }

  /* Add zLineBuf to the text widget at the appropriate spot.
  */
  zLineBuf[iBufWidth] = 0;
  ET(.term insert %d(iBufY).%d(iBufX) "%q(zLineBuf)");

  /* Tag the newly inserted text according to the current character mode. */
  /* ET(
    foreach t [.term tag names %d(iBufY).%d(iBufX)] {
      .term tag remove $t %d(iBufY).%d(iBufX) %d(iBufY).%d(iBufX+iBufWidth)
    }
  ); */
  switch( eBufTag ){
    case BT_Normal:
      break;
    case BT_Underline:
      ET( .term tag add ul %d(iBufY).%d(iBufX) %d(iBufY).%d(iBufX+iBufWidth) );
      break;
    case BT_Bold:
      ET( .term tag add bd %d(iBufY).%d(iBufX) %d(iBufY).%d(iBufX+iBufWidth) );
      break;
    case BT_Inverse:
      ET( .term tag add iv %d(iBufY).%d(iBufX) %d(iBufY).%d(iBufX+iBufWidth) );
      break;
  }
  iBufWidth = 0;
}

/* Display the cursor at its appropriate position
*/
static void DisplayCursor(void){
  MakePositionExist(iCurX,iCurY);
  ET(.term mark set insert %d(iCurY).%d(iCurX));
}

/* Index forward.  This means that the cursor needs to move down
** by one line.  Things can get complex here, due to the VT100
** scrolling region logic.  Only the lines between iScrollTop and
** iScrollBtm, inclusive, should scroll.  
**
** Remember that both iScrollTop and iScrollBtm are vt100-indices.
** That is to say, the top line of the visible part of text is
** line 1.  The cursor is on the top line of the scrolling region if:
**
**           iScrollTop == iCurY - iTop
**
** This routine prevents texts from flowing into the scrollback region
** (of the top of the viewing area) unless the scrolling region is the
** whole viewing area.
**
** The buffer should have already been flushed by the time this
** function is called.
*/
static void IndexForward(void){
  int vt100Y;            /* Cursor Y coordinate in VT100 space */
  int iTop;              

  iTop = iBtm - iHeight;
  if( iTop < 0 ) iTop = 0;
  vt100Y = iCurY - iTop;
  if( vt100Y<iScrollBtm ){
    iCurY++;
  }else if( iScrollBtm==vt100Y ){
    ET(.term insert {%d(iCurY).0 lineend} \n);
    if( iScrollTop>1 || iScrollBtm<iHeight ){
      int y = iScrollTop + iTop;
      ET(.term delete %d(y).0 %d(y+1).0);
    }else{
      iBtm++;
      iCurY++;
    }
  }else if( vt100Y<iHeight ){
    iCurY++;
  }else{
    /* Do nothing.  Let the next line of text overwrite the bottom line. */
  }
}

/* Index backwards.  Like the previous function, just in the opposite
** direction.
*/
static void IndexBackward(void){
  int vt100Y;   /* Y coordinate in VT100 space */
  int iTop;

  iTop = iBtm - iHeight;
  if( iTop < 0 ) iTop = 0;
  vt100Y = iCurY - iTop;
  if( vt100Y>iScrollTop ){
    iCurY--;
  }else if( vt100Y==iScrollTop ){
    int y;
    ET(.term insert %d(iCurY).0 \n);
    y = iScrollBtm + iTop;
    ET(.term delete {%d(y).0 lineend} {%d(y+1).0 lineend});
  }else if( vt100Y>1 ){
    iCurY--;
  }else{
    /* Do nothing.  Let the next line overwrite the top line */
  }
}

/* Add printable characters to the cache.  "c" is always a printable
** character here -- never a newline or tab or other control character.
**
** This is the only way in which text can be added to zLineBuf[].
*/
static void InsertChar(char c){
  static void ProcessNormal(char c);
  if( iCurX>=iWidth ){
    FlushBuffer();
    IndexForward();
    iCurX = 0;
  }
  if( iBufWidth >= sizeof(zLineBuf)-1 ){
    FlushBuffer();
  }
  if( iBufWidth==0 ){
    iBufX = iCurX;
    iBufY = iCurY;
  }
  zLineBuf[iBufWidth++] = c;
  iCurX++;
}

/* Process a character received while in the normal mode of operation.
**
** Add the character to the character cache.  If the character cache is
** full, then add the cache to the text widget.
*/
static void ProcessNormal(char c){
  static void ProcessEsc(char c);
  switch( c ){
    case 033:   /* ESC -- Escape */
      xProcess = ProcessEsc;
      FlushBuffer();
      break;
    case 007:   /* BEL -- Bell */
      XBell(Et_Display,0);
      break;
    case 010:   /* BS  -- Backspace */
      if( iCurX>0 ){
        FlushBuffer();
        iCurX--;
      }
      break;
    case 011:   /* HT  -- Horizontal Tab */
      FlushBuffer();
      iCurX = (iCurX+8)&~0x7;
      if( iCurX >= iWidth ){
        FlushBuffer();
        IndexForward();
        iCurX = 0;
      }
      break;
    case 012:   /* NL  -- New line */
    case 013:   /* VT  -- Vertical Tab */
    case 014:   /* FF  -- Form feed */
      FlushBuffer();
      IndexForward();
      break;
    case 015:   /* CR  -- Carriage return */
      FlushBuffer();
      iCurX = 0;
      break;
    default:
      if( c>=' ' && c<='~' ){
        InsertChar(c);
      }
      break;
  }
}

/* Process a character of a background process
** No Emulation mode, \n goes to begin of a new line
*/
static void ProcessBackground(char c){
  switch( c ){
    case 007:   /* BEL -- Bell */
      XBell(Et_Display,0);
      break;
    case 010:   /* BS  -- Backspace */
      if( iCurX>0 ){
        FlushBuffer();
        iCurX--;
      }
      break;
    case 011:   /* HT  -- Horizontal Tab */
      FlushBuffer();
      iCurX = (iCurX+8)&~0x7;
      if( iCurX >= iWidth ){
        FlushBuffer();
        IndexForward();
        iCurX = 0;
      }
      break;
    case 012:   /* NL  -- New line */
    case 013:   /* VT  -- Vertical Tab */
    case 014:   /* FF  -- Form feed */
    case 015:   /* CR  -- Carriage return */
      FlushBuffer();
      IndexForward();
      iCurX = 0;
      break;
    default:
      if( c>=' ' && c<='~' ){
        InsertChar(c);
      }
      break;
  }
}
/* Ingore one character
*/
static void IgnoreOne(char c){
  xProcess = ProcessNormal;
}

/* Wait until an ESC '\\' is seen
*/
static void WaitEscSlash(char c){
  static int escSeen = 0;
  if( c==033 ){
    escSeen = 1;
  }else if( c=='\\' && escSeen ){
    escSeen = 0;
    xProcess = ProcessNormal;
  }else{
    escSeen = 0;
  }
}

/* Wait until the BEL character is seen 
*/
static void WaitBel(char c){
  if( c==007 ) xProcess = ProcessNormal;
}

/* The previous character was an ESC (escape).  Process the next
** character.
**
** When this function is called, we know that the buffer has been
** flushed.
*/
static void ProcessEsc(char c){
  int i;
  static void ProcessEscBrace(char c);

  ASSERT( iBufWidth==0 );
  xProcess = ProcessNormal;
  switch( c ){
    case '[':
      xProcess = ProcessEscBrace;
      nParam = 0;
      for(i=0; i<sizeof(aiParam)/sizeof(aiParam[0]); i++) aiParam[i] = -1;
      break;
    case '#':    /* DEC test sequence */
    case '(':    /* Designate G0 Character Set */
    case ')':    /* Designate G1 Character Set */
    case '*':    /* Designate G2 Character Set */
    case '+':    /* Designate G3 Character Set */
      xProcess = IgnoreOne;
      break;
    case '7':    /* Save Cursor */
      iCurSavedX = iCurX;
      iCurSavedY = iCurY;
      break;
    case '8':    /* Restore Cursor */
      iCurX = iCurSavedX;
      iCurY = iCurSavedY;
      break;
    case '=':    /* Application Keypad */
    case '>':    /* Normal Keypad */
      break;
    case 'D':    /* Index */
    case 'E':    /* NextLine */
      IndexForward();
      break;
    case 'F':    /* An HP bug */
      break;
    case 'H':    /* Tab set */
      break;
    case 'M':    /* Reverse index */
      IndexBackward();
      break;
    case 'N':    /* Use G2 for next character only */
      break;
    case 'O':    /* Use G3 for next character only */
      break;
    case 'P':    /* "ESC P text ESC \" implements Device Control String */
      xProcess = WaitEscSlash;
      break;
    case 'Z':    /* Return the Terminal ID */
      ET( SendToTTY \033\[?1\;2c );
      break;
    case ']':
      xProcess = WaitBel;
      break;
    case '^':
    case '_':
      xProcess = WaitEscSlash;
      break;
    default:
      break;
  }
}

/* We have seen an ESC followed by a '['.  Process subsequent characters.
**
** When this function is called, we know that the buffer has been
** flushed.
*/
static void ProcessEscBrace(char c){
  int n, x, y;
  int i;
  int end;
  int iTop;
  char zBuf[100];
  static void ProcessEscBraceQuestion(char);

  ASSERT( iBufWidth==0 );
  xProcess = ProcessNormal;
  switch( c ){
    case '?':
      xProcess = ProcessEscBraceQuestion;
      break;
    case '@':
      n = aiParam[0];
      if( n<0 ) n = 1;
      for(i=0; i<n; i++) InsertChar(' ');
      break;
    case 'A':
      n = aiParam[0];
      if( n<0 ) n = 1;
      iCurY -= n;
      if( iCurY < 1 ) iCurY = 1;
      break;
    case 'B':
      n = aiParam[0];
      if( n<0 ) n = 1;
      iCurY += n;
      if( iCurY > iBtm && iCurY > iHeight ) iCurY = iBtm;
      break;
    case 'C':
      n = aiParam[0];
      if( n<0 ) n = 1;
      iCurX += n;
      if( iCurX > iWidth ) iCurX = iWidth;
      break;
    case 'D':
      n = aiParam[0];
      if( n<0 ) n = 1;
      iCurX -= n;
      if( iCurX<0 ) iCurX = 0;
      break;
    case 'H':
      y = aiParam[0];
      if( y<1 ) y = 1;
      x = aiParam[1];
      if( x<1 ) x = 1;
      iCurX = x-1;
      iTop = iBtm - iHeight;
      if( iTop<0 ) iTop = 0;
      iCurY = iTop + y;
      break;
    case 'J':
      iTop = iBtm - iHeight;
      if( iTop<0 ) iTop = 0;
      switch( aiParam[0] ){
        case 1:     /* Clear above the cursor */
          if( iCurY > iTop + 1 ){
            for(i=0; i<iCurY - iTop - 1; i++) zBuf[i] = '\n';
            zBuf[i] = 0;
            ET( .term delete %d(iTop+1).0 %d(iCurY).0 );
            if( zBuf[0] ) ET( .term insert %d(iTop+1).0 {%s(zBuf)} );
          }
          ET(.term delete %d(iCurY).0 %d(iCurY).%d(iCurX));
          break;
        case 2:     /* Clear everything */
          for(i=0; i<iBtm - iTop - 1; i++) zBuf[i] = '\n';
          zBuf[i] = 0;
          ET(.term delete %d(iTop+1).0 {%d(iBtm).0 lineend});
          if( zBuf[0] ) ET(.term insert %d(iTop+1).0 {%s(zBuf)});
          break;
        default:    /* Clear below the cursor */
          for(i=0; i<iBtm - iCurY; i++) zBuf[i] = '\n';
          zBuf[i] = 0;
          ET( .term delete %d(iCurY).%d(iCurX) {%d(iBtm).0 lineend} );
          if( zBuf[0] ) ET( .term insert end {%s(zBuf)} );
          break;
      }
      break;
    case 'K':
      switch( aiParam[0] ){
        case 1:     /* Clear to left of cursor */
          ET(.term delete %d(iCurY).0 %d(iCurY).%d(iCurX));
          break;
        case 2:     /* Clear the whole line */
          ET(.term delete %d(iCurY).0 {%d(iCurY).0 lineend});
          break;
        default:    /* Clear to the right of the cursor */
          ET(.term delete %d(iCurY).%d(iCurX) {%d(iCurY).0 lineend});
          break;
      }
      break;
    case 'L':       /* Insert lines */
      n = aiParam[0];
      if( n<1 ) n = 1;
      for(i=0; i<n; i++) zBuf[i] = '\n';
      zBuf[i] = 0;
      ET(.term insert %d(iCurY).0 {%s(zBuf)});
      iTop = iBtm - iHeight;
      if( iTop<0 ) iTop = 0;
      y = iScrollBtm + iTop;
      ET(.term delete {%d(y).0 lineend} {%d(y+n).0 lineend});
      iBtm = ET_INT(.term index end) - 1;
      break;
    case 'M':       /* Delete lines */
      n = aiParam[0];
      if( n<1 ) n = 1;
      for(i=0; i<n; i++) zBuf[i] = '\n';
      zBuf[i] = 0;
      ET(.term delete %d(iCurY).0 %d(iCurY+n).0);
      iTop = iBtm - iHeight;
      if( iTop<0 ) iTop = 0;
      y = iScrollBtm + iTop;
      if( iCurY < y ){
        ET(.term insert {%d(y-n).0 lineend} {%s(zBuf)});
      }else{
        ET(.term insert end {%s(zBuf)});
      }
      break;
    case 'P':       /* Delete characters */
      n = aiParam[0];
      if( n<0 ) n = 1;
      sscanf( ET_STR(.term index {%d(iCurY).0 lineend}), "%*d.%d", &end);
      if( iCurX + n > end ) n = end - iCurX;
      if( n>0 ){
        ET(.term delete %d(iCurY).%d(iCurX) %d(iCurY).%d(iCurX+n));
      }
      break;
    case 'T':       /* Initiate hilite mouse tracking */
      break;
    case 'c':       /* Send device attributes */
      break;
    case 'f':       /* horizontal and vertical position */
      break;
    case 'g':       /* Tab clear */
      break;
    case 'h':       /* Set mode */
      switch( aiParam[0] ){
        case 4:
          bReplaceMode = 0;
        default:
          break;
      }
      break;
    case 'l':       /* reset mode */
      switch( aiParam[0] ){
        case 4:
          bReplaceMode = 1;
        default:
          break;
      }
      break;
    case 'm':       /* character attributes */
      switch( aiParam[0] ){
        case 1:    /* Bold */
        case 5:    /* Blink (appears as bold) */
          eBufTag = BT_Bold;
          break;
        case 4:    /* Underscore */
          eBufTag = BT_Underline;
          break;
        case 7:    /* Inverse */
          eBufTag = BT_Inverse;
          break;
        default:   /* Normal */
          eBufTag = BT_Normal;
          break; 
      }
      break;
    case 'n':       /* Device status report */
      break;
    case 'r':       /* Set scrolling region */
      iScrollTop = aiParam[0];
      if( iScrollTop<1 ) iScrollTop = 1;
      if( iScrollTop>iHeight ) iScrollTop = iHeight;
      iScrollBtm = aiParam[1];
      if( iScrollBtm<iScrollTop ) iScrollBtm = iScrollTop;
      if( iScrollBtm>iHeight ) iScrollBtm = iHeight;
      iTop = iBtm - iHeight;
      if( iTop<0 ) iTop = 0;
      iCurY = iTop + 1;
      iCurX = 0;
      break;
    case 'x':       /* Request terminal parameters */
      break;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
      if( aiParam[nParam]<0 ){
        aiParam[nParam] = c - '0';
      }else{
        aiParam[nParam] = aiParam[nParam]*10 + c - '0';
      }
      xProcess = ProcessEscBrace;
      break;
    case ';':
      if( nParam < sizeof(aiParam)/sizeof(aiParam[0]) - 1 ){
        nParam++;
      }
      xProcess = ProcessEscBrace;
      break;
    default:
      break;
  }
}

/* We have seen an ESC followed by a '['.  Process subsequent characters.
**
** When this function is called, we know that the buffer has been
** flushed and the text widget has scrolled all the way to the
** bottom.
*/
static void ProcessEscBraceQuestion(char c){
  switch( c ){
    case 'h':       /* DEC private mode set */
      xProcess = ProcessNormal;
      break;
    case 'l':       /* DEC private mode reset */
      xProcess = ProcessNormal;
      break;
    case 'r':       /* Restore DEC private mode values */
      xProcess = ProcessNormal;
      break;
    case 's':       /* Save DEC private mode values */
      xProcess = ProcessNormal;
      break;
    case '0':
    case '1':
    case '2':
    case '3':
    case '4':
    case '5':
    case '6':
    case '7':
    case '8':
    case '9':
    case ' ':
    case ';':
      break;
    default:
      xProcess = ProcessNormal;
      break;
  }
}

/* This routine is called to deal with data written by the child process
** on the other side of the pty.  Its job is to interpret characters as
** if it where a VT100 terminal, and make appropriate changes to the
** text widget.
*/
static void HandleTerm(void *clientData, int mask){
  int *fd = (int *)clientData;
  int nByte;
  char zBuf[2000];

  nByte = read(*fd,zBuf,sizeof(zBuf)-1);
  if( nByte>0 ){
    int i;

    /* Process all characters received */
    for(i=0; i<nByte; i++){
#ifdef DEBUG
      if( bDebug ){
        printf("Recv: %03o %c\n",(int)zBuf[i],
          (zBuf[i]>=' ' && zBuf[i]<='~')? zBuf[i] : ' ');
      }
#endif
      (*xProcess)(zBuf[i]);
    }

    /* It might be a while before we process additional input, so 
    ** flush the buffer to synchronize the screen display. */
    FlushBuffer();
    ClipScrollback();
    DisplayCursor();
    JumpToBottom();

    /* Tk4.0 requires two "update idletasks" in order to redisplay
    ** the text widget.  This line is not strictly necessary.  If you
    ** remove it, the terminal will scroll faster, but you won't get to
    ** watch is scroll by.  With this line in place, the screen will
    ** update at least every 2000 characters.
    */
    ET(update idletasks; update idletasks);
  }else if( nByte<0 ){
    /* Perhaps the child process has died */
    extern int IsChildAlive();
    if( !IsChildAlive() ){
      CleanKill();
    }
  }

}

static void HandleStdOut(void *clientData, int mask){
  int *fd = (int *)clientData;
  int nByte;
  char zBuf[2000];

  nByte = read(*fd,zBuf,sizeof(zBuf)-1);
  if( nByte>0 ){
    int i;

    /* Process all characters received */
    for(i=0; i<nByte; i++){
#ifdef DEBUG
      if( bDebug ){
        printf("Recv: %03o %c\n",(int)zBuf[i],
          (zBuf[i]>=' ' && zBuf[i]<='~')? zBuf[i] : ' ');
      }
#endif
      ProcessBackground(zBuf[i]);
    }

    /* It might be a while before we process additional input, so 
    ** flush the buffer to synchronize the screen display. */
    FlushBuffer();
    ClipScrollback();
    DisplayCursor();
    JumpToBottom();

    /* Tk4.0 requires two "update idletasks" in order to redisplay
    ** the text widget.  This line is not strictly necessary.  If you
    ** remove it, the terminal will scroll faster, but you won't get to
    ** watch is scroll by.  With this line in place, the screen will
    ** update at least every 2000 characters.
    */
    ET(update idletasks; update idletasks);
  }else if( nByte<0 ){
    /* Perhaps the child process has died */
    extern int IsChildAlive();
    if( !IsChildAlive() ){
      CleanKill();
    }
  }

}

static void HandleStdErr(void *clientData, int mask){
  HandleStdOut(clientData, mask);
}


/* Process the text of the first argument as if it had been received
** through the pseudo-TTY.
*/
ET_PROC( SimulatedInput ){
  int i;
  if( argc!=2 ){
    interp->result = "wrong # args";
    return ET_ERROR;
  }
  for(i=0; argv[1][i]; i++){
#ifdef DEBUG
    if( bDebug ){
      printf("Sim: %03o %c\n",(int)argv[1][i],
        (argv[1][i]>=' ' && argv[1][i]<='~')? argv[1][i] : ' ');
    }
#endif
    (*xProcess)(argv[1][i]);
  }
  FlushBuffer();
  ClipScrollback();
  DisplayCursor();
  JumpToBottom();
  return ET_OK;
}

/* This procedure is used to send characters to the process running
** on the other size of the pseudo-TTY.
*/
ET_PROC( SendToTTY ){
  int c;
  char z[1];
  if( argc!=2 ){
    interp->result = "wrong # args";
    return ET_ERROR;
  }
  Tcl_GetInt(interp,argv[1],&c);
  *z = c;
  if( c>0 && c<=0x7f ){
    while( write(iChildFd,z,1)<1 ){}
  }
  return ET_OK;
}

/* A special procedure is needed to send zeros.
*/
ET_PROC( SendZeroToTTY ){
  char z[1];
  *z = 0;
  while( write(iChildFd,z,1)<1 ){}
  return ET_OK;
}

/* Do a paste operation
*/
ET_PROC( Paste ){
  int i;
  if( argc!=2 ){
    interp->result = "wrong # args";
    return ET_ERROR;
  }
  for(i=0; argv[1][i]; i++){
    char c = argv[1][i];
    while( write(iChildFd,&c,1)<1 ){}

    /* Some Pseudo-TTYs are broken (ex: Linux) and can't receive too
    ** many characters too quickly.  Hence we need to pause every so
    ** often on a big paste to let the Pseudo-TTY catch up. */
    if( i%100 == 99 ) ET( after 10; update);
  }
  return ET_OK;
}

/* Ring the bell.  Needed in Tk4.0 because the built-in "bell" causes
** the screen-saver to be reset, which in turn causes an unsightly flicker
** on the screen. */
ET_PROC( bell ){
  XBell(Et_Display,0);
  return ET_OK;
}

/* This procedure is called after the window changes size.  Its
** job is to tell the Pseudo-TTY about the new window size.
*/
ET_PROC( WindowSizeChangeNotify ){
  static int previousHeight = 24;
  extern void SetSizeOfTTY(int,int,int);

  JumpToBottom();
  SetSizeOfTTY(iChildFd,iWidth,iHeight);
  if( iScrollBtm == previousHeight ){
    iScrollBtm = iHeight;
  }
  previousHeight = iHeight;
  return ET_OK;
}

ET_PROC( Out )
{
  int i;

  if( argc!=3 ){
    Tcl_AppendResult(interp, "wrong # args: should be \"",
      argv[0], " win string\"", 0);
    return ET_ERROR;
  }
  xProcess = ProcessNormal;
  for(i=0; argv[2][i]; i++){
#ifdef DEBUG
    if( bDebug ){
      printf("Sim: %03o %c\n",(int)argv[1][i],
        (argv[1][i]>=' ' && argv[1][i]<='~')? argv[1][i] : ' ');
    }
#endif
  (*xProcess)(argv[2][i]);
  }
  ProcessNormal('\r');
  ProcessNormal('\n');
  FlushBuffer();
  ClipScrollback();
  DisplayCursor();
  JumpToBottom();
  return ET_OK;
}

int StartTty()
{
  pipe(iFdOut);
  pipe(iFdErr);
  Tcl_CreateFileHandler(iFdOut[0],TK_READABLE,HandleStdOut,
    (ClientData)&iFdOut[0]);
  Tcl_CreateFileHandler(iFdErr[0],TK_READABLE,HandleStdErr,
    (ClientData)&iFdErr[0]);
  fcntl(iFdOut[0], F_SETFL, O_NONBLOCK);
  fcntl(iFdErr[0], F_SETFL, O_NONBLOCK);
  return 0;
}

static int StopTty()
{
  Tcl_DeleteFileHandler(iFdErr[0]);
  Tcl_DeleteFileHandler(iFdOut[0]);
  close(iFdErr[0]);
  close(iFdErr[1]);
  close(iFdOut[0]);
  close(iFdOut[1]);
  return 0;
}

ET_PROC(ExecBg)
{
  pid_t pid;
  char *cmdline;

  if (argc < 2) {
    Tcl_AppendResult(interp, "wrong # args: should be \"",
      argv[0], " arg ...\"", 0);
    return ET_ERROR;
  }
  if ((pid = fork()) < 0) {
    sprintf(interp->result, "%s: fork failed with error code %d",
      argv[0], pid);
    return ET_ERROR;
  }
  else if (pid == 0) { /* Child */
    close(0);
    if (iFdOut[1] != 1) {
      dup2(iFdOut[1], 1);
      close(iFdOut[1]);
    }
    if (iFdErr[1] != 2) {
      dup2(iFdErr[1], 2);
      close(iFdErr[1]);
    }
    execvp(argv[1], &argv[1]);
    exit(1);
  }
  else { /* Parent */
    cmdline = Tcl_Merge(argc-1, argv+1);
    NewProcess(pid, cmdline);
    ET(OutMsg "Process %d(pid) started: %s(cmdline)");
    free(cmdline);
    sprintf(interp->result, "%d", pid);
    return ET_OK;
  }
}

ET_PROC( Kill )
{
  int i, j;
  char spid[60];
  pid_t pids[20];

  ET(set pid {});
  for (i = 0, j = 0; i < 20; i++) {
    if (processList[i].pid) {
      sprintf(spid, "{%5d %s}", processList[i].pid, processList[i].command);
      pids[j++] = processList[i].pid;
      ET(lappend pid %s(spid));
    }
  }
  if (j > 0) {
    j = ET_INT(ListDlg .ldlg 300x150$params(dlg_geom) "Kill Process:" $pid);
#ifdef DEBUG
    fprintf(stderr, "Kill: %d %d\n", j, pids[j]);
#endif
    kill(pids[j], SIGKILL);
  }
  return ET_OK;
}

ET_PROC( CleanShutdown)
{
  KillAllProcesses();
  StopTty();
  return ET_OK;
}