static char _[] = "@(#)main.c	5.27 93/10/27 15:11:04, Srini, AMD";
/******************************************************************************
 * Copyright 1991 Advanced Micro Devices, Inc.
 *
 * This software is the property of Advanced Micro Devices, Inc  (AMD)  which
 * specifically  grants the user the right to modify, use and distribute this
 * software provided this notice is not removed or altered.  All other rights
 * are reserved by AMD.
 *
 * AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
 * SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
 * DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
 * USE OF THIS SOFTWARE.
 *
 * So that all may benefit from your experience, please report  any  problems
 * or  suggestions about this software to the 29K Technical Support Center at
 * 800-29-29-AMD (800-292-9263) in the USA, or 0800-89-1131  in  the  UK,  or
 * 0031-11-1129 in Japan, toll free.  The direct dial number is 512-462-4118.
 *
 * Advanced Micro Devices, Inc.
 * 29K Support Products
 * Mail Stop 573
 * 5900 E. Ben White Blvd.
 * Austin, TX 78741
 * 800-292-9263
 *****************************************************************************
 *      Engineer: Srini Subramanian.
 *****************************************************************************
 * This is the main module of MONDFE.
 *****************************************************************************
 */

#include <stdio.h>
#include  <signal.h>
#ifdef	MSDOS
#include <stdlib.h>
#include <string.h>
#else
#include <strings.h>
#endif
#include "coff.h"
#include "main.h"
#include  "monitor.h"
#include "memspcs.h"
#include "miniint.h"
#include "error.h"
#include "versions.h"

#ifdef MSDOS
#define	strcasecmp	stricmp
#endif

/* Externals */
extern	void	Def_CtrlC_Hdlr PARAMS((int));
extern	void	Mini_parse_args PARAMS((int argc, char  **argv));
extern	INT32	Mini_initialize PARAMS((HOST_CONFIG *host, IO_CONFIG *io,
					INIT_INFO *init));
extern	INT32	Mini_io_setup PARAMS((void));
extern	INT32	Mini_io_reset PARAMS((void));
extern	INT32	Mini_load_file PARAMS((char *fname, INT32 mspace, 
				       int  argc, char  *args, 
				       INT32 symbols, INT32 sections, int msg));
extern	void	Mini_monitor PARAMS((void));
extern	INT32	Mini_go_forever PARAMS((void));

/* Globals */

GLOBAL	char  *host_version = HOST_VERSION;
GLOBAL	char  *host_date = HOST_DATE;

GLOBAL 	TARGET_CONFIG 	target_config;
GLOBAL 	VERSIONS_ETC 	versions_etc;
GLOBAL 	TARGET_STATUS 	target_status;
GLOBAL 	HOST_CONFIG 	host_config;
GLOBAL 	IO_CONFIG    	io_config;

/* The filenos of the monitor's stdin, stdout, adn stderr */
int	MON_STDIN;
int	MON_STDOUT;
int	MON_STDERR;

int	Session_ids[MAX_SESSIONS];
int	NumberOfConnections=0;
/* The following variables are to be set/initialized in Mini_parse_args()
 */
GLOBAL	BOOLEAN	monitor_enable = FALSE;
GLOBAL	int	QuietMode = 0;
GLOBAL	BOOLEAN	ROM_flag = FALSE;

GLOBAL 	char  	*ROM_file = NULL;
GLOBAL	char	**ROM_argv;
GLOBAL	int	ROM_sym, ROM_sects;
GLOBAL	int	ROM_argc;

GLOBAL	char	CoffFileName[1024];
static	char	Ex_argstring[1024];
GLOBAL	int	Ex_sym, Ex_sects, Ex_space;
GLOBAL	int	Ex_argc;
static	int	Ex_loaded=0;

GLOBAL	char	*ProgramName=NULL;

GLOBAL	char	*connect_string;

GLOBAL	INT32	udi_waittime;

/* Main routine */

