#include <stdlib.h>
#include <limits.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <getopt.h>
#include <signal.h>
#include <string.h>
#include <unistd.h>
#include <fcntl.h>
#include <wait.h>

#include "makerom.h"

// Function prototypes for Internal functions
//
static void usage(void);
static void doWave(Wave *);
static void nameTempFiles(void);
static void unlinkTempFiles(void);
static void wavePrint(void);
static void cleanup(int);
static void getOsVersion(void);
static int checkIdoVersion(char*);
static void printVersion(void);
static void getBootFile(char * bootFileName);
static void getPif2BootFile(char *pif2bootFileName);
static void getRomheaderFile(char *headerFileName);
static void getFontDataFile(char *fontFileName);
static char *gloadFindFile(char *fullpath, char *postRootSuffix, char *fname);

// Internal variables
//
static const struct sigaction act = {0, cleanup, 0};
static char segmentSymbolSource[_POSIX_PATH_MAX];
static char segmentSymbolObject[_POSIX_PATH_MAX];
static char entrySource[_POSIX_PATH_MAX];
static char entryObject[_POSIX_PATH_MAX];
static char objectListFile[_POSIX_PATH_MAX];
static char *romFile = "rom";
static int  checkOverlap = 1;
static char *progName;

// Global variables
//
unsigned char	*bootBuf, *headerBuf, *pif2bootBuf, *fontBuf;
int		bootWordAlignedByteSize;
int		pif2bootWordAlignedByteSize;
int		headerWordAlignedByteSize;
int		fontdataWordAlignedByteSize;
Segment		*segmentList = (Segment *)NULL;
Wave		*waveList = (Wave *)NULL;
char		*fileName;
char		*bootEntryName;
char		*bootStackName;
unsigned int	bootStackOffset;
int 	 	debug = 0;
int 	 	cosim = 0;
int		emulator = 0;
int		loadMap;
int		nofont = 0;
int		gcord;
int  		finalromSize = 0;
char 		fillData = 0xff;
int		offset = 0;
int 	 	keep_going = 0;	/* if TRUE, ignore failures of children */
int		irixVersion;
int		booter = 0; /* if TRUE, generate booter game */

