# 1 "gcc.c"
 




















 


























































































 







# 1 "/sprite/lib/include/stdio.h"
 






























typedef int *ClientData;



 

















































typedef struct _file {
    unsigned char *lastAccess;	 


    int readCount;		 


    int writeCount;		 





    unsigned char *buffer;	 

    int bufSize;		 


    void (*readProc)();		 
    void (*writeProc)();	 
    int (*closeProc)();		 

    ClientData clientData;	 


    int status;			 


    int flags;			 

    struct _file *nextPtr;	 




} FILE;

 


















 





















































 

























 







 



extern FILE stdioInFile, stdioOutFile, stdioErrFile;




 





 







 







 







extern void	clearerr();
extern int	fclose();
extern FILE *	fdopen();
extern int	fflush();
extern int	fgetc();
extern char *	fgets();
extern int	fileno();
extern FILE *	fopen();
extern int	fprintf();
extern int	fputc();
extern int	fputs();
extern int	fread();
extern FILE *	freopen();
extern int	fscanf();
extern long	fseek();
extern long	ftell();
extern int	fwrite();
extern char *	gets();
extern int	getw();
extern void	perror();







extern int	printf();

extern int	puts();
extern int	putw();
extern void	rewind();
extern int	scanf();
extern void	setbuf();
extern void	setbuffer();
extern void	setlinebuf();
extern int	setvbuf();
extern char *	sprintf();
extern int	sscanf();
extern FILE *	tmpfile();
extern char *	tmpnam();
extern char *	tempnam();
extern int	ungetc();
extern int	vfprintf();
extern int	vfscanf();
extern int	vprintf();
extern char *	vsprintf();
extern void	_cleanup();

extern void	Stdio_Setup();


# 121 "gcc.c"

# 1 "/sprite/lib/include/sys/types.h"
 









 



 


 


 


typedef	unsigned char	u_char;
typedef	unsigned short	u_short;
typedef	unsigned int	u_int;
typedef	unsigned long	u_long;
typedef	unsigned short	ushort;		 













typedef	struct	_quad { long val[2]; } quad;
typedef	long	daddr_t;
typedef	char *	caddr_t;
typedef	long *	qaddr_t;	 
typedef	u_long	ino_t;
typedef	long	swblk_t;


typedef	int	size_t;

typedef	long	time_t;
typedef	short	dev_t;
typedef	long	off_t;
typedef	short	uid_t;
typedef	short	gid_t;


 









typedef long	fd_mask;





typedef	struct fd_set {
	fd_mask	fds_bits[(((256 )+(( (sizeof(fd_mask) * 8		)	)-1))/( (sizeof(fd_mask) * 8		)	)) ];
} fd_set;







# 122 "gcc.c"

# 1 "/sprite/lib/include/signal.h"
 















































 








void	(*signal())();


 


struct	sigvec {
	void	(*sv_handler)();	 
	int	sv_mask;		 
	int	sv_flags;		 
};




 


struct	sigstack {
	char	*ss_sp;			 
	int	ss_onstack;		 
};

 






struct	sigcontext {
	int	sc_onstack;		 
	int	sc_mask;		 
	int	sc_sp;			 
	int	sc_fp;			 
	int	sc_ap;			 
	int	sc_pc;			 
	int	sc_ps;			 
};










 






# 123 "gcc.c"

# 1 "/sprite/lib/include/sys/file.h"
 










 

















 



 





 









 



 













 







 







 







# 124 "gcc.c"

# 1 "obstack.h"
 








































































































 


















































































 




 











struct _obstack_chunk		 
{
  char  *limit;			 
  struct _obstack_chunk *prev;	 
  char	contents[4];		 
};

struct obstack		 
{
  long	chunk_size;		 
  struct _obstack_chunk* chunk;	 
  char	*object_base;		 
  char	*next_free;		 
  char	*chunk_limit;		 
  int	temp;			 
  int   alignment_mask;		 
  struct _obstack_chunk *(*chunkfun) ();  
  void (*freefun) ();		 
};



 