main(argc, argv)
   int   argc;
   char *argv[];
   {

   char		*temp;
   int		i;
   UINT32	ProcessorState;
   int		GrossState;
   INT32	retval;

   ProgramName=argv[0];
   if (strpbrk( ProgramName, "/\\" ))
   {
	temp = ProgramName + strlen( ProgramName );
	while (!strchr( "/\\", *--temp ))
		;
	ProgramName = temp+1;
   }

   if (argc < 2 ) {
     fprintf(stderr, "MiniMON29K Release 3.0\n");
     fprintf(stderr, "MONDFE Debugger Front End (UDI 1.2) Version %s Date %s\n", HOST_VERSION, HOST_DATE);
     fatal_error(EMUSAGE);
   }

   /* Initialize stdin, stdout, sdterr to defaults */
   MON_STDIN = fileno(stdin);
   MON_STDOUT = fileno(stdout);
   MON_STDERR = fileno(stderr);
   NumberOfConnections = 0;
   (void) strcpy (CoffFileName,"");

   udi_waittime = (INT32) 10;	/* default poll every ? secs */
   /*
   ** Initialize host configuration structure (global), set defaults
   */
   if (Mini_initialize (&host_config, &io_config, &init_info) != SUCCESS)
      fatal_error(EMHINIT);

   /* Parse args */
   (void) Mini_parse_args(argc, argv);

   if (io_config.echo_mode == (INT32) TRUE) {
      for (i=0; i < argc; i++)
	 fprintf(io_config.echo_file, "%s ", argv[i]);
      fprintf(io_config.echo_file, "\n");
      fflush (io_config.echo_file);
   };

   if ((monitor_enable == FALSE) & !Ex_loaded)
     fatal_error (EMNOFILE);

   /*
   ** Initialize host I/O.
   */

   if (Mini_io_setup() != SUCCESS)
      fatal_error(EMIOSETF);

   /*
   * Initialize TIP. Load ROM file, if necessary.
   ** Open communication channel
   */
   if (signal (SIGINT, Def_CtrlC_Hdlr) == SIG_ERR) {
     fprintf(stderr, "Couldn't install default Ctrl-C handler.\n"); 
     if (io_config.echo_mode == (INT32) TRUE)
        fprintf(io_config.echo_file, "Couldn't install default Ctrl-C handler.\n"); 
   }
   /* connect_string is made by the Mini_parse_args routine */
   retval = Mini_TIP_init(connect_string, &Session_ids[NumberOfConnections]); 
   if (retval > (INT32) 0) {
       fatal_error(EMTIPINIT);
   } else if (retval == (INT32) SUCCESS) {
       NumberOfConnections=NumberOfConnections+1;
   } else {
   	Mini_TIP_exit();
        fatal_error(EMTIPINIT);
   }
   if (Mini_get_target_stats((INT32) -1, &ProcessorState) != SUCCESS) {/* reconnect?*/
         Mini_TIP_exit();
	 fatal_error(EMFATAL);
   };
   GrossState = (int) (ProcessorState & 0xFF);
   if (GrossState == NOTEXECUTING)
      if (Mini_TIP_CreateProc() != SUCCESS) {
         Mini_TIP_exit();
         fatal_error(EMNOPROCESS);
      }

   /* Get capabilities */
   if (Mini_TIP_Capabilities() != SUCCESS) {
      Mini_TIP_DestroyProc();
      Mini_TIP_exit();
      fatal_error(EMNOTCOMP);
   }

   /* Get the target memory configuration, and processor type */
   versions_etc.version = 0;	/* initialize in case not returned */
   if (Mini_config_req(&target_config, &versions_etc) != SUCCESS) {
      warning(EMCONFIG);
   }

   if (strcmp(CoffFileName,"") != 0) {
     if (Mini_load_file(&CoffFileName[0], 
			Ex_space,
			Ex_argc,
			Ex_argstring,
			Ex_sym,
			Ex_sects,
			QuietMode) != SUCCESS) {
	Ex_loaded = 0;
	warning(EMLOADF);
     } else {
        Ex_loaded = 1;
     };
   }

   if (monitor_enable == FALSE) {
      if (Ex_loaded)
         Mini_go_forever();
      else { /* nothing to do, so quit */
         Mini_TIP_DestroyProc();
         Mini_TIP_exit();
	 warning (EMNOFILE);
      }
   } else {
      Mini_monitor();
   };

   fflush(stderr);
   fflush(stdout);

   /* Perform host-specific clean-up */
   if (Mini_io_reset() != SUCCESS)
      warning(EMIORESETF);

   if (!QuietMode) {
      fprintf(stderr, "\nGoodbye.\n");
      if (io_config.echo_mode == (INT32) TRUE) {
          fprintf(io_config.echo_file, "\nGoodbye.\n");
          (void) fclose (io_config.echo_file);
      }
   }
   return(0);

   }   /* end Main */