main(int argc, char *argv[]) {
  int c;
  FILE *f;
  Wave *wave;
  char *cppCmd;
  long cppCmdCount;
  int headerFd, pif2bootFd;
  char *bootFileName = NULL;
  char *headerFileName = NULL;
  char *pif2bootFileName = NULL;
  char *fontFileName = NULL;
  int createRom = 1;
  char CheckerBuf[NAME_MAX];
  char NameBuf[NAME_MAX];
  char *rootName;
  int quietMode = 0;
  
  progName = argv[0];
  if ((cppCmdCount = sysconf(_SC_ARG_MAX)) == -1) {
    fprintf(stderr, "makerom: sysconf(_SC_ARG_MAX): %s\n",
	    sys_errlist[errno]);
    exit(1);
  }
  if ((cppCmd = malloc(cppCmdCount)) == NULL) {
    fprintf(stderr, "malloc failed\n");
    return(-1);
  }
#ifdef __sgi__
  sprintf(cppCmd, "/usr/lib/cpp -D_LANGUAGE_MAKEROM");
#else
  sprintf(cppCmd, "/lib/cpp -D_LANGUAGE_MAKEROM");
#endif
  cppCmdCount -= (strlen(cppCmd) + 1);
  
  // Parse options
  //
  while ((c = getopt(argc, argv, "D:I:U:cdeimnor:gb:h:p:s:f:O:QqVvB:")) != EOF) {
    switch (c) {
    case 'D':
    case 'I':
    case 'U':
      cppCmdCount -= 3+strlen(optarg);
      if (cppCmdCount <= 0) {
	fprintf(stderr,
		"makerom: too many -[DIU] flags\n");
	exit(1);
      }
      sprintf(cppCmd, "%s -%c%s", cppCmd, c, optarg);
      break;
    case 'c':
      cosim = 1;
      break;
    case 'd':   // Print debug messages
      debug = 1;
      break;
    case 'g':
      gcord = 1;
      break;
    case 'k':	// if TRUE, ignore failures of children 
      keep_going = 1;
      break;
    case 'e':   // Used if we're on the software emulator
      emulator = 1;
      break;
    case 'm':   // Print symbol map
      loadMap = 1; 
      break;
    case 'n':   // Turn off use of font file
      nofont = 1;
      break;
    case 'o':   // Turn off overlap checking
      checkOverlap = 0;
      break;
    case 'r':   // Name rom file
      romFile = optarg;
      break;
    case 'b':   // Name boot file
      bootFileName = optarg;
      break;
    case 'h':   // Name romheader file
      headerFileName = optarg;
      break;
    case 'p':   // Name pif2 boot file
      pif2bootFileName = (char *)optarg;
      break;
    case 's':   // Give explicit rom file size
      finalromSize = strtol(optarg, (char **)NULL, 0);
      break;
    case 'f':   // Give data byte to fill extra rom space with
      fillData = strtol(optarg, (char **)NULL, 0);
      break;
    case 'O':
      offset = strtol(optarg, (char **)NULL, 0);
      break;
    case 'B':
      {
	  int		bootType;
	  
	  bootType = strtol(optarg, (char **)NULL, 0);
	  if (bootType == 0)
	      booter = 1;
	  else if (bootType == 1)
	  {
	      fprintf(stderr, "\"Bootee\" game should be a disk game\n");
	      exit(1);
	  }
	  else
	  {
	      fprintf(stderr, "makerom: invalid argument for -B option (-B 0)\n");
	      exit(1);
	  }
      }
      break;
    case '?':
      usage();
      exit(1);
    case 'Q':
    case 'q':   // Don't print messages
      quietMode = 1;
      break;
    case 'V':   // Print version number
    case 'v':
      printVersion();
      exit (1);
    }
  }

  // Print usage message if incorrect number of parameters
  if ((argc - optind) != 1) {
    usage();
    exit(1);
  }
  
  if ((cosim + emulator) > 1) {
    fprintf(stderr, "makerom: only specify one of -c, -e, or -i\n");
    exit(1);
  }
  
  getOsVersion();
  
  // Print the version number if not in quiet mode.
  if (!quietMode) {
    printVersion();
  }
  
  // Load some necessary files.
  getBootFile(bootFileName);
  getPif2BootFile(pif2bootFileName);
  getRomheaderFile(headerFileName);
  getFontDataFile(fontFileName);
  
  // Make sure rom file doesn't already exist.
  if ((unlink(romFile) == -1) && (errno != ENOENT)) {
    fprintf(stderr, "makerom: %s: %s\n",
	    romFile, sys_errlist[errno]);
    exit(1);
  }

  // Setup for spec file parse
  fileName = argv[optind];
  if ((yyin = fopen(fileName, "r")) == NULL) {
    fprintf(stderr, "makerom: %s: %s\n",
	    fileName, sys_errlist[errno]);
    exit(1);
  }
  fclose(yyin);

  // Call "CPP" on the spec file, by making the parser input be the
  //   output from the cpp command.
  cppCmdCount -= strlen(fileName);
  if (cppCmdCount <= 0) {
    fprintf(stderr,
	    "makerom: cpp command line too long\n");
    exit(1);
  }
  sprintf(cppCmd, "%s %s", cppCmd, fileName);
  if ((yyin = popen(cppCmd, "r")) == NULL) {
    fprintf(stderr, "makerom: could not run cpp on %s: %s\n",
	    fileName, sys_errlist[errno]);
    exit(1);
  }
  
  // Build waves from spec file
  if (yyparse())
    exit(1);
  
  // Wait for and check error return of cpp
  if (pclose(yyin) != 0)
    exit(1);
  
  //////////////////////////////////
  // SPEC file is done being parsed
  //////////////////////////////////

  // Check for unreferenced segments and get segment sizes
  if (scanSegments() == -1)
    exit(1);
  
  // Check that segment sizes are within various limits
  if (checkSizes())
    createRom = 0;
  
  // If desired, check for overlapping direct mapped CPU segments
  if (checkOverlap && checkOverlaps())
    createRom = 0;
  
  // Create temp file names
  nameTempFiles();
  
  // Hook signals for cleanup on abnormal termination
  sigaction(SIGHUP, &act, NULL);
  sigaction(SIGINT, &act, NULL);
  sigaction(SIGTERM, &act, NULL);
  
  // Create file of segment start/end symbols
  if (debug)
    printf("Creating segment symbol source file in %s\n",
	   segmentSymbolSource);
  
  if (createSegmentSymbols(segmentSymbolSource,
			   segmentSymbolObject) == -1) {
    unlinkTempFiles();
    exit(1);
  }
  
  // For each wave, call the 'doWave' routine, which creates an 
  //   elspec file and runs the linker to generate an elf object file.
  //
  for (wave = waveList; wave != (Wave *)NULL; wave = wave->next)
    doWave(wave);
  
  ///////////////////////////
  // Linking stage complete!
  ///////////////////////////

#ifdef DEBUG
  wavePrint();
#endif /* DEBUG */

  if ((rootName = getenv("ROOT")) == NULL) {
    rootName = "/";
  }

#ifdef __sgi__
  // check multiply instruction pair
  if (irixVersion >= OS_VERSION_62) {
    // Check to make sure we're not running an old IDO on a new IRIX.
    if (checkIdoVersion(rootName) < IDO_VERSION_71) {
      fprintf(stderr, "makerom: This IDO version is not compatible with the\n");
      fprintf(stderr, "         Nintendo64 development environment on this\n");
      fprintf(stderr, "         version of IRIX.\n");
      exit (1);
    }
    sprintf(CheckerBuf, 
	    "%s/usr/sbin/u64check -fmulmul:check:noforce:norepair", 
	    rootName);
  } else {
    // This should be IRIX 5.3, IDO 5.3.
    sprintf(CheckerBuf, "%s/usr/sbin/r4300_check", rootName);
  }
  if (debug) {
    printf("Checking fmulmul status\n");
  }
  for (wave = waveList; wave != (Wave *)NULL; wave = wave->next) {
    sprintf(NameBuf,"%s %s",CheckerBuf,wave->name);
    if (debug)
      printf("  %s\n", NameBuf);
    if (execCommand(NameBuf) == -1 && !keep_going) {
      unlinkTempFiles();
      exit(1);
    }
  }
#endif

  if ( gcord ) {
    char gcordFileBuf[NAME_MAX];
    
    sprintf(CheckerBuf, "%s/usr/lib/PR/gcord ", rootName);
    
    for (wave = waveList; wave != (Wave *)NULL; wave = wave->next) {
      sprintf(NameBuf,"%s %s",CheckerBuf,wave->name);
      if (debug)
	printf("makerom: %s\n", NameBuf);
      if (execCommand(NameBuf) == -1 && !keep_going) {
	unlinkTempFiles();
	exit(1);
      }
      strcat(strcpy( gcordFileBuf, wave->name), ".cord" );
      strcpy(wave->name , gcordFileBuf);
    }
    
  }
  
  if (debug)
    printf("Creating entry source file in %s\n", entrySource);
  
  if (createEntryFile(entrySource, entryObject) == -1) {
    unlinkTempFiles();
    exit(1);
  }
  
  // If no size violation or overlap occurred, create the rom image
  if (createRom) {
    if (debug) {
      printf("Extracting sections from ELF wave files");
      printf(" to create ROM image in %s\n", romFile);
    }
    
    if (createRomImage(romFile, entryObject) == -1) {
      unlinkTempFiles();
      exit(1);
    }
    
  }
  
  // Remove all created temp files
  unlinkTempFiles();
  
  // Clean up memory buffers.
  if (bootBuf)
    free(bootBuf);
  if (headerBuf)
    free(headerBuf);
  if (fontBuf)
    free(fontBuf);
  
  exit(createRom ? 0 : 1);
}


