home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / utils / amd-udi / mondfe / monitor.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-12-23  |  41.9 KB  |  1,655 lines
  1. static char _[] = "@(#)monitor.c    5.28 93/11/02 11:46:54, Srini, AMD.";
  2. /******************************************************************************
  3.  * Copyright 1991 Advanced Micro Devices, Inc.
  4.  *
  5.  * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
  6.  * specifically  grants the user the right to modify, use and distribute this
  7.  * software provided this notice is not removed or altered.  All other rights
  8.  * are reserved by AMD.
  9.  *
  10.  * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
  11.  * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
  12.  * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
  13.  * USE OF THIS SOFTWARE.
  14.  *
  15.  * So that all may benefit from your experience, please report  any  problems
  16.  * or  suggestions about this software to the 29K Technical Support Center at
  17.  * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
  18.  * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
  19.  *
  20.  * Advanced Micro Devices, Inc.
  21.  * 29K Support Products
  22.  * Mail Stop 573
  23.  * 5900 E. Ben White Blvd.
  24.  * Austin, TX 78741
  25.  * 800-292-9263
  26.  *****************************************************************************
  27.  *      Engineer: Srini Subramanian.
  28.  *****************************************************************************
  29.  * This module implements the monitor command interpreter.
  30.  *****************************************************************************
  31.  */
  32.  
  33. #include  <stdio.h>
  34. #include  <string.h>
  35. #include  <ctype.h>
  36. #include  <signal.h>
  37. #ifdef    MSDOS
  38. #include  <stdlib.h>
  39. #include  <conio.h>
  40. #include  <io.h>
  41. #else
  42. #include  <fcntl.h>
  43. #include  <termio.h>
  44. /* #include   <sys/ioctl.h> */
  45. #endif
  46. #include  "monitor.h"
  47. #include  "main.h"
  48. #include  "memspcs.h"
  49. #include  "error.h"
  50. #include  "miniint.h"
  51.  
  52. /* Function declarations */
  53. extern    void    Mini_Ctrl_C_Handler PARAMS((int));
  54. extern    void    Mini_loop PARAMS((void));
  55. extern    INT32    Mini_go_forever PARAMS((void));
  56. extern    void    Mini_poll_kbd PARAMS((char  *cmd_buffer, int size, int mode));
  57. extern    int    Mini_cmdfile_input PARAMS((char  *cmd_buffer, int size));
  58. extern    int       tokenize_cmd PARAMS((char *, char **));
  59. extern     void     lcase_tokens PARAMS((char **, int));
  60. extern    int       get_word PARAMS((char *, INT32 *));
  61. extern    void    PrintTrapMsg PARAMS((int trapnum));
  62. extern    void    display_msg PARAMS((void));
  63. extern    void    display_termuser PARAMS((void));
  64. extern    void    display_term29k PARAMS((void));
  65. extern    INT32    get_pc_addrs PARAMS((ADDR32 *pc1, ADDR32 *cps));
  66. extern    INT32    get_pc1_inst PARAMS((ADDR32 cps, ADDR32 pc1, BYTE *inst));
  67. extern    void     dasm_instr PARAMS((ADDR32, struct instr_t *));
  68. extern    void    convert32 PARAMS((BYTE *));
  69. extern    INT32    Mini_send_init_info PARAMS((INIT_INFO *init));
  70.  
  71. static    int    FindCmdIndx PARAMS((char *string));
  72.  
  73. /* Globals */
  74. GLOBAL     struct bkpt_t     *bkpt_table;
  75.  
  76. GLOBAL     char           cmd_buffer[BUFFER_SIZE];
  77. GLOBAL     char           tip_cmd_buffer[256];
  78. GLOBAL    int        GoCmdFlag=0;
  79.  
  80. #define    TOGGLE_CHAR    (io_config.io_toggle_char)
  81.  
  82. /* Following three vars to be used in stdin/stdout/stderr funcs */
  83. #define    IO_BUFSIZE    1024
  84. static    char        io_buffer[IO_BUFSIZE]; 
  85. static    INT32         io_bufsize;
  86. static    INT32        io_count_done;
  87.  
  88. static    INT32        ProcessorState;
  89. static    int        GrossState;
  90. static    INT32        exit_loop;
  91. static    int        CtrlCHit=0;
  92. static    int        BlockMode;
  93. /* These modes are defined in montip, udi2mtip.c file */
  94. #define    TIP_COOKED    0x0
  95. #define    TIP_RAW        0x1
  96. #define    TIP_CBREAK    0x2
  97. #define    TIP_ECHO    0x4
  98. #define    TIP_ASYNC    0x8
  99. #define    TIP_NBLOCK    0x10
  100. static    INT32        TipStdinMode = TIP_COOKED;    /* initial */
  101. #ifndef    MSDOS
  102. struct termio OldTermbuf, NewTermbuf;    /* STDIN, Channel0 */
  103. #endif /* MSDOS */
  104.  
  105. /* Monitor command table */
  106. struct    MonitorCommands_t {
  107.   char        *CmdString; /* Maximum length */
  108.   INT32        (*CmdFn) PARAMS((char **, int));
  109. };
  110.  
  111. static    struct MonitorCommands_t MonitorCommands[] = {
  112. "a", asm_cmd,
  113. "attach", set_sessionid_cmd,
  114. "b", bkpt_cmd,
  115. "bc", bkpt_cmd,
  116. "b050", bkpt_cmd,
  117. "b050v", bkpt_cmd,
  118. "b050p", bkpt_cmd,
  119. "c", config_cmd,
  120. "caps", capab_cmd,
  121. "cp", create_proc_cmd,
  122. "con", connect_cmd,
  123. "ch0", channel0_cmd,
  124. "d", dump_cmd,
  125. "ex", exit_conn_cmd,
  126. "dw", dump_cmd,
  127. "dh", dump_cmd,
  128. "db", dump_cmd,
  129. "df", dump_cmd,
  130. "dd", dump_cmd,
  131. "dp", destroy_proc_cmd,
  132. "disc", disconnect_cmd,
  133. "detach", disconnect_cmd,
  134. "esc", escape_cmd,
  135. "eon", echomode_on,
  136. "eoff", echomode_off,
  137. "f", fill_cmd,
  138. "fw", fill_cmd,
  139. "fh", fill_cmd,
  140. "fb", fill_cmd,
  141. "ff", fill_cmd,
  142. "fd", fill_cmd,
  143. "fs", fill_cmd,
  144. "g", go_cmd,
  145. "h", help_cmd,
  146. "ix", ix_cmd,
  147. "il", il_cmd,
  148. "init", init_proc_cmd,
  149. "k", kill_cmd,
  150. "l", dasm_cmd,
  151. "logon", logon_cmd,
  152. "logoff", logoff_cmd,
  153. "m", move_cmd,
  154. "pid", set_pid_cmd,
  155. "q", quit_cmd,
  156. "qoff", quietmode_off,
  157. "qon", quietmode_on,
  158. "r", reset_cmd,
  159. "s", set_cmd,
  160. "sw", set_cmd,
  161. "sh", set_cmd,
  162. "sb", set_cmd,
  163. "sf", set_cmd,
  164. "sd", set_cmd,
  165. "sid", set_sessionid_cmd,
  166. "t", trace_cmd,
  167. "target", connect_cmd,
  168. "tip", tip_cmd,
  169. "ver", version_cmd,
  170. "xp", xp_cmd,
  171. "xc", xc_cmd,
  172. "y", yank_cmd,
  173. "zc", cmdfile_cmd,
  174. "ze", echofile_cmd,
  175. "zl", set_logfile,
  176. "?", help_cmd,
  177. "|", dummy_cmd,
  178. "", dummy_cmd,
  179. NULL
  180. };
  181.  
  182. /* Trap Messages */
  183. static char    *TrapMsg[] = {
  184. "Illegal Opcode",
  185. "Unaligned Access",
  186. "Out of Range",
  187. "Coprocessor Not Present",
  188. "Coprocessor Exception",
  189. "Protection Violation",
  190. "Instruction Access Exception",
  191. "Data Access Exception",
  192. "User-Mode Instruction TLB Miss",
  193. "User-Mode Data TLB Miss",
  194. "Supervisor-Mode Instruction TLB Miss",
  195. "Supervisor-Mode Data TLB Miss",
  196. "Instruction TLB Protection Violation",
  197. "Data TLB Protection Violation",
  198. "Timer",
  199. "Trace",
  200. "INTR0",
  201. "INTR1",
  202. "INTR2",
  203. "INTR3",
  204. "TRAP0",
  205. "TRAP1",
  206. "Floating-Point Exception"
  207. };
  208.  
  209. void
  210. Mini_monitor()
  211. {
  212.  
  213.   /* Initialize breakpoint table */
  214.  
  215.   bkpt_table = NULL;
  216.   GrossState = NOTEXECUTING;
  217.  
  218.    /*
  219.     * Start with the user being the terminal controller.
  220.     */
  221.     io_config.io_control = TERM_USER;
  222.     io_config.target_running = FALSE;
  223.  
  224. #ifndef    MSDOS
  225.    ioctl (fileno(stdin), TCGETA, &OldTermbuf);    /* Initial settings */
  226. #endif
  227.  
  228.    /*
  229.     * Define Ctrl-U as the io_toggle_char as default.
  230.     */
  231.     io_config.io_toggle_char = (BYTE) 21;
  232.  
  233.    /*
  234.    ** Open cmd file (if necessary)
  235.    */
  236.  
  237.    if (io_config.cmd_file_io == TRUE) {  /* TRUE if -c option given */
  238.       io_config.cmd_file = fopen(io_config.cmd_filename, "r");
  239.         if (io_config.cmd_file == NULL) {
  240.             warning (EMCMDOPEN);
  241.             io_config.cmd_file_io = FALSE;
  242.         } else {
  243.       /* MON_STDIN is command file */
  244.       MON_STDIN = fileno(io_config.cmd_file); /* set MON_STDIN */
  245.     };
  246.    }
  247.  
  248.    /*
  249.    ** Open log file, if no command file given.
  250.    */
  251.  
  252.    if (io_config.log_mode == (INT32) TRUE) { /* -log option given */
  253.      if (io_config.log_filename) {
  254.        io_config.log_file = fopen(io_config.log_filename, "w");
  255.        if (io_config.log_file == NULL) {
  256.           io_config.log_mode = (INT32) FALSE;
  257.           warning(EMLOGOPEN);
  258.        }
  259.      } else {
  260.        io_config.log_mode = (INT32) FALSE;
  261.        warning(EMLOGOPEN);
  262.      }
  263.    }
  264.  
  265.    /* Install ctrl-C handler */
  266.  
  267.    if (signal (SIGINT, Mini_Ctrl_C_Handler) == SIG_ERR) {
  268.      fprintf(stderr, "Ctrl-C handler not installed.\n"); /* warning */
  269.      if (io_config.echo_mode == (INT32) TRUE)
  270.         fprintf(io_config.echo_file, "Ctrl-C handler not installed.\n"); /* warning */
  271.    }
  272.   /* Get into monitor loop */
  273.  
  274.   Mini_loop();
  275.  
  276. }
  277.  
  278. void
  279. Mini_loop()
  280. {
  281.    INT32    retval;
  282.    int        token_count;
  283.    char      *token[MAX_TOKENS];
  284.    int        Indx;
  285.  
  286.    exit_loop = FALSE;
  287.    CtrlCHit = 0;
  288.    /*
  289.    ** Enter command interpreter loop
  290.    */
  291.  
  292.    fprintf(stderr, "%s>", ProgramName);
  293.    if (io_config.echo_mode == (INT32) TRUE)
  294.       fprintf(io_config.echo_file, "%s>", ProgramName);
  295.  
  296.    BlockMode = BLOCK;    /* wait for a user command */
  297.    do {
  298.  
  299.       if (CtrlCHit) {
  300.     CtrlCHit = 0;
  301.        /* Print a prompt */
  302.        fprintf(stderr, "\n%s>", ProgramName);
  303.        if (io_config.echo_mode == (INT32) TRUE)
  304.             fprintf(io_config.echo_file, "\n%s>", ProgramName);
  305.       }
  306.       /*
  307.       ** If the target was set to run, get its current status.
  308.       */
  309.       if (Mini_get_target_stats((INT32) udi_waittime, &ProcessorState) != SUCCESS) {
  310.          Mini_TIP_DestroyProc();
  311.          Mini_TIP_exit();
  312.      fatal_error(EMFATAL);
  313.       };
  314.       GrossState = (int) (ProcessorState & 0xFF);
  315.       switch (GrossState) {
  316.     case    NOTEXECUTING:  /* do nothing */
  317.         io_config.io_control=TERM_USER;
  318.              io_config.target_running = FALSE;
  319.         BlockMode = BLOCK;    /* wait for a user command */
  320.         break;
  321.     case    EXITED:  /* do nothing */
  322.         if (GoCmdFlag) {
  323.          GoCmdFlag = 0;
  324. #ifndef    MSDOS
  325.                  ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  326. #endif
  327.          if (!QuietMode) {
  328.             fprintf (stderr, "Process exited with 0x%lx\n", 
  329.                     (ProcessorState >> 8));
  330.                  if (io_config.echo_mode == (INT32) TRUE)
  331.                fprintf (io_config.echo_file, "Process exited with 0x%lx\n", 
  332.                     (ProcessorState >> 8));
  333.          }
  334.          fprintf (stderr, "%s>", ProgramName);
  335.               if (io_config.echo_mode == (INT32) TRUE)
  336.             fprintf (io_config.echo_file, "%s> ", ProgramName);
  337.         }
  338.         io_config.io_control=TERM_USER;
  339.              io_config.target_running = FALSE;
  340.         BlockMode = BLOCK; /* wait for a user command */
  341.         break;
  342.     case    RUNNING:    /* any request from target? */
  343.              io_config.target_running = TRUE;
  344.         BlockMode = NONBLOCK; /* return immediately */
  345.         break;
  346.     case    STOPPED:
  347.         io_config.io_control=TERM_USER;
  348.              io_config.target_running = TRUE;
  349.         if (GoCmdFlag) {
  350.            GoCmdFlag = 0;
  351. #ifndef    MSDOS
  352.                    ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  353. #endif
  354.            fprintf(stderr, "Execution stopped at ");
  355.                 if (io_config.echo_mode == (INT32) TRUE)
  356.               fprintf(io_config.echo_file, "Execution stopped at ");
  357.            display_msg();
  358.         }
  359.         BlockMode = BLOCK; /* wait for next user command */
  360.         break;
  361.     case    BREAK:
  362.         io_config.io_control=TERM_USER;
  363.              io_config.target_running = FALSE;
  364.         if (GoCmdFlag) {
  365.            GoCmdFlag = 0;
  366. #ifndef    MSDOS
  367.                    ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  368. #endif
  369.            fprintf(stderr, "Breakpoint hit at ");
  370.                 if (io_config.echo_mode == (INT32) TRUE)
  371.               fprintf(io_config.echo_file, "Breakpoint hit at ");
  372.            display_msg();
  373.         }
  374.         BlockMode = BLOCK; /* wait for next user command */
  375.         break;
  376.     case    STEPPED:
  377.         io_config.io_control=TERM_USER;
  378.              io_config.target_running = FALSE;
  379.         if (GoCmdFlag) {
  380.            GoCmdFlag = 0;
  381. #ifndef    MSDOS
  382.                    ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  383. #endif
  384.            fprintf(stderr, "Stepping... Execution stopped at ");
  385.                 if (io_config.echo_mode == (INT32) TRUE)
  386.               fprintf(io_config.echo_file, "Stepping...Execution stopped at ");
  387.            display_msg();
  388.         }
  389.         BlockMode = BLOCK; /* wait for next user command */
  390.         break;
  391.     case    WAITING:
  392.         io_config.io_control=TERM_USER;
  393.              io_config.target_running = FALSE;
  394.         break;
  395.     case    HALTED:
  396.         io_config.io_control=TERM_USER;
  397.              io_config.target_running = FALSE;
  398.         if (GoCmdFlag) {
  399.            GoCmdFlag = 0;
  400. #ifndef    MSDOS
  401.                    ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  402. #endif
  403.            fprintf(stderr, "Execution halted at ");
  404.                 if (io_config.echo_mode == (INT32) TRUE)
  405.               fprintf(io_config.echo_file, "Execution halted at ");
  406.            display_msg();
  407.         }
  408.         BlockMode = BLOCK; /* wait for next user command */
  409.         break;
  410.     case    WARNED:
  411.         io_config.io_control=TERM_USER;
  412.              io_config.target_running = FALSE;
  413.         break;
  414.     case    TRAPPED:
  415.         io_config.io_control=TERM_USER;
  416.              io_config.target_running = FALSE;
  417.         if (GoCmdFlag) {
  418.            GoCmdFlag = 0;
  419. #ifndef    MSDOS
  420.                    ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  421. #endif
  422.            PrintTrapMsg((int) (ProcessorState >> 8));
  423.            display_msg();
  424.         }
  425.         BlockMode = BLOCK; /* wait for next user command */
  426.         break;
  427.     case    STDOUT_READY:
  428.         io_bufsize = 0;
  429.         io_count_done = (INT32) 0;
  430.         do {
  431.           Mini_get_stdout(io_buffer, IO_BUFSIZE, &io_count_done);
  432.           write(MON_STDOUT, &io_buffer[0], (int) io_count_done);
  433.           if (io_config.echo_mode == (INT32) TRUE) {
  434.            fflush (io_config.echo_file);
  435.            write (fileno(io_config.echo_file), &io_buffer[0], (int) io_count_done);
  436.           }
  437.         } while (io_count_done == (INT32) IO_BUFSIZE);
  438.         break;
  439.     case    STDERR_READY:
  440.         io_bufsize = 0;
  441.         io_count_done = (INT32) 0;
  442.         do {
  443.           Mini_get_stderr(io_buffer, IO_BUFSIZE, &io_count_done);
  444.           write(MON_STDERR, &io_buffer[0], (int) io_count_done);
  445.           if (io_config.echo_mode == (INT32) TRUE) {
  446.              fflush (io_config.echo_file);
  447.              write (fileno(io_config.echo_file), &io_buffer[0], (int) io_count_done);
  448.           }
  449.         } while (io_count_done == (INT32) IO_BUFSIZE);
  450.         break;
  451.     case    STDIN_NEEDED:
  452.         /* Line buffered reads only */
  453.         if (io_config.cmd_file_io == TRUE) { /* read from command file */
  454.            if (Mini_cmdfile_input(io_buffer, IO_BUFSIZE) == SUCCESS) {
  455.               io_bufsize = strlen(io_buffer);
  456.               fprintf(stderr, "%s", io_buffer); /* echo */
  457.                    if (io_config.echo_mode == (INT32) TRUE)
  458.                   fprintf(io_config.echo_file, "%s", io_buffer); /* echo */
  459.            } else { /* read from terminal */
  460.              io_bufsize = read( fileno(stdin), io_buffer, IO_BUFSIZE );
  461.            }
  462.         } else {
  463.            io_bufsize = read( fileno(stdin), io_buffer, IO_BUFSIZE );
  464.         };
  465.         if (io_bufsize < 0)
  466.         {
  467.            fprintf(stderr, "fatal error reading from stdin\n");
  468.                 if (io_config.echo_mode == (INT32) TRUE)
  469.               fprintf(io_config.echo_file, "fatal error reading from stdin\n");
  470.         }
  471.         if (io_config.echo_mode == (INT32) TRUE) {
  472.           write (fileno(io_config.echo_file), &io_buffer[0], (int) io_bufsize);
  473.           fflush (io_config.echo_file);
  474.         }
  475.         Mini_put_stdin(io_buffer, io_bufsize, &io_count_done);
  476.         break;
  477.     case    STDINMODEX:
  478.         /* call TIP to get StdinMode */
  479.         Mini_stdin_mode_x((INT32 *)&TipStdinMode);
  480.         if (TipStdinMode & TIP_NBLOCK) 
  481.           io_config.io_control = TERM_29K;
  482.         else if (TipStdinMode & TIP_ASYNC)
  483.           io_config.io_control = TERM_29K;
  484.         else if (TipStdinMode == TIP_COOKED)
  485.           io_config.io_control = TERM_USER;
  486.         else {
  487.           fprintf(stderr, "DFEWARNING: TIP Requested Stdin Mode Not Supported.\n");
  488.           fprintf(stderr, "DFEWARNING: Using default mode.\n");
  489.           TipStdinMode = TIP_COOKED;
  490.           io_config.io_control = TERM_USER;
  491.         }
  492.  
  493.         if (io_config.io_control == TERM_29K)
  494.           display_term29k();
  495.         break;
  496.  
  497.     default:
  498.         break;
  499.       }; /* end switch */
  500.  
  501.  
  502.       /*
  503.       ** Check for keyboard input from command file first, then keyboard.
  504.       */
  505.       if (io_config.io_control == TERM_USER)  {
  506.         if (io_config.target_running == FALSE) {
  507.       if (io_config.cmd_ready == FALSE) { /* Get a new user command */
  508.              if (io_config.cmd_file_io == TRUE) { /* try command file first*/
  509.             if (Mini_cmdfile_input(cmd_buffer, BUFFER_SIZE) == SUCCESS) {
  510.                    fprintf(stderr, "%s", cmd_buffer); 
  511.            io_config.cmd_ready = TRUE;
  512.         } else {
  513.                    Mini_poll_kbd(cmd_buffer, BUFFER_SIZE, BlockMode);
  514.         }
  515.          } else { /* keyboard */
  516.         /* Mini_poll_kbd function sets io_config.cmd_ready */
  517.                 Mini_poll_kbd(cmd_buffer, BUFFER_SIZE, BlockMode);
  518.          }
  519.       }
  520.     } else {
  521.                 Mini_poll_kbd(cmd_buffer, BUFFER_SIZE, BlockMode);
  522.     }
  523.       } else if (io_config.io_control == TERM_29K) {
  524.     if ((GrossState == RUNNING) || GoCmdFlag)
  525.        Mini_poll_channel0();    /* non-blocking */
  526.       } else {
  527.     fprintf(stderr, "fatal error: Don't know who is controlling the terminal!\n");
  528.     return;
  529.       }
  530.  
  531.  
  532.       if (io_config.cmd_ready == TRUE) { /* if there is a command in buffer */
  533. #ifdef    MSDOS
  534.          if (io_config.log_mode == (INT32) TRUE)  /* make a log file */
  535.                 fprintf(io_config.log_file, "%s\n", cmd_buffer);
  536.               if (io_config.echo_mode == (INT32) TRUE)
  537.                 fprintf(io_config.echo_file, "%s\n", cmd_buffer);
  538. #else
  539.          if (io_config.log_mode == (INT32) TRUE)  /* make a log file */
  540.                 fprintf(io_config.log_file, "%s", cmd_buffer);
  541.               if (io_config.echo_mode == (INT32) TRUE)
  542.                 fprintf(io_config.echo_file, "%s", cmd_buffer);
  543. #endif
  544.                /*
  545.                ** Parse command
  546.                */
  547.  
  548.              token_count = tokenize_cmd(cmd_buffer, token);
  549.              /* Convert first character (command) to lcase */
  550.              if (isupper(*token[0]))
  551.                 (*token[0]) = (char) tolower(*token[0]);
  552.  
  553.              /* If anything but a y or z command, convert to lower case */
  554.              if ( ((*token[0]) != 'y') &&
  555.           ((*token[0]) != 'z') )
  556.                 lcase_tokens(token, token_count);
  557.  
  558.          if ((Indx = FindCmdIndx(token[0])) != (int) FAILURE)
  559.            io_config.cmd_ready = TRUE;
  560.          else {
  561.            warning(EMNOSUCHCMD);
  562.                /* Print a prompt */
  563.               fprintf(stderr, "\n%s>", ProgramName);
  564.                 if (io_config.echo_mode == (INT32) TRUE)
  565.                  fprintf(io_config.echo_file, "\n%s>", ProgramName);
  566.            io_config.cmd_ready = FALSE; /* nothing to execute */
  567.          }
  568.       }
  569.  
  570.       /*
  571.       ** Execute command
  572.       */
  573.  
  574.       if (io_config.cmd_ready == TRUE) {
  575.      retval = MonitorCommands[Indx].CmdFn(token, token_count);
  576.          io_config.cmd_ready = FALSE;
  577.      if (retval == FAILURE) {
  578.         fprintf(stderr, "Command failed\n");
  579.              if (io_config.echo_mode == (INT32) TRUE)
  580.            fprintf(io_config.echo_file, "Command failed\n");
  581.      } else if (retval != SUCCESS) {
  582.         warning(retval);
  583.      };
  584.          /* Print a prompt */
  585.      if (io_config.io_control == TERM_USER) {
  586.           fprintf(stderr, "%s>", ProgramName);
  587.             if (io_config.echo_mode == (INT32) TRUE)
  588.              fprintf(io_config.echo_file, "%s>", ProgramName);
  589.      } else {
  590.           display_term29k();
  591.      }
  592.       }  /* if cmd ready */
  593.  
  594.    } while (exit_loop != TRUE);  /* end of do-while */
  595.  
  596.    /* Close log file */
  597.    if (io_config.log_mode == (INT32) TRUE)
  598.       (void) fclose(io_config.log_file);
  599.  
  600.    if (bkpt_table != NULL)
  601.        (void) free((char *) bkpt_table);
  602. }
  603.  
  604. /*
  605. ** This function takes in a string and produces a lower case,
  606. ** " argv - argc" style array.  Then number of elements in the
  607. ** array is returned.
  608. */
  609.  
  610. int
  611. tokenize_cmd(cmd, token)
  612.    char  *cmd;
  613.    char  *token[];
  614.    {
  615.    int  token_count;
  616.  
  617.    /* Break input into tokens */
  618.    token_count = 0;
  619.    token[0] = cmd;
  620.  
  621.    if (cmd[0] != '\0') {
  622.       token[token_count] = strtok(cmd, " \t,;\n\r");
  623.  
  624.       if (token[token_count] != NULL) {
  625.          do {
  626.             token_count = token_count + 1;
  627.             token[token_count] = strtok((char *) NULL, " \t,;\n\r");
  628.             } while ((token[token_count] != NULL) &&
  629.                      (token_count < MAX_TOKENS));
  630.          }
  631.       else {
  632.          token[0] = cmd;
  633.          *token[0] = '\0';
  634.          }
  635.       }
  636.  
  637.    return (token_count);
  638.  
  639.    }  /* end tokenize_cmd() */
  640.  
  641.  
  642.  
  643. /*
  644. ** This function is used to convert a list of tokens
  645. ** to all lower case letters.
  646. */
  647.  
  648. void
  649. lcase_tokens(token, token_count)
  650.    char *token[MAX_TOKENS];
  651.    int   token_count;
  652.    {
  653.    int   i;
  654.    char *temp_str;
  655.  
  656.    for (i=0; i<token_count; i=i+1) {
  657.       temp_str = token[i];
  658.       while (*temp_str != '\0') {
  659.          if (isupper(*temp_str))
  660.             *temp_str = (char) tolower(*temp_str);
  661.          temp_str++;
  662.          }
  663.       }  /* end for() */
  664.    }  /* end lcase_string() */
  665.  
  666.  
  667. INT32
  668. Mini_go_forever()
  669. {
  670.   static  int    complete=0;
  671.  
  672.    /* Terminal control initialization. */
  673.    io_config.io_control = TERM_USER;    /* 3.1-7 */
  674.    io_config.target_running = TRUE;
  675.  
  676. #ifndef    MSDOS
  677.    ioctl (fileno(stdin), TCGETA, &OldTermbuf);    /* Initial settings */
  678. #endif
  679.  
  680.    /* Install ctrl-C handler */
  681.  
  682.    if (signal (SIGINT, Mini_Ctrl_C_Handler) == SIG_ERR) {
  683.      fprintf(stderr, "Ctrl-C handler not installed.\n"); /* warning */
  684.      if (io_config.echo_mode == (INT32) TRUE)
  685.         fprintf(io_config.echo_file, "Ctrl-C handler not installed.\n"); /* warning */
  686.    }
  687.    /*
  688.    ** Open cmd file (if necessary)
  689.    */
  690.  
  691.    if (io_config.cmd_file_io == TRUE) {  /* TRUE if -c option given */
  692.       io_config.cmd_file = fopen(io_config.cmd_filename, "r");
  693.         if (io_config.cmd_file == NULL) {
  694.             warning (EMCMDOPEN);
  695.             io_config.cmd_file_io = FALSE;
  696.         } else {
  697.       /* MON_STDIN is command file */
  698.       MON_STDIN = fileno(io_config.cmd_file); /* set MON_STDIN */
  699.     };
  700.    }
  701.  
  702.    Mini_go();  /* set target running */
  703.  
  704.    do {
  705.  
  706.       /*
  707.       ** If the target was set to run, get its current status.
  708.       */
  709.       if (Mini_get_target_stats((INT32) udi_waittime, &ProcessorState) != SUCCESS) {
  710.          Mini_TIP_DestroyProc();
  711.          Mini_TIP_exit();
  712.      fatal_error(EMFATAL);
  713.       }
  714.       GrossState = (int) (ProcessorState & 0xFF);
  715.       switch (GrossState) {
  716.     case    NOTEXECUTING:  /* do nothing */
  717.         io_config.io_control = TERM_USER;
  718.                 io_config.target_running = FALSE;
  719.         break;
  720.     case    EXITED:  /* do nothing */
  721.          if (!QuietMode) {
  722.          fprintf (stderr, "Process exited with 0x%lx\n",
  723.                            (ProcessorState >> 8));
  724.               if (io_config.echo_mode == (INT32) TRUE)
  725.             fprintf (io_config.echo_file, "Process exited with 0x%lx\n",
  726.                            (ProcessorState >> 8));
  727.          }
  728.         io_config.io_control = TERM_USER;
  729.                 io_config.target_running = FALSE;
  730.         complete=1;
  731.         break;
  732.     case    RUNNING:    /* any request from target? */
  733.         break;
  734.     case    STOPPED:
  735.         complete=1;
  736.         io_config.io_control = TERM_USER;
  737.                 io_config.target_running = FALSE;
  738.         fprintf(stderr, "Execution stopped at ");
  739.              if (io_config.echo_mode == (INT32) TRUE)
  740.            fprintf(io_config.echo_file, "Execution stopped at ");
  741.         display_msg();
  742.         break;
  743.     case    BREAK:
  744.         complete=1;
  745.         io_config.io_control = TERM_USER;
  746.                 io_config.target_running = FALSE;
  747.         fprintf(stderr, "Breakpoint hit at ");
  748.              if (io_config.echo_mode == (INT32) TRUE)
  749.            fprintf(io_config.echo_file, "Breakpoint hit at ");
  750.         display_msg();
  751.         break;
  752.     case    STEPPED:
  753.         complete=1;
  754.         io_config.io_control = TERM_USER;
  755.                 io_config.target_running = FALSE;
  756.         fprintf(stderr, "Stepping...Execution stopped at ");
  757.              if (io_config.echo_mode == (INT32) TRUE)
  758.            fprintf(io_config.echo_file, "Stepping...Execution stopped at ");
  759.         display_msg();
  760.         break;
  761.     case    WAITING:
  762.         complete=1;
  763.         io_config.io_control = TERM_USER;
  764.                 io_config.target_running = FALSE;
  765.         break;
  766.     case    HALTED:
  767.         complete=1;
  768.         io_config.io_control = TERM_USER;
  769.                 io_config.target_running = FALSE;
  770.         fprintf(stderr, "Execution halted at ");
  771.              if (io_config.echo_mode == (INT32) TRUE)
  772.            fprintf(io_config.echo_file, "Execution halted at ");
  773.         display_msg();
  774.         break;
  775.     case    WARNED:
  776.         complete=1;
  777.         io_config.io_control = TERM_USER;
  778.                 io_config.target_running = FALSE;
  779.         break;
  780.     case    TRAPPED:
  781.         complete=1;
  782.         io_config.io_control = TERM_USER;
  783.                 io_config.target_running = FALSE;
  784.         PrintTrapMsg((int) (ProcessorState >> 8));
  785.         display_msg();
  786.         break;
  787.     case    STDOUT_READY:
  788.         io_bufsize = 0;
  789.         io_count_done = (INT32) 0;
  790.         do {
  791.           Mini_get_stdout(io_buffer, IO_BUFSIZE, &io_count_done);
  792.           write(MON_STDOUT, &io_buffer[0], (int) io_count_done);
  793.           if (io_config.echo_mode == (INT32) TRUE) {
  794.              fflush (io_config.echo_file);
  795.              write (fileno(io_config.echo_file), &io_buffer[0], (int) io_count_done);
  796.           }
  797.         } while (io_count_done == (INT32) IO_BUFSIZE);
  798.         break;
  799.     case    STDERR_READY:
  800.         io_bufsize = 0;
  801.         io_count_done = (INT32) 0;
  802.         do {
  803.           Mini_get_stderr(io_buffer, IO_BUFSIZE, &io_count_done);
  804.           write(MON_STDERR, &io_buffer[0], (int) io_count_done);
  805.           if (io_config.echo_mode == (INT32) TRUE) {
  806.              fflush (io_config.echo_file);
  807.              write (fileno(io_config.echo_file), &io_buffer[0], (int) io_count_done);
  808.           }
  809.         } while (io_count_done == (INT32) IO_BUFSIZE);
  810.         break;
  811.     case    STDIN_NEEDED:
  812.         /* Line buffered reads only */
  813.         if (io_config.cmd_file_io == TRUE) { /* read from command file */
  814.            if (Mini_cmdfile_input(io_buffer, IO_BUFSIZE) == SUCCESS) {
  815.               io_bufsize = strlen(io_buffer);
  816.               fprintf(stderr, "%s", io_buffer); /* echo */
  817.                    if (io_config.echo_mode == (INT32) TRUE)
  818.                   fprintf(io_config.echo_file, "%s", io_buffer); /* echo */
  819.            } else { /* read from terminal */
  820.              io_bufsize = read( fileno(stdin), io_buffer, IO_BUFSIZE );
  821.            }
  822.         } else {
  823.            io_bufsize = read( fileno(stdin), io_buffer, IO_BUFSIZE );
  824.         };
  825.         if (io_bufsize < 0)
  826.         {
  827.            fprintf(stderr, "fatal error reading from stdin\n");
  828.                 if (io_config.echo_mode == (INT32) TRUE)
  829.                fprintf(io_config.echo_file, "fatal error reading from stdin\n");
  830.         }
  831.         if (io_config.echo_mode == (INT32) TRUE) {
  832.           fflush (io_config.echo_file);
  833.           write (fileno(io_config.echo_file), &io_buffer[0], (int) io_bufsize);
  834.         }
  835.         Mini_put_stdin(io_buffer, io_bufsize, &io_count_done);
  836.         break;
  837.     case    STDINMODEX:
  838.         /* call TIP to get StdinMode */
  839.         Mini_stdin_mode_x((INT32 *)&TipStdinMode);
  840.         if (TipStdinMode & TIP_NBLOCK)
  841.           io_config.io_control = TERM_29K;
  842.         else if (TipStdinMode & TIP_ASYNC)
  843.           io_config.io_control = TERM_29K;
  844.         else if (TipStdinMode == TIP_COOKED)
  845.           io_config.io_control = TERM_USER;
  846.         else {
  847.           fprintf(stderr, "DFEWARNING: TIP Requested Stdin Mode Not Supported.\n");
  848.           fprintf(stderr, "DFEWARNING: Using default mode.\n");
  849.           TipStdinMode = TIP_COOKED;
  850.           io_config.io_control = TERM_USER;
  851.         }
  852.         if (io_config.io_control == TERM_29K)
  853.           display_term29k();
  854.         break;
  855.  
  856.     default:
  857.         complete=1;
  858.         io_config.io_control = TERM_USER;
  859.                 io_config.target_running = FALSE;
  860.         break;
  861.       }; /* end switch */
  862. #ifdef    MSDOS
  863.       if (!complete)
  864.     kbhit();    /* Poll for Ctrl-C */
  865. #endif
  866.       if (CtrlCHit) {
  867.      CtrlCHit = 0;
  868.      complete = 1;
  869.       }
  870.  
  871.       if (io_config.io_control == TERM_29K)
  872.     if (GrossState == RUNNING)
  873.           Mini_poll_channel0();    /* non-blocking */
  874.       else
  875.     TipStdinMode = TIP_COOKED;
  876.  
  877.    } while (!complete);
  878. #ifndef MSDOS
  879.    ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  880. #endif
  881.  
  882.    fflush(stdout);
  883.    fflush(stderr);
  884.  
  885.    Mini_TIP_DestroyProc();
  886.    Mini_TIP_exit();
  887.  
  888.    NumberOfConnections=0;
  889.    return (SUCCESS);
  890. }
  891.  
  892.  
  893. INT32
  894. get_pc_addrs(pc1, cps)
  895. ADDR32    *pc1;
  896. ADDR32    *cps;
  897. {
  898.    ADDR32    pc_1;
  899.    ADDR32    cps_b;
  900.    INT32    hostendian;
  901.    INT32    bytes_ret;
  902.    INT32    retval;
  903.  
  904.    hostendian = FALSE;
  905.    if ((retval = Mini_read_req (PC_SPACE,
  906.                 (ADDR32) 0, /* doesn't matter */
  907.                 (INT32) 1,
  908.                 (INT16) 4, /* size */
  909.                 &bytes_ret,
  910.                 (BYTE *) &pc_1,
  911.                 hostendian)) != SUCCESS) {
  912.     return(FAILURE);
  913.    };
  914.  
  915.    *pc1 = (ADDR32) pc_1;
  916.    if (host_config.host_endian != host_config.target_endian)  {
  917.       convert32((BYTE *)pc1);
  918.    }
  919.  
  920.    /* get cps */
  921.    hostendian = FALSE;
  922.    if ((retval = Mini_read_req (SPECIAL_REG,
  923.                 (ADDR32) 2,
  924.                 (INT32) 1,
  925.                 (INT16) 4, /* size */
  926.                 &bytes_ret,
  927.                 (BYTE *) &cps_b,
  928.                 hostendian)) != SUCCESS) {
  929.     return(FAILURE);
  930.    };
  931.    *cps = (ADDR32) cps_b;
  932.    if (host_config.host_endian != host_config.target_endian)  {
  933.       convert32((BYTE *)cps);
  934.    }
  935.  
  936.    return (SUCCESS);
  937. }
  938.  
  939. INT32
  940. get_pc1_inst(cps, pc1, inst)
  941. ADDR32    cps;
  942. ADDR32    pc1;
  943. BYTE    *inst;
  944. {
  945.    INT32    bytes_ret;
  946.    INT32    hostendian;
  947.    INT32    retval;
  948.    INT32    memory_space;
  949.  
  950.    hostendian = FALSE;
  951.  
  952.    if (cps & 0x100L) /* RE bit */
  953.      memory_space = I_ROM;
  954.    else
  955.      memory_space = I_MEM;
  956.  
  957.    if ((retval = Mini_read_req(memory_space,
  958.                    pc1,
  959.                    (INT32) 1,
  960.                    (INT16) sizeof(INST32),  /* size */
  961.                    &bytes_ret,
  962.                    (BYTE *) inst,
  963.                    hostendian)) != SUCCESS) {
  964.     return(FAILURE);
  965.    };
  966.    return (SUCCESS);
  967. }
  968.  
  969. void
  970. display_msg()
  971. {
  972.         ADDR32    c_pc1;
  973.         ADDR32    c_cps;
  974.  
  975.         union instruction_t {
  976.           BYTE    buf[sizeof(struct instr_t)];
  977.           struct instr_t  instr;
  978.         };
  979.         union instruction_t instruction;
  980.         struct    instr_t        temp;
  981.  
  982.         (void) get_pc_addrs(&c_pc1, &c_cps);
  983.         (void) get_pc1_inst(c_cps, c_pc1, instruction.buf);
  984.         fprintf(stderr, " %08lx\n", c_pc1);
  985.              if (io_config.echo_mode == (INT32) TRUE)
  986.             fprintf(io_config.echo_file, " %08lx\n", c_pc1);
  987.         if (host_config.target_endian == LITTLE) {
  988.           temp.op = instruction.instr.b;
  989.           temp.c = instruction.instr.a;
  990.           temp.a = instruction.instr.c;
  991.           temp.b = instruction.instr.op;
  992.         } else { /* default BIG endian */
  993.           temp.op = instruction.instr.op;
  994.           temp.c = instruction.instr.c;
  995.           temp.a = instruction.instr.a;
  996.           temp.b = instruction.instr.b;
  997.         }
  998.         fprintf(stderr, "%08lx\t %02x%02x%02x%02x\t", c_pc1,
  999.                      temp.op,
  1000.                      temp.c,
  1001.                      temp.a,
  1002.                      temp.b);
  1003.              if (io_config.echo_mode == (INT32) TRUE)
  1004.            fprintf(io_config.echo_file, "%08lx\t %02x%02x%02x%02x\t", c_pc1,
  1005.                      temp.op,
  1006.                      temp.c,
  1007.                      temp.a,
  1008.                      temp.b);
  1009.         (void) dasm_instr(c_pc1, &(temp));
  1010.       if (io_config.io_control == TERM_USER) {
  1011.            fprintf(stderr, "\n%s>", ProgramName);
  1012.         fflush(stderr);
  1013.              if (io_config.echo_mode == (INT32) TRUE)
  1014.               fprintf(io_config.echo_file, "\n%s>", ProgramName);
  1015.       }
  1016. }
  1017.  
  1018. int
  1019. Mini_cmdfile_input(cmd_buffer, size)
  1020. char    *cmd_buffer;
  1021. int    size;
  1022. {
  1023.  if (fgets(cmd_buffer, size, io_config.cmd_file) == NULL) {
  1024.    io_config.cmd_file_io = FALSE;
  1025.    (void) fclose(io_config.cmd_file);
  1026.    MON_STDIN = fileno (stdin); /* reset to terminal after EOF */
  1027.    return (FAILURE);
  1028.  } else {
  1029.    return (SUCCESS);
  1030.  }
  1031. }
  1032.  
  1033. void
  1034. Mini_Ctrl_C_Handler(num)
  1035. int    num;
  1036. {
  1037.    CtrlCHit = 1;  /* used for run-only mode, no debugging */
  1038.    if (io_config.io_control == TERM_29K) {
  1039. #ifndef    MSDOS
  1040.      ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  1041. #endif
  1042.    }
  1043.    if (io_config.target_running == TRUE)
  1044.       Mini_break();
  1045.    io_config.cmd_ready == FALSE;
  1046. #ifdef MSDOS
  1047.   if (signal (SIGINT, Mini_Ctrl_C_Handler) == SIG_ERR) {
  1048.      fprintf(stderr, "Ctrl-C handler not installed.\n"); /* warning */
  1049.      if (io_config.echo_mode == (INT32) TRUE)
  1050.         fprintf(io_config.echo_file, "Ctrl-C handler not installed.\n"); /* warning */
  1051.   }
  1052. #endif
  1053.   return;
  1054. }
  1055.  
  1056. static    int
  1057. FindCmdIndx(CmdString)
  1058. char    *CmdString;
  1059. {
  1060.   int    i;
  1061.  
  1062.   i = 0;
  1063.   while (MonitorCommands[i].CmdString) {
  1064.     if (strcmp(CmdString, MonitorCommands[i].CmdString))
  1065.       i++;
  1066.     else
  1067.       return (i);
  1068.   };
  1069.   return (-1);
  1070. }
  1071.  
  1072. INT32
  1073. escape_cmd(token, tokencnt)
  1074. char    **token;
  1075. int    tokencnt;
  1076. {
  1077.   int    retval;
  1078. #ifdef    MSDOS
  1079.   if ((retval = system ((char *) getenv("COMSPEC"))) != 0)
  1080.      return ((INT32) EMDOSERR);
  1081.   return ((INT32) SUCCESS);
  1082. #else
  1083.   if ((retval = system ((char *) getenv("SHELL"))) != 0)
  1084.     return ((INT32) EMSYSERR);
  1085.   return ((INT32) SUCCESS);
  1086. #endif
  1087. }
  1088.  
  1089. INT32
  1090. dummy_cmd(token, tokencnt)
  1091. char    **token;
  1092. int    tokencnt;
  1093. {
  1094.   return ((INT32) 0);
  1095. }
  1096.  
  1097. INT32
  1098. quit_cmd(token, tokencnt)
  1099. char    **token;
  1100. int    tokencnt;
  1101. {
  1102.    int    i;
  1103.  
  1104.    for (i =0; i < NumberOfConnections; i++) {
  1105.       Mini_TIP_SetCurrSession(Session_ids[i]);
  1106.       Mini_TIP_DestroyProc();
  1107.       Mini_TIP_exit();
  1108.    };
  1109.    fflush(stdout);
  1110.    fflush(stderr);
  1111.    exit_loop = TRUE;
  1112.    NumberOfConnections=0;
  1113.    return ((INT32) 0);
  1114. }
  1115.  
  1116. INT32
  1117. connect_cmd(token, tokencnt)
  1118. char    **token;
  1119. int    tokencnt;
  1120. {
  1121.   INT32        retval;
  1122.  
  1123.   if (tokencnt < 2)
  1124.     return (EMSYNTAX);
  1125.  
  1126.   if ((retval = Mini_TIP_init(token[1], &Session_ids[NumberOfConnections]))
  1127.                        == SUCCESS) {
  1128.       NumberOfConnections=NumberOfConnections+1;
  1129.   };
  1130.  
  1131.   return ((INT32) retval);
  1132. }
  1133.  
  1134. INT32
  1135. disconnect_cmd(token, tokencnt)
  1136. char    **token;
  1137. int    tokencnt;
  1138. {
  1139.   INT32        retval;
  1140.   int        i;
  1141.  
  1142.   if ((retval = Mini_TIP_disc()) != SUCCESS)
  1143.      return ((INT32) retval);
  1144.   else { /* find some other session */
  1145.      NumberOfConnections=NumberOfConnections - 1;
  1146.      for (i = 0; i < NumberOfConnections; i++) {
  1147.         if ((retval = Mini_TIP_SetCurrSession(Session_ids[i])) == SUCCESS) 
  1148.         return (retval);
  1149.      }
  1150.      if (i >= NumberOfConnections)  { /* exit DFE */
  1151.      exit_loop = TRUE;
  1152.      }
  1153.   }
  1154.  
  1155.   return ((INT32) retval);
  1156. }
  1157.  
  1158. INT32
  1159. create_proc_cmd(token, tokencnt)
  1160. char    **token;
  1161. int    tokencnt;
  1162. {
  1163.   INT32        retval;
  1164.  
  1165.   retval = Mini_TIP_CreateProc();
  1166.  
  1167.   return ((INT32) retval);
  1168. }
  1169.  
  1170. INT32
  1171. capab_cmd(token, tokencnt)
  1172. char    **token;
  1173. int    tokencnt;
  1174. {
  1175.   INT32        retval;
  1176.  
  1177.   retval = Mini_TIP_Capabilities();
  1178.  
  1179.   return ((INT32) retval);
  1180. }
  1181.  
  1182. INT32
  1183. exit_conn_cmd(token, tokencnt)
  1184. char    **token;
  1185. int    tokencnt;
  1186. {
  1187.   INT32        retval;
  1188.   int        i;
  1189.  
  1190.   if ((retval = Mini_TIP_exit()) != SUCCESS) {;
  1191.      return (retval);
  1192.   } else { /* find some other session */
  1193.      NumberOfConnections=NumberOfConnections - 1;
  1194.      for (i = 0; i < NumberOfConnections; i++) {
  1195.         if ((retval = Mini_TIP_SetCurrSession(Session_ids[i])) == SUCCESS) 
  1196.         return (retval);
  1197.      }
  1198.      if (i >= NumberOfConnections)  { /* exit DFE */
  1199.      exit_loop = TRUE;
  1200.      }
  1201.   }
  1202.  
  1203.  
  1204.   return ((INT32) retval);
  1205. }
  1206.  
  1207. INT32
  1208. init_proc_cmd(token, tokencnt)
  1209. char    **token;
  1210. int    tokencnt;
  1211. {
  1212.   INT32        retval;
  1213.  
  1214.   retval = Mini_send_init_info(&init_info);
  1215.  
  1216.   return ((INT32) retval);
  1217. }
  1218.  
  1219. INT32
  1220. destroy_proc_cmd(token, tokencnt)
  1221. char    **token;
  1222. int    tokencnt;
  1223. {
  1224.   INT32        retval;
  1225.  
  1226.   retval = Mini_TIP_DestroyProc();
  1227.  
  1228.   return ((INT32) retval);
  1229. }
  1230.  
  1231. INT32
  1232. set_sessionid_cmd(token, tokencnt)
  1233. char    **token;
  1234. int    tokencnt;
  1235. {
  1236.   INT32        retval;
  1237.   int        sid;
  1238.  
  1239.   if (tokencnt < 2)
  1240.     return (EMSYNTAX);
  1241.  
  1242.   if (sscanf(token[1],"%d",&sid) != 1)
  1243.     return (EMSYNTAX);
  1244.  
  1245.   retval = Mini_TIP_SetCurrSession(sid);
  1246.  
  1247.   return ((INT32) retval);
  1248. }
  1249.  
  1250. INT32
  1251. set_pid_cmd(token, tokencnt)
  1252. char    **token;
  1253. int    tokencnt;
  1254. {
  1255.   INT32        retval;
  1256.   int        pid;
  1257.  
  1258.   if (tokencnt < 2)
  1259.     return (EMSYNTAX);
  1260.  
  1261.   if (sscanf(token[1],"%d",&pid) != 1)
  1262.     return (EMSYNTAX);
  1263.  
  1264.   retval = Mini_TIP_SetPID(pid);
  1265.  
  1266.   return ((INT32) retval);
  1267. }
  1268.  
  1269.  
  1270. INT32
  1271. go_cmd(token, token_count)
  1272.    char   *token[];
  1273.    int     token_count;
  1274.    {
  1275.  
  1276.    INT32    retval;
  1277.  
  1278.    if ((retval = Mini_go()) != SUCCESS) {
  1279.      return(FAILURE);
  1280.    } else {
  1281.      GoCmdFlag = 1;
  1282.      BlockMode = NONBLOCK;
  1283.      if (TipStdinMode & TIP_NBLOCK) 
  1284.       io_config.io_control = TERM_29K;
  1285.      else if (TipStdinMode & TIP_ASYNC)
  1286.       io_config.io_control = TERM_29K;
  1287.      else if (TipStdinMode == TIP_COOKED)
  1288.       io_config.io_control = TERM_USER;
  1289.      else {
  1290.           TipStdinMode = TIP_COOKED;
  1291.       io_config.io_control = TERM_USER;
  1292.      }
  1293.      io_config.target_running = TRUE;
  1294.      return(SUCCESS);
  1295.    };
  1296.  
  1297. }  /* end go_cmd() */
  1298.  
  1299. /*
  1300. ** This command is used to "trace" or step through code.
  1301. ** A "t" command with no parameters defaults to a single.
  1302. ** step.  A "t" command with an integer value following
  1303. ** steps for as many instructions as is specified by
  1304. ** that integer.
  1305. */
  1306.  
  1307. INT32
  1308. trace_cmd(token, token_count)
  1309.    char   *token[];
  1310.    int     token_count;
  1311.    {
  1312.    int    result;
  1313.    INT32  count;
  1314.    INT32    retval;
  1315.  
  1316.    if (token_count == 1) {
  1317.       count = 1; 
  1318.       }
  1319.    else
  1320.    if (token_count >= 2) {
  1321.       result = get_word(token[1], &count);
  1322.       if (result != 0)
  1323.          return (EMSYNTAX);
  1324.       }
  1325.  
  1326.    if ((retval = Mini_step(count)) != SUCCESS) {
  1327.      return(FAILURE);
  1328.    } else {
  1329.      GoCmdFlag = 1;
  1330.      BlockMode = NONBLOCK;
  1331.      if (TipStdinMode & TIP_NBLOCK) 
  1332.       io_config.io_control = TERM_29K;
  1333.      else if (TipStdinMode & TIP_ASYNC)
  1334.       io_config.io_control = TERM_29K;
  1335.      else if (TipStdinMode == TIP_COOKED)
  1336.       io_config.io_control = TERM_USER;
  1337.      else {
  1338.           TipStdinMode = TIP_COOKED;
  1339.       io_config.io_control = TERM_USER;
  1340.      }
  1341.      io_config.target_running = TRUE;
  1342.      return(SUCCESS);
  1343.    }
  1344.  
  1345.    }  /* end trace_cmd() */
  1346.  
  1347. /*
  1348.  * The "ch0" command is used to send characters (input) to the application
  1349.  * program asynchronously. This command deinstalls the control-C handler,
  1350.  * sets up input to raw mode, polls the keyboard, sends the bytes to the
  1351.  * TIP. The command is exited when Ctrl-U is typed.
  1352.  */
  1353.  
  1354. INT32
  1355. channel0_cmd(token, token_count)
  1356.    char   *token[];
  1357.    int     token_count;
  1358. {
  1359.       io_config.io_control = TERM_29K;
  1360. #ifndef MSDOS
  1361.       ioctl (fileno(stdin), TCGETA, &NewTermbuf);     /* New settings */
  1362.       NewTermbuf.c_lflag &= ~(ICANON);
  1363.       NewTermbuf.c_cc[4] = 0;        /* MIN */
  1364.       NewTermbuf.c_cc[5] = 0;        /* TIME */
  1365.       ioctl (fileno(stdin), TCSETA, &NewTermbuf); /* Set new settings */
  1366. #endif
  1367.   return (0);
  1368. }
  1369.  
  1370. /*
  1371.  * Only for stdin, not for command file input 
  1372.  */
  1373. INT32
  1374. Mini_poll_channel0()
  1375. {
  1376.   BYTE    ch;
  1377.  
  1378.     /* read from terminal */
  1379. #ifdef MSDOS
  1380.       /* CBREAK mode */
  1381.       if (kbhit()) {
  1382.          ch = (unsigned char) getche();
  1383.      if (io_config.echo_mode == (INT32) TRUE) {
  1384.        putc (ch, io_config.echo_file);
  1385.        fflush (io_config.echo_file);
  1386.      }
  1387.          if (ch == (BYTE) TOGGLE_CHAR) { /* Ctrl-U typed, give control back to User */
  1388.            io_config.io_control = TERM_USER;
  1389.        display_termuser();
  1390.            return (0);
  1391.          } else {
  1392.        if (ch == (unsigned char) 13) { /* \r, insert \n */
  1393.          putchar(10);    /* line feed */
  1394.          if (io_config.echo_mode == (INT32) TRUE) {
  1395.            putc (ch, io_config.echo_file);
  1396.            fflush (io_config.echo_file);
  1397.          }
  1398.        }
  1399. #ifdef MSDOS
  1400.        if (ch == (unsigned char) 10) { /* \n, ignore \n */
  1401.          return (0);
  1402.        }
  1403. #endif
  1404.            Mini_put_stdin((char *)&ch, 1, &io_count_done);
  1405.            return (0);
  1406.          }
  1407.        }
  1408.        return(0);
  1409. #else    /* Unix */
  1410.      /* 
  1411.       * Set STDIN to CBREAK mode. For each character read() send it
  1412.       * to TIP using Mini_put_stdin(). This is done only if the
  1413.       * terminal is controlled by the 29K Target System, i.e. when
  1414.       * io_config.io_control == TERM_29K. Otherwise, this function should
  1415.       * not be called as it would affect the command-line processing.
  1416.       */
  1417.       /* while ((io_bufsize = read (fileno(stdin), &ch, 1)) == 1) { */
  1418.       if ((io_bufsize = read (fileno(stdin), &ch, 1)) == 1) { 
  1419.     if (io_config.echo_mode == (INT32) TRUE) {
  1420.       putc (ch, io_config.echo_file);
  1421.       fflush (io_config.echo_file);
  1422.     }
  1423.     if (ch == (BYTE) TOGGLE_CHAR) { /* process ctrl-U */
  1424.          ioctl (fileno(stdin), TCSETA, &OldTermbuf); /* reset old settings */
  1425.          io_config.io_control = TERM_USER;
  1426.      display_termuser();
  1427.          return (0);
  1428.     } else { /* send it to TIP */
  1429.          Mini_put_stdin((char *)&ch, 1, &io_count_done);
  1430.     }
  1431.       }
  1432.      return (0);
  1433. #endif
  1434. } /* end Mini_poll_channel0() */
  1435.  
  1436. void
  1437. PrintTrapMsg(num)
  1438. int    num;
  1439. {
  1440.   if ((num >= 0) && (num <= 22)) {
  1441.     fprintf(stderr, "%s Trap occurred at ", TrapMsg[num]);
  1442.     if (io_config.echo_mode == (INT32) TRUE)
  1443.        fprintf(io_config.echo_file, "%s Trap occurred at ", TrapMsg[num]);
  1444.   } else {
  1445.     fprintf(stderr, "Trap %d occurred at ");
  1446.     if (io_config.echo_mode == (INT32) TRUE)
  1447.        fprintf(io_config.echo_file, "Trap %d occurred at ");
  1448.   }
  1449. }
  1450.  
  1451. void
  1452. display_term29k()
  1453. {
  1454.     fprintf(stderr,"\nTerminal controlled 29K target...Type Ctrl-U <ret> for mondfe prompt\n");
  1455.     fflush (stderr);
  1456.     if (io_config.echo_mode == (INT32) TRUE)
  1457.        fprintf(stderr,"\nTerminal controlled 29K target...Type Ctrl-U <ret> for mondfe prompt\n");
  1458. #ifndef MSDOS
  1459.       ioctl (fileno(stdin), TCGETA, &NewTermbuf);     /* New settings */
  1460.       NewTermbuf.c_lflag &= ~(ICANON);
  1461.       NewTermbuf.c_cc[4] = 0;        /* MIN */
  1462.       NewTermbuf.c_cc[5] = 0;        /* TIME */
  1463.       ioctl (fileno(stdin), TCSETA, &NewTermbuf); /* Set new settings */
  1464. #endif
  1465. }
  1466.  
  1467. void
  1468. display_termuser()
  1469. {
  1470. #ifndef MSDOS
  1471.     ioctl (fileno(stdin), TCSETA, &OldTermbuf); /*reset settings */
  1472. #endif
  1473.    /* Print a prompt */
  1474.   fprintf(stderr, "\n%s>", ProgramName);
  1475.   if (io_config.echo_mode == (INT32) TRUE)
  1476.     fprintf(io_config.echo_file, "\n%s>", ProgramName);
  1477. }
  1478.  
  1479. INT32
  1480. quietmode_off(token, token_count)
  1481.    char   *token[];
  1482.    int     token_count;
  1483. {
  1484.   QuietMode = 0;
  1485.   return (0);
  1486. }
  1487.  
  1488. INT32
  1489. quietmode_on(token, token_count)
  1490.    char   *token[];
  1491.    int     token_count;
  1492. {
  1493.   QuietMode = 1;
  1494.   return (0);
  1495. }
  1496.  
  1497. INT32
  1498. logoff_cmd(token, token_count)
  1499.    char   *token[];
  1500.    int     token_count;
  1501. {
  1502.    if (io_config.log_mode == (INT32) TRUE) { 
  1503.      io_config.log_mode = (INT32) FALSE;
  1504.      (void) fclose(io_config.log_file);
  1505.    }
  1506.    return (0);
  1507. }
  1508.  
  1509. INT32
  1510. logon_cmd(token, token_count)
  1511.    char   *token[];
  1512.    int     token_count;
  1513. {
  1514.    if (io_config.log_mode == (INT32) FALSE) { 
  1515.      if (strcmp(io_config.log_filename, "\0") != 0) {/* valid file */
  1516.        io_config.log_mode = (INT32) TRUE;
  1517.        if ((io_config.log_file = fopen(io_config.log_filename, "a")) == NULL)
  1518.        {
  1519.           io_config.log_mode = (INT32) FALSE;
  1520.           warning(EMLOGOPEN);
  1521.        };
  1522.      } else {
  1523.        warning(EMLOGOPEN);
  1524.      }
  1525.    }
  1526.    return (0);
  1527. }
  1528.  
  1529. INT32
  1530. set_logfile(token, token_count)
  1531.    char   *token[];
  1532.    int     token_count;
  1533. {
  1534.   if (token_count < 2) /* insufficient number of args */
  1535.     return (EMSYNTAX);
  1536.  
  1537.   (void) strcpy ((char *)(&(io_config.log_filename[0])),token[1]);
  1538.  
  1539.   if (io_config.log_mode == (INT32) TRUE) { /* replace log file used */
  1540.      if ((io_config.log_file = 
  1541.               fopen (io_config.log_filename, "w")) == NULL) {
  1542.         warning (EMLOGOPEN);
  1543.         io_config.log_mode = (INT32) FALSE;
  1544.      }
  1545.   } else {
  1546.      io_config.log_mode = (INT32) TRUE;
  1547.      if ((io_config.log_file = 
  1548.               fopen (io_config.log_filename, "w")) == NULL) {
  1549.         warning (EMLOGOPEN);
  1550.         io_config.log_mode = (INT32) FALSE;
  1551.      } 
  1552.   }
  1553.   return (0);
  1554.  
  1555. }
  1556.  
  1557. INT32
  1558. echomode_on(token, token_count)
  1559.    char   *token[];
  1560.    int     token_count;
  1561. {
  1562.   if (io_config.echo_mode == (INT32) FALSE) {
  1563.     if (strcmp(io_config.echo_filename, "\0") != 0) { /* if valid file in effect */
  1564.        io_config.echo_mode = (INT32) TRUE;
  1565.        if ((io_config.echo_file = fopen (io_config.echo_filename, "a")) == NULL)
  1566.        {
  1567.      warning (EMECHOPEN);
  1568.      io_config.echo_mode = (INT32) FALSE;
  1569.        }
  1570.     } else
  1571.        warning(EMINVECHOFILE);
  1572.   }
  1573.   return (0);
  1574. }
  1575.  
  1576. INT32
  1577. echomode_off(token, token_count)
  1578.    char   *token[];
  1579.    int     token_count;
  1580. {
  1581.   if (io_config.echo_mode == (INT32) TRUE)  {
  1582.     io_config.echo_mode = (INT32) FALSE;
  1583.     (void) fclose(io_config.echo_file);
  1584.   }
  1585.   return (0);
  1586. }
  1587.  
  1588. INT32
  1589. echofile_cmd(token, token_count)
  1590.    char   *token[];
  1591.    int     token_count;
  1592. {
  1593.   if (token_count < 2) /* insufficient number of args */
  1594.     return (EMSYNTAX);
  1595.  
  1596.   (void) strcpy ((char *)(&(io_config.echo_filename[0])),token[1]);
  1597.  
  1598.   if (io_config.echo_mode == (INT32) TRUE) { /* replace echo file used */
  1599.      if ((io_config.echo_file = 
  1600.               fopen (io_config.echo_filename, "w")) == NULL) {
  1601.         warning (EMECHOPEN);
  1602.         io_config.echo_mode = (INT32) FALSE;
  1603.      }
  1604.   } else {
  1605.      io_config.echo_mode = (INT32) TRUE;
  1606.      if ((io_config.echo_file = 
  1607.               fopen (io_config.echo_filename, "w")) == NULL) {
  1608.         warning (EMECHOPEN);
  1609.         io_config.echo_mode = (INT32) FALSE;
  1610.      } 
  1611.   }
  1612.   return (0);
  1613. }
  1614.  
  1615. INT32
  1616. cmdfile_cmd(token, token_count)
  1617.    char   *token[];
  1618.    int     token_count;
  1619. {
  1620.   if (token_count < 2)
  1621.      return (EMSYNTAX);
  1622.  
  1623.   (void) strcpy((char *)(&(io_config.cmd_filename[0])),token[1]);
  1624.  
  1625.   if (io_config.cmd_file_io == (INT32) TRUE) {
  1626.     warning (EMCMDFILENEST); /* command file nesting not allowed */
  1627.   } else {
  1628.     io_config.cmd_file_io = (INT32) TRUE;
  1629.     if ((io_config.cmd_file = fopen (io_config.cmd_filename,"r")) == NULL) {
  1630.       warning (EMCMDOPEN);
  1631.       io_config.cmd_file_io = (INT32) FALSE;
  1632.     } else {
  1633.        /* MON_STDIN is command file */
  1634.        MON_STDIN = fileno(io_config.cmd_file); /* set MON_STDIN */
  1635.     }
  1636.   }
  1637.  
  1638.   return (0);
  1639. }
  1640.  
  1641. INT32
  1642. tip_cmd(token, token_count)
  1643.    char   *token[];
  1644.    int     token_count;
  1645. {
  1646.   if (token_count < 2)
  1647.     return (EMSYNTAX);
  1648.  
  1649.   sprintf(tip_cmd_buffer, "%s %s\0", token[0], token[1]);
  1650.  
  1651.   Mini_put_trans(tip_cmd_buffer);
  1652.  
  1653.   return (0);
  1654. }
  1655.