/*
** Functions
*/

/*
** This function prints out a fatal error message 
** from error_msg[]. 
** Finally, the program exits with error_number.
*/
#ifndef	MINIMON
extern	UINT32	UDIGetDFEIPCId PARAMS((void));
#endif

void
fatal_error(error_number)
   INT32 error_number;
   {
   UINT32	IPCId;

   if (error_number == (INT32) EMUSAGE) {
#ifndef	MINIMON
     IPCId = (UINT32) UDIGetDFEIPCId();
     fprintf(stderr, "MONDFE UDI IPC Implementation Id %d.%d.%d\n",
				(int) ((IPCId & 0xf00) >> 8),
				(int) ((IPCId & 0xf0) >> 4),
				(int) (IPCId & 0xf));
     if (io_config.echo_mode == (INT32) TRUE)
       fprintf(io_config.echo_file, "MONDFE UDI IPC Implementation Id %d.%d.%d\n",
				(int) ((IPCId & 0xf00) >> 8),
				(int) ((IPCId & 0xf0) >> 4),
				(int) (IPCId & 0xf));
#else
     fprintf(stderr, "Procedurally linked MiniMON29K 3.0 Delta\n");
#endif
       fprintf(stderr, "Usage: %s %s\nGoodbye.\n", 
				  ProgramName, error_msg[(int)error_number]);
       if (io_config.echo_mode == (INT32) TRUE)
          fprintf(io_config.echo_file, "Usage: %s %s\nGoodbye.\n", 
				  ProgramName, error_msg[(int)error_number]);
   } else {
     fprintf(stderr, "DFEERROR: %d : %s\nFatal error. Exiting.\n", 
			(int)error_number, error_msg[(int)error_number]);
     if (io_config.echo_mode == (INT32) TRUE)
        fprintf(io_config.echo_file, "DFEERROR: %d : %s\nFatal error. Exiting.\n", 
			(int)error_number, error_msg[(int)error_number]);
   }

   NumberOfConnections=0;
   if (io_config.echo_mode == (INT32) TRUE)
     (void) fclose(io_config.echo_file);

   exit((int) error_number);
   }


/*
** This function prints out a warning message from
** the error_msg[] string array.
*/

void
warning(error_number)
   INT32 error_number;
   {
   fprintf(stderr, "DFEWARNING: %d : %s\n", (int) error_number, error_msg[(int)error_number]);
   if (io_config.echo_mode == (INT32) TRUE)
      fprintf(io_config.echo_file, "DFEWARNING: %d : %s\n", error_number, error_msg[(int)error_number]);
   }