////////////////////////////////////////////////////////////////////////////////
// usage()
//
// Print a usage message describing appropriate options.
//
static void usage(void) {
  fprintf(stderr, "usage: makerom [-D<define>] [-I<dir>] -[U<define>]\n");
  fprintf(stderr, "               [-c] [-n] [-d] [-g] [-e] [-m] [-q] [-v]\n");
  fprintf(stderr, "               [-o] [-b bootfile] [-h headerfile]\n");
  fprintf(stderr, "               [-p pif2bootfile]\n");
  fprintf(stderr, "               [-s romsize (Mbits)]\n");
  fprintf(stderr, "               [-f filldata (0x00 - 0xff)]\n");
  fprintf(stderr, "               [-B 0]\n");
  fprintf(stderr, "               [-r romfile] specfile\n");
}


////////////////////////////////////////////////////////////////////////////////
// getOsVersion()
//
// Determine the IRIX version by running the 'uname' command and parsing
//   its output.  Store the version number in the variable 'irixVersion'.
//
static void getOsVersion(void) {
#ifdef __sgi__
  char* cmd = "/sbin/uname -r";
#else
  char* cmd = "/bin/uname -r";
#endif
  char  buf[BUFSIZ];
  FILE* procPtr;
  
  if ((procPtr = popen(cmd, "r")) != NULL) {
    fgets(buf, BUFSIZ, procPtr);
    pclose(procPtr);
    if (!strcmp(buf, "5.3\n")) {
      irixVersion = OS_VERSION_53;
    } else if (!strcmp(buf, "6.2\n")) {
      irixVersion = OS_VERSION_62;
    } else if (!strcmp(buf, "6.3\n")) {
      irixVersion = OS_VERSION_63;
    } else if (!strcmp(buf, "6.4\n")) {
      irixVersion = OS_VERSION_64;
    } else {
      irixVersion = OS_VERSION_OTHER;
      fprintf(stderr, "makerom: Operating system not recognized.  Trying 6.x ...\n");
    }
  } else {
    fprintf(stderr, "makerom: Unable to find uname command!\n");
    exit(1);
  }
}

