OpenCores
URL https://opencores.org/ocsvn/or1k/or1k/trunk

Subversion Repositories or1k

[/] [or1k/] [tags/] [start/] [gdb-5.0/] [utils/] [amd-udi/] [mondfe/] [monitor.c] - Blame information for rev 1765

Details | Compare with Previous | View Log

Line No. Rev Author Line
1 106 markom 
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 
}

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.