void obstack_init (struct obstack *obstack);

void * obstack_alloc (struct obstack *obstack, int size);

void * obstack_copy (struct obstack *obstack, void *address, int size);
void * obstack_copy0 (struct obstack *obstack, void *address, int size);

void obstack_free (struct obstack *obstack, void *block);

void obstack_blank (struct obstack *obstack, int size);

void obstack_grow (struct obstack *obstack, void *data, int size);
void obstack_grow0 (struct obstack *obstack, void *data, int size);

void obstack_1grow (struct obstack *obstack, int data_char);

void * obstack_finish (struct obstack *obstack);

int obstack_object_size (struct obstack *obstack);

int obstack_room (struct obstack *obstack);
void obstack_1grow_fast (struct obstack *obstack, int data_char);
void obstack_blank_fast (struct obstack *obstack, int size);

void * obstack_base (struct obstack *obstack);
void * obstack_next_free (struct obstack *obstack);
int obstack_alignment_mask (struct obstack *obstack);
int obstack_chunk_size (struct obstack *obstack);



 


 





 



 



 















 





















# 325 "obstack.h"
































# 367 "obstack.h"








# 450 "obstack.h"




# 125 "gcc.c"

# 1 "alloca.h"
 







# 126 "gcc.c"











extern int xmalloc ();
extern void free ();

 




 

struct obstack obstack;

char *handle_braces ();
char *save_string ();
char *concat ();
int do_spec ();
int do_spec_1 ();
int give_string ();
char *find_file ();

 



# 1 "specs.h"
 





















 

struct compiler
{
  char *suffix;			 

  char *spec;			 

};

 





typedef struct
{
    char *name;				 


    struct compiler *base_specs;	 



    char *link_base_spec;		 

    char *cpp_predefines;		 
    char *compile_spec;			 
    char *asm_spec;			 
    char *link_spec;			 
    char *lib_spec;			 
    char *startfile_spec;		 
} target_specs;

 



struct compiler default_compilers[] =
{
    {".c",
     "cpp %{nostdinc} %{C} %{v} %{D*} %{U*} %{I*}         -I/sprite/lib/include.new/%m.md %{M*} %{T}         -undef -D__GNUC__ %{ansi:-T -$ -D__STRICT_ANSI__}	%{!ansi:%p -Dunix -Dsprite}        %{O:-D__OPTIMIZE__} %{traditional} %{pedantic}	%{Wcomment} %{Wtrigraphs} %{Wall}        %i %{!M*:%{!E:%g.cpp}}%{E:%{o*}}%{M*:%{o*}}\n     %{!M*:%{!E:%C %g.cpp %{!Q:-quiet} -dumpbase %i %{Y*} %{d*} %{m*} %{f*}	%{g} %{O} %{W*} %{w} %{pedantic} %{ansi} %{traditional}	%{v:-version} %{gg:-symout %g.sym} %{pg:-p} %{p}        %{S:%{o*}%{!o*:-o %b.s}}%{!S:-o %g.s}\n     %{!S:%a %{R} %{j} %{J} %{h} %{d2} %{gg:-G %g.sym}	%g.s %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\n }}}"},
# 78 "specs.h"
    {".s",
     "%{!S:%a %{R} %{j} %{J} %{h} %{d2}	%i %{c:%{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%b.o}\n }"},

     
    {0, 0}
};

char default_link_spec[] =
    "%{!c:%{!M*:%{!E:%{!S:%l %{o*}    %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}    %{y*} %{!nostdlib:%S} %{L*} -L/sprite/lib/%m.md     %o %{!nostdlib:%L}\n }}}}";





target_specs m68000_target =
{
    "sun2",					 
    default_compilers,				 
    default_link_spec,				 
    "-Dmc68000 -Dsun2 %{funsigned-char: -D__CHAR_UNSIGNED__}",
						 
    "cc1.68k -msoft-float -m68000",		 
    "as -m68010",				 
    "ld.new -X %{!e:-e start}",
						 
    "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}",	 
    ""						 
};