/* Parse the command line arguments */
void
Mini_parse_args(argc, argv)
int	argc;
char	**argv;
{
   int		i, j;
   int		len;

   len = 0;
   for (i = 1; i < argc; i++)  {	/* ISS */
      len = len + (int) strlen(argv[i]);
   };
   if (len == (int) 0) {
     connect_string = NULL;
   } else {
     if ((connect_string = (char *) malloc (len + argc)) == NULL) {
	fatal_error(EMALLOC);
     };
     for (i = 1; i < argc; i++)  {	/* ISS */
      if (strcasecmp(argv[i], "-TIP") == 0) {
	  i++;
          if (i >= argc)
            fatal_error(EMUSAGE);
	  connect_string = argv[i];
      } else if (strcmp(argv[i], "-log") == 0) {
	i++;
	if (i >= argc)
	  fatal_error(EMUSAGE);
	(void) strcpy((char *)(&(io_config.log_filename[0])),argv[i]);
	io_config.log_mode = (INT32) TRUE;
      } else if (strcmp (argv[i], "-w") == 0) { /* Wait time param */
	i++;
	if (i >= argc)
	  fatal_error(EMUSAGE);
	if (sscanf(argv[i], "%ld", &udi_waittime) != 1)
	  fatal_error(EMUSAGE);
      } else if (strcmp (argv[i], "-ms") == 0) { /* mem stack size */
	i++;
	if (i >= argc)
	  fatal_error(EMUSAGE);
	if (sscanf(argv[i], "%lx", &init_info.mem_stack_size) != 1)
	  fatal_error(EMUSAGE);
      } else if (strcmp (argv[i], "-rs") == 0) { /* reg stack size */
	i++;
	if (i >= argc)
	  fatal_error(EMUSAGE);
	if (sscanf(argv[i], "%lx", &init_info.reg_stack_size) != 1)
	  fatal_error(EMUSAGE);
      } else if (strcmp(argv[i], "-d") == 0) {	
         monitor_enable = TRUE;	
      } else if (strcasecmp(argv[i], "-D") == 0) {	
         monitor_enable = TRUE;	
      } else if (strcmp(argv[i], "-le") == 0) {	
         host_config.target_endian = LITTLE;	
      } else if (strcmp(argv[i], "-q") == 0) {	
         QuietMode = 1;	
      } else if (strcmp(argv[i], "-c") == 0) {
         i++;
         if (i >= argc)
            fatal_error(EMUSAGE);
         (void) strcpy((char *)(&(io_config.cmd_filename[0])),argv[i]);
         io_config.cmd_file_io = TRUE;
      } else if (strcmp(argv[i], "-e") == 0) {
         i++;
         if (i >= argc)
            fatal_error(EMUSAGE);
         (void) strcpy((char *)(&(io_config.echo_filename[0])),argv[i]);
	 io_config.echo_mode = (INT32) TRUE;
	 if ((io_config.echo_file = fopen (io_config.echo_filename, "w")) == NULL) {
	    warning (EMECHOPEN);
	    io_config.echo_mode = (INT32) FALSE;
	 }
      } else { 
	 (void) strcpy (&CoffFileName[0], argv[i]);
	 Ex_argc = argc - i;
	 (void) strcpy(Ex_argstring, argv[i]);
	 for (j=1; j < Ex_argc; j++) {
	   (void) strcat(Ex_argstring, " ");
	   (void) strcat (Ex_argstring, argv[i+j]);
	 }
	 Ex_sym = 0;
	 Ex_sects = (STYP_ABS|STYP_TEXT|STYP_LIT|STYP_DATA|STYP_BSS);
	 Ex_space = (INT32) I_MEM;
	 Ex_loaded = 1;  /* given */
	 break;
       }  
     }; /* end for */
   }; /* end if-else */
}

/* Function to initialize host_config and io_config data structures
 * to their default values *
 */

INT32
Mini_initialize(host, io, init)
HOST_CONFIG	*host;
IO_CONFIG	*io;
INIT_INFO	*init;
{
   /* Initialize host configuration information */

#ifdef	MSDOS
   host->host_endian = LITTLE;
#else
   host->host_endian = BIG;
#endif

   host->target_endian = BIG;  /* default */
   host->version = host_version;
   host->date = host_date;

   /* Initialize I/O configuration information */

   io->hif = TRUE;
   io->io_control = TERM_USER;
   io->cmd_ready = FALSE;
   io->clear_to_send = TRUE;
   io->target_running = FALSE;
   io->cmd_file = NULL;
   io->cmd_filename[0] = '\0';
   io->cmd_file_io = FALSE;
   io->log_mode = FALSE;
   io->log_file = NULL;
   io->log_filename[0] = '\0';
   io->echo_mode = FALSE;
   io->echo_file = NULL;
   io->echo_filename[0] = '\0';
   io->io_toggle_char = (BYTE) 21;  /* CTRL-U */

   init->mem_stack_size = (UINT32) -1;
   init->reg_stack_size = (UINT32) -1;
   return(SUCCESS);
}

void
Def_CtrlC_Hdlr(num)
int	num;
{
  Mini_io_reset();
   if (!QuietMode) {
      fprintf(stderr, "\nInterrupted.\n");
      if (io_config.echo_mode == (INT32) TRUE) {
          fprintf(io_config.echo_file, "\nInterrupted.\n");
          (void) fclose (io_config.echo_file);
      }
   }
   Mini_TIP_SetCurrSession(0);
   Mini_TIP_exit();
  exit(1);
}