////////////////////////////////////////////////////////////////////////////////
// checkIdoVersion()
//
// IDO 7.x has u64check.  But we can only use IDO 7.1.
// This function checks to make sure that the IDO version is okay.
//
static int checkIdoVersion(char* rootName) {
#ifndef __sgi__
  return IDO_VERSION_71;
#else
  int u64CheckFound;
  int v70Found;
  char cmd[NAME_MAX];
  char buffer[NAME_MAX];
  struct stat statBuffer;
  FILE* procPtr;

  /* Check for existence of u64check.
   */
  sprintf(buffer, "%s/usr/sbin/u64check", rootName);
  if (stat(buffer, &statBuffer) != 0) {
    /* Not found. */
    u64CheckFound = 0;
  } else {
    u64CheckFound = 1;
  }
  
  /* Make sure we're not on IDO 7.0.
   */
  sprintf(cmd, "/usr/sbin/showprods -D 1 dev");
  if ((procPtr = popen(cmd, "r")) != NULL) {
    fgets(buffer, NAME_MAX, procPtr);
    fgets(buffer, NAME_MAX, procPtr);
    fgets(buffer, NAME_MAX, procPtr);
    fgets(buffer, NAME_MAX, procPtr);
    pclose(procPtr);
    if (strstr(buffer, "7.0")) {
      v70Found = 1;
    } else {
      v70Found = 0;
    }
  }

  if (v70Found) {
    fprintf(stderr, "makerom: IDO v7.0 does not work with the Nintendo64\n");
    fprintf(stderr, "         development environment.  Please upgrade to\n");
    fprintf(stderr, "         IDO v7.1.\n");
    exit (1);
  }
  if (u64CheckFound) {
    /* This should be 7.1 or later. */
    return IDO_VERSION_71;
  } else {
    /* This should be 5.3. */
    return IDO_VERSION_53;
  }
#endif
}