target_specs m68020_target =
{
    "sun3",					 
    default_compilers,				 
    default_link_spec,				 
    "-Dmc68000 -Dsun3 %{funsigned-char: -D__CHAR_UNSIGNED__}",
						 
    "cc1.68k -msoft-float -m68020",		 
    "as -m68020",				 
    "ld.new -X %{!e:-e start}",
						 
    "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}",	 
    ""						 
};

target_specs spur_target =
{
    "spur",					 
    default_compilers,				 
    default_link_spec,				 
    "-Dspur %{funsigned-char: -D__CHAR_UNSIGNED__}",
						 
    "cc1.spur -msoft-float",			 
    "sas",					 
    "sld -X -p %{!e:-e start}",			 
    "%{!p:%{!pg:-lc}}%{p:-lc_p}%{pg:-lc_p}",	 
    ""						 
};

 






typedef struct
{
    char *name;			 

    target_specs *info;		 
} target_machine;

target_machine target_machines[] = {
    {"sun3",	&m68020_target},	 
    {"68000",	&m68000_target},
    {"68010",	&m68000_target},
    {"sun2",	&m68000_target},
    {"68020",	&m68020_target},
    {"spur",	&spur_target},
    {0, 0}				 
};

char *target_name;			 
target_specs *target;			 


# 161 "gcc.c"


 


 






char *temp_filename;

 

int temp_filename_length;

 

struct temp_file
{
  char *name;
  struct temp_file *next;
  int success_only;		 

};

struct temp_file *temp_file_queue;

 



void
record_temp_file (filename, success_only)
     char *filename;
     int success_only;
{
  register struct temp_file *temp;
  register char *name;
  temp = (struct temp_file *) xmalloc (sizeof (struct temp_file));
  name = (char *) xmalloc (strlen (filename) + 1);
  strcpy (name, filename);
  temp->next = temp_file_queue;
  temp->name = name;
  temp->success_only = success_only;
  temp_file_queue = temp;
}

 


void
delete_temp_files (success)
     int success;
{
  register struct temp_file *temp;
  for (temp = temp_file_queue; temp; temp = temp->next)
    if (success || ! temp->success_only)
      {
# 230 "gcc.c"

	  unlink (temp->name);
      }
  temp_file_queue = 0;
}

 


void
choose_temp_base ()
{
  register char *foo = "/tmp/ccXXXXXX";
  temp_filename = (char *) xmalloc (strlen (foo) + 1);
  strcpy (temp_filename, foo);
  mktemp (temp_filename);
  temp_filename_length = strlen (temp_filename);
}

 

 

char **argbuf;

 

int argbuf_length;

 

int argbuf_index;

 

unsigned char vflag;

 


char *user_exec_prefix = 0;

 



char *standard_exec_prefix = "/sprite/cmds.%s/";
char *standard_exec_prefix_1 = "/sprite/lib/gcc/%s.md/";

char *standard_startfile_prefix = "/sprite/lib/%s.md/";
char *standard_startfile_prefix_1 = "/sprite/lib/gcc/%s.md/";

 


char *machine;
int machine_length;		 

 

void
clear_args ()
{
  argbuf_index = 0;
}

 





void
store_arg (arg, tempnamep)
     char *arg;
     int tempnamep;
{
  if (argbuf_index + 1 == argbuf_length)
    {
      argbuf = (char **) realloc (argbuf, (argbuf_length *= 2) * sizeof (char *));
    }

  argbuf[argbuf_index++] = arg;
  argbuf[argbuf_index] = 0;

  if (tempnamep)
    record_temp_file (arg, tempnamep == 2);
}

 


int
execute ()
{
  int pid;
  int status;
  int size;
  char *temp;
  int win = 0;

  size = strlen (standard_exec_prefix);
  if (user_exec_prefix != 0 && strlen (user_exec_prefix) > size)
    size = strlen (user_exec_prefix);
  if (strlen (standard_exec_prefix_1) > size)
    size = strlen (standard_exec_prefix_1);
  size += strlen (argbuf[0]) + machine_length + 1;
  temp = (char *) alloca (size);

   

  if (user_exec_prefix)
    {
      sprintf (temp, user_exec_prefix, machine);
      strcat (temp, argbuf[0]);
      win = (access (temp, 	1	) == 0);
    }

  if (!win)
    {
      sprintf (temp, standard_exec_prefix, machine);
      strcat (temp, argbuf[0]);
      win = (access (temp, 	1	) == 0);
    }

  if (!win)
    {
      sprintf (temp, standard_exec_prefix_1, machine);
      strcat (temp, argbuf[0]);
      win = (access (temp, 	1	) == 0);
    }

  if (vflag)
    {
      int i;
      for (i = 0; argbuf[i]; i++)
	{
	  if (i == 0 && win)
	    fprintf ((&stdioErrFile) , " %s", temp);
	  else
	    fprintf ((&stdioErrFile) , " %s", argbuf[i]);
	}
      fprintf ((&stdioErrFile) , "\n");
      fflush ((&stdioErrFile) );
# 382 "gcc.c"

    }






  pid = vfork ();
  if (pid < 0)
    pfatal_with_name ("vfork");

  if (pid == 0)
    {
      if (win)
	execv (temp, argbuf);
      else
	execvp (argbuf[0], argbuf);
      perror_with_name (argbuf[0]);
      _exit (65);
    }
  wait (&status);
  if ((status & 0x7F) != 0)
    fatal ("Program %s got fatal signal %d.", argbuf[0], (status & 0x7F));
  if (((status & 0xFF00) >> 8) >= 1 )
    return -1;
  return 0;
}

 





struct switchstr
{
  char *part1;
  char *part2;
};

struct switchstr *switches;

int n_switches;

 

char **infiles;

int n_infiles;

 

char **outfiles;

char *
make_switch (p1, s1, p2, s2)
     char *p1;
     int s1;
     char *p2;
     int s2;
{
  register char *new;
  if (p2 && s2 == 0)
    s2 = strlen (p2);
  new = (char *) xmalloc (s1 + s2 + 2);
  bcopy (p1, new, s1);
  if (p2)
    {
      new[s1++] = ' ';
      bcopy (p2, new + s1, s2);
    }
  new[s1 + s2] = 0;
  return new;
}

void
set_target_machine(name)
    char *name;
{
  register target_machine *t;
  int i;

  for (i = 0; ; i++)
    {
      t = &target_machines[i];
      if (t->name == 0)
        {
	  break;
	}
      if (strcmp(t->name, name) == 0)
        {
	  target_name = t->info->name;
	  target = t->info;
	  return;
	}
    }
}

 


void
process_command (argc, argv)
     int argc;
     char **argv;
{
  register int i;
  n_switches = 0;
  n_infiles = 0;

   



  for (i = 1; i < argc; i++)
    {
      if (argv[i][0] == '-' && argv[i][1] != 'l')
	{
	  register char *p = &argv[i][1];
	  register int c = *p;

	  p++;
	  if (((c) == 'D' || (c) == 'U' || (c) == 'o' || (c) == 'e' || (c) == 'T' || (c) == 'u' || (c) == 'I' || (c) == 'Y' || (c) == 'm' || (c) == 'L' || (c) == 'B')  && *p == 0)
	    {
	      i++;
	      p = argv[i];
	      if (p == 0 )
	        p = "";
	    }

	  switch (c)
	    {
	    case 'B':
	      user_exec_prefix = p;
	      break;

	    case 'v':	 
	      vflag++;
	      n_switches++;
	      break;

	    case 'm':
	       



	      set_target_machine(p);
	      n_switches++;
	      break;

	    default:
	      n_switches++;

	    }
	}
      else
	n_infiles++;
    }

   

  switches = ((struct switchstr *)
	      xmalloc ((n_switches + 1) * sizeof (struct switchstr)));
  infiles = (char **) xmalloc ((n_infiles + 1) * sizeof (char *));
  n_switches = 0;
  n_infiles = 0;

   



  for (i = 1; i < argc; i++)
    {
      if (argv[i][0] == '-' && argv[i][1] != 'l')
	{
	  register char *p = &argv[i][1];
	  register int c = *p;

	  switches[n_switches].part1 = p;
	  if (((c) == 'D' || (c) == 'U' || (c) == 'o' || (c) == 'e' || (c) == 'T' || (c) == 'u' || (c) == 'I' || (c) == 'Y' || (c) == 'm' || (c) == 'L' || (c) == 'B')  && p[1] == 0)
	    switches[n_switches].part2 = argv[++i];
	  else
	    switches[n_switches].part2 = 0;
	  if (c != 'B')
	    n_switches++;
	}
      else
	infiles[n_infiles++] = argv[i];
    }

  switches[n_switches].part1 = 0;
  infiles[n_infiles] = 0;
}

 

 