////////////////////////////////////////////////////////////////////////////////
// printVersion()
//
// Print out the version number of this executable.
//
static void printVersion(void) {

  if (irixVersion == OS_VERSION_53)
     printf("Nintendo64 Makerom v2.4 for IRIX.\n");
  else
     printf("Nintendo64 Makerom v2.4 -BETA- for IRIX.\n");

}


////////////////////////////////////////////////////////////////////////////////
// getBootFile()
//
// Get the contents of the file /usr/lib/PR/Boot, load it into bootBuf.
//
static void getBootFile(char *bootFileName) {
  int bootFd;
  char scratchFileName[NAME_MAX];
  struct stat buf;
  char errMessage[NAME_MAX];
  
  /*
   * Load the bootstrap file (provide a default if none was supplied)
   */
  if (!bootFileName) {
    if ( gloadFindFile(scratchFileName, "/usr/lib/PR", "Boot") ) {
      bootFileName = scratchFileName;
    }
  }
  
  if (bootFileName) {
    if ((bootFd = open(bootFileName, O_RDONLY | O_NOCTTY)) < 0) {
      sprintf(errMessage, "%s: unable to open %s", progName, bootFileName);
      perror(errMessage);
      exit(1);
    }
    /*
     * Load the bootstrap file.
     */
    if (fstat(bootFd, &buf) < 0) {
      sprintf(errMessage, "%s unable to stat %s", progName, bootFileName);
      perror(errMessage);
      close(bootFd);
      exit(1);
    }
    
    bootBuf = malloc(buf.st_size);
    if (bootBuf == NULL) {
      fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n",
	      progName, buf.st_size);
      close(bootFd);
      exit(1);
    }
    close(bootFd);
    bootWordAlignedByteSize = readCoff(bootFileName, (unsigned int *)bootBuf);
  } else {
    bootBuf = NULL;
  }
}


////////////////////////////////////////////////////////////////////////////////
// getPif2BootFile()
//
// Get the contents of the file /usr/lib/PR/pif2Boot, load it into pif2BootBuf.
//
static void getPif2BootFile(char *pif2bootFileName) {
  int pif2bootFd;
  char scratchFileName[NAME_MAX];
  struct stat buf;
  char errMessage[NAME_MAX];
  
  /*
   * Load the pif2bootstrap file (provide a default if none was supplied)
   */
  if (!pif2bootFileName) {
    if ( gloadFindFile(scratchFileName, "/usr/lib/PR", "pif2Boot") ) {
      pif2bootFileName = scratchFileName;
    }
  }
  
  if (pif2bootFileName) {
    if ((pif2bootFd = open(pif2bootFileName, O_RDONLY | O_NOCTTY)) < 0) {
      sprintf(errMessage, "%s: unable to open %s", progName, pif2bootFileName);
      perror(errMessage);
      exit(1);
    }
    /*
     * Load the pif2bootstrap file.
     */
    if (fstat(pif2bootFd, &buf) < 0) {
      sprintf(errMessage, "%s unable to stat %s", progName, pif2bootFileName);
      perror(errMessage);
      close(pif2bootFd);
      exit(1);
    }
    
    pif2bootBuf = malloc(buf.st_size);
    if (pif2bootBuf == NULL) {
      fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n", 
	      progName, buf.st_size);
      close(pif2bootFd);
      exit(1);
    }
    close(pif2bootFd);
    pif2bootWordAlignedByteSize = readCoff(pif2bootFileName, (unsigned int *)pif2bootBuf);
  } else {
    pif2bootBuf = NULL;
  }
}