char *input_filename;
int input_file_number;
int input_filename_length;
int basename_length;
char *input_basename;

 

 

int arg_going;

 

int delete_this_arg;

 

int this_is_output_file;

 


int this_is_library_file;

 


int
do_spec (spec)
     char *spec;
{
  int value;

  clear_args ();
  arg_going = 0;
  delete_this_arg = 0;
  this_is_output_file = 0;
  this_is_library_file = 0;

  value = do_spec_1 (spec, 0);
  if (value == 0)
    value = do_spec_1 ("\n", 0);
  return value;
}

 











int
do_spec_1 (spec, inswitch)
     char *spec;
     int inswitch;
{
  register char *p = spec;
  register int c;
  char *string;

  while (c = *p++)
     

    switch (inswitch ? 'a' : c)
      {
      case '\n':
	 

	if (arg_going)
	  {
	    ({ struct obstack *__o = (&obstack);	((__o->next_free + 1 > __o->chunk_limit)	? _obstack_newchunk (__o, 1) : 0),	*(__o->next_free)++ = ( 0);	(void) 0; }) ;
	    string = ({ struct obstack *__o = (&obstack);	void *value = (void *) __o->object_base;	__o->next_free	= (((((__o->next_free) - (char *)0) +__o->alignment_mask)	& ~ (__o->alignment_mask)) + (char *)0) ;	((__o->next_free - (char *)__o->chunk	> __o->chunk_limit - (char *)__o->chunk)	? (__o->next_free = __o->chunk_limit) : 0);	__o->object_base = __o->next_free;	value; }) ;
	    if (this_is_library_file)
	      string = find_file (string);
	    store_arg (string, delete_this_arg);
	    if (this_is_output_file)
	      outfiles[input_file_number] = string;
	  }
	arg_going = 0;
	if (argbuf_index)
	  {
	    int value = execute ();
	    if (value)
	      return value;
	  }
	 
	clear_args ();
	arg_going = 0;
	delete_this_arg = 0;
	this_is_output_file = 0;
	this_is_library_file = 0;
	break;

      case '\t':
      case ' ':
	 
	if (arg_going)
	  {
	    ({ struct obstack *__o = (&obstack);	((__o->next_free + 1 > __o->chunk_limit)	? _obstack_newchunk (__o, 1) : 0),	*(__o->next_free)++ = ( 0);	(void) 0; }) ;
	    string = ({ struct obstack *__o = (&obstack);	void *value = (void *) __o->object_base;	__o->next_free	= (((((__o->next_free) - (char *)0) +__o->alignment_mask)	& ~ (__o->alignment_mask)) + (char *)0) ;	((__o->next_free - (char *)__o->chunk	> __o->chunk_limit - (char *)__o->chunk)	? (__o->next_free = __o->chunk_limit) : 0);	__o->object_base = __o->next_free;	value; }) ;
	    if (this_is_library_file)
	      string = find_file (string);
	    store_arg (string, delete_this_arg);
	    if (this_is_output_file)
	      outfiles[input_file_number] = string;
	  }
	 
	arg_going = 0;
	delete_this_arg = 0;
	this_is_output_file = 0;
	this_is_library_file = 0;
	break;

      case '%':
	switch (c = *p++)
	  {
	  case 0:
	    fatal ("Invalid specification!  Bug in cc.");

	  case 'i':
	    ({ struct obstack *__o = (&obstack);	int __len = ( input_filename_length);	((__o->next_free + __len > __o->chunk_limit)	? _obstack_newchunk (__o, __len) : 0);	bcopy ( input_filename, __o->next_free, __len);	__o->next_free += __len;	(void) 0; }) ;
	    arg_going = 1;
	    break;

	  case 'b':
	    ({ struct obstack *__o = (&obstack);	int __len = ( basename_length);	((__o->next_free + __len > __o->chunk_limit)	? _obstack_newchunk (__o, __len) : 0);	bcopy ( input_basename, __o->next_free, __len);	__o->next_free += __len;	(void) 0; }) ;
	    arg_going = 1;
	    break;

	  case 'p':
	    do_spec_1 (target->cpp_predefines, 0);
	    break;

	  case 'g':
	    ({ struct obstack *__o = (&obstack);	int __len = ( temp_filename_length);	((__o->next_free + __len > __o->chunk_limit)	? _obstack_newchunk (__o, __len) : 0);	bcopy ( temp_filename, __o->next_free, __len);	__o->next_free += __len;	(void) 0; }) ;
	    delete_this_arg = 1;
	    arg_going = 1;
	    break;

	  case 'm':
	      ({ struct obstack *__o = (&obstack);	int __len = ( strlen (target_name));	((__o->next_free + __len > __o->chunk_limit)	? _obstack_newchunk (__o, __len) : 0);	bcopy ( target_name, __o->next_free, __len);	__o->next_free += __len;	(void) 0; }) ;
	      arg_going = 1;
	      break;

	  case 'd':
	    delete_this_arg = 2;
	    break;

	  case 'w':
	    this_is_output_file = 1;
	    break;

	  case 's':
	    this_is_library_file = 1;
	    break;

	  case 'o':
	    {
	      register int f;
	      for (f = 0; f < n_infiles; f++)
		store_arg (outfiles[f], 0);
	    }
	    break;

	  case 'a':
	    do_spec_1 (target->asm_spec, 0);
	    break;

	  case 'C':
	    do_spec_1 (target->compile_spec, 0);
	    break;

	  case 'l':
	    do_spec_1 (target->link_spec, 0);
	    break;

	  case 'L':
	    do_spec_1 (target->lib_spec, 0);
	    break;

	  case 'S':
	    do_spec_1 (target->startfile_spec, 0);
	    break;

	  case '{':
	    p = handle_braces (p);
	    if (p == 0)
	      return -1;
	    break;

	  case '%':
	    ({ struct obstack *__o = (&obstack);	((__o->next_free + 1 > __o->chunk_limit)	? _obstack_newchunk (__o, 1) : 0),	*(__o->next_free)++ = ( '%');	(void) 0; }) ;
	    break;

	  default:
	    fatal ("Invalid spec sequence \"%%%c\"!  Bug in cc.", c);
	  }
	break;

      default:
	 
	({ struct obstack *__o = (&obstack);	((__o->next_free + 1 > __o->chunk_limit)	? _obstack_newchunk (__o, 1) : 0),	*(__o->next_free)++ = ( c);	(void) 0; }) ;
	arg_going = 1;
      }

  return 0;		 
}

 

char *
handle_braces (p)
     register char *p;
{
  register char *q;
  int negate = *p == '!';
  char *filter;

  if (negate) ++p;

  filter = p;
  while (*p != ':' && *p != '}') p++;
  if (*p != '}')
    {
      register int count = 1;
      q = p + 1;
      while (count > 0)
	{
	  if (*q == '{')
	    count++;
	  else if (*q == '}')
	    count--;
	  else if (*q == 0)
	    abort ();
	  q++;
	}
    }
  else
    q = p + 1;

  if (p[-1] == '*' && p[0] == '}')
    {
       
      register int i;
      --p;
      for (i = 0; i < n_switches; i++)
	if (!strncmp (switches[i].part1, filter, p - filter))
	  {
	    give_switch (i);
	  }
    }
  else
    {
       
      register int i;
      int present = 0;

       

      if (p[-1] == '*')
	{
	  for (i = 0; i < n_switches; i++)
	    {
	      if (!strncmp (switches[i].part1, filter, p - filter - 1))
		{
		  present = 1;
		  break;
		}
	    }
	}
       
      else
	{
	  for (i = 0; i < n_switches; i++)
	    {
	      if (!strncmp (switches[i].part1, filter, p - filter)
		  && switches[i].part1[p - filter] == 0)
		{
		  present = 1;
		  break;
		}
	    }
	}

       


      if (present != negate)
	{
	  if (*p == '}')
	    {
	      give_switch (i);
	    }
	  else
	    {
	      if (do_spec_1 (save_string (p + 1, q - p - 2), 0) < 0)
		return 0;
	    }
	}
    }

  return q;
}

 