////////////////////////////////////////////////////////////////////////////////
// getRomheaderFile()
//
// Get the contents of the file /usr/lib/PR/romheader, load it into headerBuf.
//
static void getRomheaderFile(char *headerFileName) {
  int headerFd;
  char scratchFileName[NAME_MAX];
  struct stat buf;
  char errMessage[NAME_MAX];
  char nibbleString[2];
  int nibbleVal;
  int i, readPtr, retval;
  
  /*
   * Load the romheader file (provide a default, if none was supplied).
   * It's in ascii format, so we convert each character to hexadecimal and
   * prepare words of data to be loaded into memory.
   */
  if (!headerFileName) {
    if ( gloadFindFile(scratchFileName, "/usr/lib/PR", "romheader") ) {
      headerFileName = scratchFileName;
    }
  }
  if (headerFileName) {
    
    if ((headerFd = open(headerFileName, O_RDONLY | O_NOCTTY)) < 0) {
      sprintf(errMessage, "%s unable to open %s", progName, headerFileName);
      perror(errMessage);
      exit(1);
    }
    /*
     * Load the romheader file
     */
    if (fstat(headerFd, &buf) < 0) {
      sprintf(errMessage, "%s unable to stat %s", progName, headerFileName);
      perror(errMessage);
      close(headerFd);
      exit(1);
    }
    headerWordAlignedByteSize = buf.st_size;
    
    /*
     * Since each byte corresponds to an ascii character describing a 
     * nibble, this is twice as big as we need, but we'll need it larger
     * in case we need to word align ourselves.
     */
    headerBuf = malloc(headerWordAlignedByteSize);
    if (headerBuf == NULL) {
      fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n", 
	      progName, headerWordAlignedByteSize);
      close(headerFd);
      exit(1);
    }
    nibbleString[1] = '\0';
    for (i = 0, readPtr = 0; readPtr < headerWordAlignedByteSize; i++, readPtr++) {
      retval = read(headerFd, ( (void *)(&(nibbleString[0])) ), 1);
      if (retval != 1) {
	fprintf(stderr, "%s: short read from %s.\n",
		progName, headerFileName);
	free(headerBuf);
	close(headerFd);
	exit(1);
      }
      /*
       * Eat line feeds at end of line.
       */
      if ( (nibbleString[0] == '\n') && 
	   (++readPtr < headerWordAlignedByteSize) ) {
	retval = read(headerFd, ( (void *)(&(nibbleString[0])) ), 1);
	if (retval != 1) {
	  fprintf(stderr, "%s: short read from %s.\n",
		  progName, headerFileName);
	  free(headerBuf);
	  close(headerFd);
	  exit(1);
	}
      }
      
      /*
       * Do a hex to int conversion on each nibble as they come in.
       */
      nibbleVal = strtol(nibbleString, NULL, 16);
      
      if (i % 2) {
	headerBuf[ (i >> 1) ] |= nibbleVal;
      } else {
	headerBuf[ (i >> 1) ] = (nibbleVal << 4);
      }
#ifdef DEBUG
      printf("headerBuf[%d] now = 0x%x, char read was 0x%x\n", 
	     (i >> 1), headerBuf[ (i >> 1) ], nibbleString[0]);
#endif
    }

    /*
     * Write the contents of the ramromheader file into the beginning of 
     * ramrom.  Divide number of nibbles read by 2 to get number of bytes.
     */
    headerWordAlignedByteSize = ((i - 1) >> 1);
    
    /* 
     * We must transfer an integral number of words.  Doesn't hurt to 
     * transfer a couple of extra bytes of crap.
     */
    
    if (headerWordAlignedByteSize & 3){
      headerWordAlignedByteSize += 4;
      headerWordAlignedByteSize &= ~(3);
    }
    close(headerFd);
  } else {
    headerBuf = NULL;
  }
}