give_switch (switchnum)
     int switchnum;
{
  do_spec_1 ("-", 0);
  do_spec_1 (switches[switchnum].part1, 1);
  do_spec_1 (" ", 0);
  if (switches[switchnum].part2 != 0)
    {
      do_spec_1 (switches[switchnum].part2, 1);
      do_spec_1 (" ", 0);
    }
}

 



char *
find_file (name)
     char *name;
{
  int size;
  char *temp;
  int win = 0;

   

  size = strlen (standard_exec_prefix);
  if (user_exec_prefix != 0 && strlen (user_exec_prefix) > size)
    size = strlen (user_exec_prefix);
  if (strlen (standard_exec_prefix_1) > size)
    size = strlen (standard_exec_prefix_1);
  if (strlen (standard_startfile_prefix) > size)
    size = strlen (standard_startfile_prefix);
  if (strlen (standard_startfile_prefix_1) > size)
    size = strlen (standard_startfile_prefix_1);
  size += strlen (name) + strlen(target_name) + 1;

  temp = (char *) alloca (size);

  if (user_exec_prefix)
    {
      sprintf (temp, user_exec_prefix, target_name);
      strcat (temp, name);
      win = (access (temp, 	4	) == 0);
    }

  if (!win)
    {
      sprintf (temp, standard_exec_prefix, target_name);
      strcat (temp, name);
      win = (access (temp, 	4	) == 0);
    }

  if (!win)
    {
      sprintf (temp, standard_exec_prefix_1, target_name);
      strcat (temp, name);
      win = (access (temp, 	4	) == 0);
    }

  if (!win)
    {
      strcpy (temp, standard_startfile_prefix);
      strcat (temp, name);
      win = (access (temp, 	4	) == 0);
    }

  if (!win)
    {
      strcpy (temp, standard_startfile_prefix_1);
      strcat (temp, name);
      win = (access (temp, 	4	) == 0);
    }

  if (!win)
    {
      strcpy (temp, "./");
      strcat (temp, name);
      win = (access (temp, 	4	) == 0);
    }

  if (win)
    return save_string (temp, strlen (temp));
  return name;
}

 

char *programname;

 

void
fatal_error (signum)
     int signum;
{
  signal (signum, 	(void (*)())0 );
  delete_temp_files (0);
   

  kill (getpid (), signum);
}