////////////////////////////////////////////////////////////////////////////////
// getFontDataFile() 
//
// Get the contents of the file /usr/lib/PR/font, load it into fontBuf.
//
static void getFontDataFile(char *fontFileName) {
  int fontFd;
  char scratchFileName[NAME_MAX];
  struct stat buf;
  char errMessage[NAME_MAX];
  
  /*
   * Load the fontdata file 
   */
  if ( gloadFindFile(scratchFileName, "/usr/lib/PR", "font") ) {
    fontFileName = scratchFileName;
  }
  
  if (fontFileName) {
    if ((fontFd = open(fontFileName, O_RDONLY | O_NOCTTY)) < 0) {
      sprintf(errMessage, "%s: unable to open %s", progName, fontFileName);
      perror(errMessage);
      exit(1);
    }
    /*
     * Load the fontdata file.
     */
    if (fstat(fontFd, &buf) < 0) {
      sprintf(errMessage, "%s unable to stat %s", progName, fontFileName);
      perror(errMessage);
      close(fontFd);
      exit(1);
    }
    
    fontBuf = malloc(buf.st_size);
    if (fontBuf == NULL) {
      fprintf(stderr, "%s: unable to malloc buffer to hold %d bytes\n",
	      progName, buf.st_size);
      close(fontFd);
      exit(1);
    }
    fontdataWordAlignedByteSize = buf.st_size;
    if (read(fontFd, fontBuf, fontdataWordAlignedByteSize) !=
	fontdataWordAlignedByteSize) {
      sprintf(errMessage, "%s unable to read %s", progName, fontFileName);
      perror(errMessage);
      close(fontFd);
      exit(1);
    }
    close(fontFd);
  } else {
    fontBuf = NULL;
  }
}


////////////////////////////////////////////////////////////////////////////////
// gloadFindFile()
//
// Find the filename 'fname', using the suggested directory 'postRootSuffix'.
// Use ROOT, WORKAREA, and then NULL as prefixes to find the file.
// If found, return the filename in 'fullpath', else return NULL.
//
static char *gloadFindFile(char *fullpath, char *postRootSuffix, char *fname) {
  char *rootname, *rootpath;
  int try;
  
  for (try = 0; try <= 2; try++) {
    fullpath[0] = '\0';
    
    switch (try) {
    case 0: rootname = "ROOT"; break;
    case 1: rootname = "WORKAREA"; break;
    case 2: rootname = NULL; break;
    }
    if (rootname != NULL) {
      if ((rootpath = (char *)getenv(rootname)) == NULL)
	continue;
      strcat(fullpath, rootpath);
    }
    
    if (postRootSuffix) {
      strcat(fullpath, postRootSuffix);
      strcat(fullpath, "/");
    }
    
    strcat(fullpath, fname);
    
    if (!access(fullpath, R_OK))
      return(fullpath);
  }
  
  fprintf(stderr, "gloadFindFile: can't find file %s\n", fullpath);
  fullpath[0] = '\0';
  return(NULL);
}


////////////////////////////////////////////////////////////////////////////////
// doWave()
//
//
//
static void doWave(Wave *wave) {
  
  /* Create linker spec file from wave information */
  
  if (debug) {
    printf("Translating ROM spec file into");
    printf(" linker spec file in %s\n", wave->elspecFile);
  }
  
  if (createElspec(wave) == -1) {
    unlinkTempFiles();
    exit(1);
  }

  // Execute linker to create a.out
  //
  if (runLinker(wave, segmentSymbolObject, objectListFile) == -1 && 
      !keep_going) {
    unlinkTempFiles();
    exit(1);
  }
}