int
main (argc, argv)
     int argc;
     char **argv;
{
  register int i;
  int value;
  int nolink = 0;
  int error = 0;
  extern char *getenv();

  programname = argv[0];

  if (signal (2	, 	(void (*)())1 ) != 	(void (*)())1 )
    signal (2	, fatal_error);
  if (signal (1	, 	(void (*)())1 ) != 	(void (*)())1 )
    signal (1	, fatal_error);
  if (signal (15	, 	(void (*)())1 ) != 	(void (*)())1 )
    signal (15	, fatal_error);

  argbuf_length = 10;
  argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));

  _obstack_begin ((&obstack), 0, 0, xmalloc , free ) ;

  choose_temp_base ();

   


  process_command (argc, argv);

   


  machine = getenv("MACHINE");
  if (machine == 0 )
    {
      machine = "";
    }
  machine_length = strlen(machine);

   



  if (target == 0 )
    {
      char *env;

      env = getenv ("TM");
      if (env == 0 )
        {
	  env = getenv ("MACHINE");
	  if (env == 0 )
	    {
	      env = target_machines[0].name;
	    }
	}
      set_target_machine (env);
    }

  if (vflag)
    {
      extern char *version_string;
      printf ("gcc version %s\n", version_string);
      printf ("target machine is %s\n", target_name);
      if (n_infiles == 0)
	exit (0);
    }

  if (n_infiles == 0)
    fatal ("No source or object files specified.");

   


  outfiles = (char **) xmalloc (n_infiles * sizeof (char *));
  bzero (outfiles, n_infiles * sizeof (char *));

  for (i = 0; i < n_infiles; i++)
    {
       
      
      register struct compiler *cp;

       

      input_filename = infiles[i];
      input_filename_length = strlen (input_filename);
      input_file_number = i;

       

      outfiles[i] = input_filename;

      for (cp = target->base_specs; cp->spec; cp++)
	{
	  if (strlen (cp->suffix) < input_filename_length
	      && !strcmp (cp->suffix,
			  infiles[i] + input_filename_length
			  - strlen (cp->suffix)))
	    {
	       
	       
	      register char *p;

	      input_basename = input_filename;
	      for (p = input_filename; *p; p++)
		if (*p == '/')
		  input_basename = p + 1;
	      basename_length = (input_filename_length - strlen (cp->suffix)
				 - (input_basename - input_filename));
	      value = do_spec (cp->spec);
	      if (value < 0)
		error = 1;
	      break;
	    }
	}

       


    }

   

  if (! nolink && error == 0)
    {
      value = do_spec (target->link_base_spec);
      if (value < 0)
	error = 1;
    }

   

  delete_temp_files (error == 0);

  exit (error);
}

xmalloc (size)
     int size;
{
  register int value = malloc (size);
  if (value == 0)
    fatal ("Virtual memory full.");
  return value;
}

xrealloc (ptr, size)
     int ptr, size;
{
  register int value = realloc (ptr, size);
  if (value == 0)
    fatal ("Virtual memory full.");
  return value;
}

fatal (msg, arg1, arg2)
     char *msg, *arg1, *arg2;
{
  error (msg, arg1, arg2);
  delete_temp_files (0);
  exit (1);
}

error (msg, arg1, arg2)
     char *msg, *arg1, *arg2;
{
  fprintf ((&stdioErrFile) , "%s: ", programname);
  fprintf ((&stdioErrFile) , msg, arg1, arg2);
  fprintf ((&stdioErrFile) , "\n");
}

 

char *
concat (s1, s2, s3)
     char *s1, *s2, *s3;
{
  int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
  char *result = (char *) xmalloc (len1 + len2 + len3 + 1);

  strcpy (result, s1);
  strcpy (result + len1, s2);
  strcpy (result + len1 + len2, s3);
  *(result + len1 + len2 + len3) = 0;

  return result;
}

char *
save_string (s, len)
     char *s;
     int len;
{
  register char *result = (char *) xmalloc (len + 1);

  bcopy (s, result, len);
  result[len] = 0;
  return result;
}

pfatal_with_name (name)
     char *name;
{
  extern int errno, sys_nerr;
  extern char *sys_errlist[];
  char *s;

  if (errno < sys_nerr)
    s = concat ("", sys_errlist[errno], " for %s");
  else
    s = "cannot open %s";
  fatal (s, name);
}

perror_with_name (name)
     char *name;
{
  extern int errno, sys_nerr;
  extern char *sys_errlist[];
  char *s;

  if (errno < sys_nerr)
    s = concat ("", sys_errlist[errno], " for %s");
  else
    s = "cannot open %s";
  error (s, name);
}