////////////////////////////////////////////////////////////////////////////////
// wavePrint()
//
//
//
#ifdef DEBUG
static void wavePrint(void) {
  Wave *w;
  Segment *s;
  SegmentChain *sc;
  Path *p;
  
  printf("segments:\n");
  for (s = segmentList; s != NULL; s = s->next) {
    printf("name = %s address = 0x%x text 0x%x data 0x%x romOffset 0x%x\n",
	   s->name, s->address/*+s->adjust_address*/, s->textSize, s->dataSize, s->romOffset);
    for (p = s->pathList; p != NULL; p = p->next) {
      printf("\t%s\n", p->name);
    }
  }
  printf("waves:\n");
  for (w = waveList; w != NULL; w = w->next) {
    printf("name = %s\n", w->name);
    printf("segments:\n");
    for (sc = w->segmentChain; sc != NULL; sc = sc->next) {
      printf("\t%s\n", sc->segment->name);
    }
  }
}
#endif


////////////////////////////////////////////////////////////////////////////////
// nameTempFiles()
//
// Create the names for temporary files used by this app.
//   - elspec files
//   - segment symbols file
//   - entry point file
//   - object list file for linker
//
static void nameTempFiles(void) {
  Wave *wave;
  char *tmpdir;
  
  // Choose the temporary directory.
  // "/tmp", or TMPDIR if set.
  //
  if ((tmpdir = getenv("TMPDIR")) ==  NULL)
    tmpdir = "/tmp";
  
  // Create a temporary elspec file for each wave in the spec file.
  //
  for (wave = waveList; wave != (Wave *)NULL; wave = wave->next) {
    sprintf(wave->elspecFile,
	    "%s/%sElspecXXXXXX", tmpdir, wave->name);
    mktemp(wave->elspecFile);
  }
  
  // Create a temporary file for the segment symbols.
  //
  sprintf(segmentSymbolSource, "%s/segmentXXXXXX", tmpdir);
  mktemp(segmentSymbolSource);
  strcpy(segmentSymbolObject, segmentSymbolSource);
  strcat(segmentSymbolSource, ".s");
  strcat(segmentSymbolObject, ".o");

  // Create a temporary file for the entry point.
  //
  sprintf(entrySource, "%s/entryXXXXXX", tmpdir);
  mktemp(entrySource);
  strcpy(entryObject, entrySource);
  strcat(entrySource, ".s");
  strcat(entryObject, ".o");
  
  // Create a temporary file for the object list file, which will
  //   be passed to the linker on its command line.
  //
  sprintf(objectListFile, "%s/objListXXXXXX", tmpdir);
  mktemp(objectListFile);
}


////////////////////////////////////////////////////////////////////////////////
// unlinkTempFiles()
//
// Remove all of the temporary files which were created by this app.
//
static void unlinkTempFiles(void) {
  Wave *wave;
  
  if (!debug) {
    for (wave = waveList; wave != (Wave *)NULL; wave = wave->next) {
      unlink(wave->elspecFile);
    }
    unlink(segmentSymbolSource);
    unlink(segmentSymbolObject);
    unlink(entrySource);
    unlink(entryObject);
    unlink(objectListFile);
  }
}


////////////////////////////////////////////////////////////////////////////////
// cleanup()
//
// Callback routine which is called by the OS on SIGHUP, SIGINT, SIGTERM.
// Clean up the temp files, and exit.
//
static void cleanup(int sig) {
  unlinkTempFiles();
  exit(1);
}


////////////////////////////////////////////////////////////////////////////////
// execCommand()
//
// Execute a command by calling "system".  If it returns an error, print out
//   an error message.
//
int execCommand(char *s) {
  int status;
  
  status = system(s);
  
  if (status == -1) {
    fprintf(stderr, "makerom: cannot execute command: %s\n",
	    sys_errlist[errno]);
    return(-1);
  } else if (WIFEXITED(status) && (WEXITSTATUS(status) == 0)) {
    return(0);	/* sucess! */
  } else if (keep_going && 
	     (WIFEXITED(status) && (WEXITSTATUS(status) == 1))) {
    return(1);	/* warning! */
  } else {
    if (debug) {
      fprintf(stderr, "makerom: [%s] returned %d (%08x), errno=%d\n",
	      s, WEXITSTATUS(status), status, errno);
    }
    return(-1);	/* failure! */
  }
}