home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / prgtools / gnustuff / tos / updates / update26.zoo / gcc-231 / gcc-231.diff < prev    next >
Encoding:
Text File  |  1992-11-07  |  62.1 KB  |  2,366 lines
  1. *** 1.9    1992/11/07 04:57:45
  2. --- c-decl.c    1992/11/08 00:48:24
  3. ***************
  4. *** 5868,5873 ****
  5. --- 5868,5875 ----
  6.   
  7.     expand_function_start (fndecl, 0);
  8.   
  9. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  10. +   /* we will only need this in cp-decl.c, not here */
  11.     /* If this function is `main', emit a call to `__main'
  12.        to run global initializers, etc.  */
  13.     if (DECL_NAME (fndecl)
  14. ***************
  15. *** 5874,5879 ****
  16. --- 5876,5882 ----
  17.         && strcmp (IDENTIFIER_POINTER (DECL_NAME (fndecl)), "main") == 0
  18.         && DECL_CONTEXT (fndecl) == NULL_TREE)
  19.       expand_main_function ();
  20. + #endif
  21.   }
  22.   
  23.   /* SPECPARMS is an identifier list--a chain of TREE_LIST nodes
  24. *** 1.5    1992/11/07 04:57:45
  25. --- c-lex.c    1992/11/08 00:48:25
  26. ***************
  27. *** 391,396 ****
  28. --- 391,397 ----
  29.       case '\r':
  30.         /* ANSI C says the effects of a carriage return in a source file
  31.            are undefined.  */
  32. + #ifndef atarist /* but not on an atarist, though hopefully we should'nt see it */
  33.         if (pedantic && !newline_warning)
  34.           {
  35.             warning ("carriage return in source file");
  36. ***************
  37. *** 397,402 ****
  38. --- 398,404 ----
  39.             warning ("(we only warn about the first carriage return)");
  40.             newline_warning = 1;
  41.           }
  42. + #endif
  43.         c = getc (finput);
  44.         break;
  45.   
  46. *** 1.11    1992/11/07 04:57:45
  47. --- cccp.c    1992/11/08 00:48:31
  48. ***************
  49. *** 71,76 ****
  50. --- 71,78 ----
  51.   #undef bzero
  52.   #undef bcmp
  53.   
  54. + #ifndef atarist
  55. + 
  56.   #include <sys/types.h>
  57.   #include <sys/stat.h>
  58.   #include <ctype.h>
  59. ***************
  60. *** 77,91 ****
  61.   #include <stdio.h>
  62.   
  63.   #ifndef VMS
  64. ! #ifndef USG
  65.   #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  66.   #include <sys/resource.h>
  67.   #else
  68.   #include <time.h>
  69.   #include <fcntl.h>
  70. ! #endif /* USG */
  71.   #endif /* not VMS */
  72.   
  73.   /* VMS-specific definitions */
  74.   #ifdef VMS
  75.   #include <time.h>
  76. --- 79,111 ----
  77.   #include <stdio.h>
  78.   
  79.   #ifndef VMS
  80. ! #if (!(defined(USG) || defined(atariminix)))
  81.   #include <sys/time.h>        /* for __DATE__ and __TIME__ */
  82.   #include <sys/resource.h>
  83.   #else
  84.   #include <time.h>
  85.   #include <fcntl.h>
  86. ! #endif /* USG or atariminix */
  87.   #endif /* not VMS */
  88.   
  89. + #else    /* atarist */
  90. + 
  91. + #include <ctype.h>
  92. + #include <stdio.h>
  93. + #include <types.h>
  94. + #include <stat.h>
  95. + #include <file.h>
  96. + #include <time.h>
  97. + #include <string.h>
  98. + #include "stddef.h"
  99. + 
  100. + long _stksize = -1L;    /* want big stack cause include files
  101. +                    get alloca'ed there */
  102. + 
  103. + #define read(fd,buf,size)    _text_read(fd,buf,size)
  104. + 
  105. + #endif        /* atarist */
  106. + 
  107.   /* VMS-specific definitions */
  108.   #ifdef VMS
  109.   #include <time.h>
  110. ***************
  111. *** 925,930 ****
  112. --- 945,971 ----
  113.   /* Nonzero means -I- has been seen,
  114.      so don't look for #include "foo" the source-file directory.  */
  115.   static int ignore_srcdir;
  116. +  
  117. + #ifdef atarist
  118. + /* the following dingus is used in place of some calls to bcopy,
  119. +    to ensure that backslashes get properly slashified when getting
  120. +    shoved into strings.  Note that it returns the new pointer!!
  121. +    There ought to be a better way... */
  122. + 
  123. + U_CHAR * slashifying_bcopy(from_buf, to_buf, nbytes)
  124. + U_CHAR * from_buf, * to_buf;
  125. + int nbytes;
  126. + {
  127. +   for ( ; nbytes > 0 ; )
  128. +     {
  129. +     if(*from_buf == '\\')
  130. +         *to_buf++ = '\\';
  131. +     *to_buf++ = *from_buf++;
  132. +     nbytes--;
  133. +     }
  134. +   return(to_buf);
  135. + }
  136. + #endif        /* atarist */
  137.   
  138.   int
  139.   main (argc, argv)
  140. ***************
  141. *** 963,968 ****
  142. --- 1004,1014 ----
  143.     /* Target-name to write with the dependency information.  */
  144.     char *deps_target = 0;
  145.   
  146. + #ifdef atarist
  147. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  148. + /*  _malloczero(1); */     /* zero mallocs by default */
  149. + #endif  
  150. + 
  151.   #ifdef RLIMIT_STACK
  152.     /* Get rid of any avoidable limit on stack size.  */
  153.     {
  154. ***************
  155. *** 1210,1219 ****
  156. --- 1256,1271 ----
  157.       break;
  158.   
  159.         case 'v':
  160. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  161. + #include "PatchLev.h"
  162. +     fprintf (stderr, "GNU CPP-atariST version %s Patchlevel %s",
  163. +          version_string, PatchLevel);
  164. + #else
  165.       fprintf (stderr, "GNU CPP version %s", version_string);
  166.   #ifdef TARGET_VERSION
  167.       TARGET_VERSION;
  168.   #endif
  169. + #endif
  170.       fprintf (stderr, "\n");
  171.       break;
  172.   
  173. ***************
  174. *** 1345,1350 ****
  175. --- 1397,1403 ----
  176.       }
  177.     }
  178.   
  179. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  180.     /* Add dirs from CPATH after dirs from -I.  */
  181.     /* There seems to be confusion about what CPATH should do,
  182.        so for the moment it is not documented.  */
  183. ***************
  184. *** 1354,1359 ****
  185. --- 1407,1413 ----
  186.     p = (char *) getenv ("CPATH");
  187.     if (p != 0 && ! no_standard_includes)
  188.       path_include (p);
  189. + #endif
  190.   
  191.     /* Now that dollars_in_ident is known, initialize is_idchar.  */
  192.     initialize_char_syntax ();
  193. ***************
  194. *** 1477,1484 ****
  195.     { /* read the appropriate environment variable and if it exists
  196.          replace include_defaults with the listed path. */
  197.       char *epath = 0;
  198.       switch ((objc << 1) + cplusplus)
  199. !       {
  200.         case 0:
  201.       epath = getenv ("C_INCLUDE_PATH");
  202.       break;
  203. --- 1531,1586 ----
  204.     { /* read the appropriate environment variable and if it exists
  205.          replace include_defaults with the listed path. */
  206.       char *epath = 0;
  207. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  208. +     int db_hack = 0;
  209. +     char *e1 = getenv("GNUINC"), *e2 = getenv("GNULIB"),
  210. +          *e3 = getenv("GXXINC");
  211. + 
  212. + 
  213. +     /* Get length of the alloc'ed array. (Yeah I know, I might alloc
  214. +      * a character more than I need but who cares...
  215. +      */
  216. +     if (cplusplus && e3)
  217. +     db_hack += strlen (e3);
  218. +     if (e1)
  219. +         db_hack += strlen (e1) + 1;
  220. +     if (e2)
  221. +         db_hack += strlen (e1) + 1;
  222. + 
  223. +     if (db_hack) {
  224. +     epath = alloca (db_hack + 1);
  225. +     *epath = '\0';
  226. +     db_hack = 0;
  227. + 
  228. +     /* Concatenate the paths together. */
  229. +     if (cplusplus && e3) {
  230. +         strcpy (epath, e3);
  231. +         db_hack = 1;
  232. +     }
  233. +     if (e1) {
  234. +         if (db_hack) {
  235. +         strcat (epath, PATH_SEP_STR);
  236. +         }
  237. +         strcat (epath, e1);
  238. +         db_hack = 1;
  239. +     }
  240. +     if (e2) {
  241. +         if (db_hack) {
  242. +         strcat (epath, PATH_SEP_STR);
  243. +         }
  244. +         strcat (epath, e2);
  245. +     }
  246. +     }
  247. + 
  248. + #ifdef atarist
  249. +     if (epath)
  250. +         for (e3=epath; *e3; e3++)    /* Use one kind of path separator */
  251. +         if (*e3 == ';')
  252. +         *e3 = PATH_SEPARATOR;
  253. + #endif
  254. + #else
  255.       switch ((objc << 1) + cplusplus)
  256. !     {
  257.         case 0:
  258.       epath = getenv ("C_INCLUDE_PATH");
  259.       break;
  260. ***************
  261. *** 1491,1497 ****
  262.         case 3:
  263.       epath = getenv ("OBJCPLUS_INCLUDE_PATH");
  264.       break;
  265. !       }
  266.       /* If the environment var for this language is set,
  267.          add to the default list of include directories.  */
  268.       if (epath) {
  269. --- 1593,1601 ----
  270.         case 3:
  271.       epath = getenv ("OBJCPLUS_INCLUDE_PATH");
  272.       break;
  273. !     }
  274. ! #endif
  275. ! 
  276.       /* If the environment var for this language is set,
  277.          add to the default list of include directories.  */
  278.       if (epath) {
  279. ***************
  280. *** 1545,1551 ****
  281. --- 1649,1659 ----
  282.     if (!no_standard_includes) {
  283.       struct default_include *p = include_defaults;
  284.       char *specd_prefix = include_prefix;
  285. + #ifdef GCC_INCLUDE_DIR
  286.       char *default_prefix = savestring (GCC_INCLUDE_DIR);
  287. + #else
  288. +     char *default_prefix = savestring ("./");
  289. + #endif
  290.       int default_len = 0;
  291.       /* Remove the `include' from /usr/local/lib/gcc.../include.  */
  292.       if (!strcmp (default_prefix + strlen (default_prefix) - 8, "/include")) {
  293. ***************
  294. *** 1552,1557 ****
  295. --- 1660,1671 ----
  296.         default_len = strlen (default_prefix) - 7;
  297.         default_prefix[default_len] = 0;
  298.       }
  299. + #ifdef atarist
  300. +     else if (!strcmp (default_prefix + strlen (default_prefix) - 8, "\\include")) {
  301. +       default_len = strlen (default_prefix) - 7;
  302. +       default_prefix[default_len] = 0;
  303. +     }
  304. + #endif
  305.       /* Search "translated" versions of GNU directories.
  306.          These have /usr/local/lib/gcc... replaced by specd_prefix.  */
  307.       if (specd_prefix != 0 && default_len != 0)
  308. ***************
  309. *** 1678,1684 ****
  310. --- 1792,1802 ----
  311.         char *p1 = p;
  312.         /* Discard all directory prefixes from P.  */
  313.         while (*p1) {
  314. + #ifdef atarist
  315. +     if ((*p1 == '/') || (*p1 == '\\'))
  316. + #else
  317.       if (*p1 == '/')
  318. + #endif
  319.         p = p1 + 1;
  320.       p1++;
  321.         }
  322. ***************
  323. *** 1840,1845 ****
  324. --- 1958,1964 ----
  325.     return 0;
  326.   }
  327.   
  328. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  329.   /* Given a colon-separated list of file names PATH,
  330.      add all the names to the search path for include files.  */
  331.   
  332. ***************
  333. *** 1886,1891 ****
  334. --- 2005,2011 ----
  335.         p++;
  336.       }
  337.   }
  338. + #endif /* atarist */
  339.   
  340.   /* Pre-C-Preprocessor to translate ANSI trigraph idiocy in BUF
  341.      before main CCCP processing.  Name `pcp' is also in honor of the
  342. ***************
  343. *** 3040,3045 ****
  344. --- 3160,3166 ----
  345.     assertions_flag = save_assertions_flag;
  346.     return obuf;
  347.   }
  348. + /* #endif */
  349.   
  350.   /*
  351.    * Process a # directive.  Expects IP->bufp to point after the '#', as in
  352. ***************
  353. *** 3501,3508 ****
  354. --- 3622,3638 ----
  355.   
  356.         if (string)
  357.       {
  358. + #ifndef atarist
  359.         buf = (char *) alloca (3 + strlen (string));
  360.         sprintf (buf, "\"%s\"", string);
  361. + #else
  362. +           buf = (char *) alloca (16 + strlen (string));
  363. +           {
  364. +           char *tbuf = (char *) alloca (16 + strlen (string));
  365. +           (void) slashifying_bcopy(string, tbuf, strlen(string)+1);
  366. +           sprintf (buf, "\"%s\"", tbuf);
  367. +           }
  368. + #endif /* atarist */
  369.       }
  370.         else
  371.       buf = "\"\"";
  372. ***************
  373. *** 3724,3730 ****
  374. --- 3854,3865 ----
  375.           dsp[0].next = search_start;
  376.           search_start = dsp;
  377.   #ifndef VMS
  378. + #ifdef atarist
  379. +         if((ep = rindex(nam, '\\')) == NULL)
  380. +         ep = rindex(nam, '/');
  381. + #else
  382.           ep = rindex (nam, '/');
  383. + #endif
  384.   #else                /* VMS */
  385.           ep = rindex (nam, ']');
  386.           if (ep == NULL) ep = rindex (nam, '>');
  387. ***************
  388. *** 3800,3808 ****
  389. --- 3935,3957 ----
  390.   
  391.     /* If specified file name is absolute, just open it.  */
  392.   
  393. + #ifdef atarist
  394. +   if ((*fbeg == '\\') || (*fbeg == '/')) {
  395. +     if(fbeg[2] == ':')
  396. +     { /* allow "\D:\xxx" */
  397. +         strncpy (fname, fbeg+1, flen-1);
  398. +         fname[flen-1] = 0;
  399. +     }
  400. +     else
  401. +     {  /* allow "\lib\xxx" == "\currentdrive:\lib\xxx" */
  402. +         strncpy (fname, fbeg, flen);
  403. +         fname[flen] = 0;
  404. +     }
  405. + #else
  406.     if (*fbeg == '/') {
  407.       strncpy (fname, fbeg, flen);
  408.       fname[flen] = 0;
  409. + #endif
  410.       if (redundant_include_p (fname))
  411.         return 0;
  412.       if (importing)
  413. ***************
  414. *** 3823,3829 ****
  415. --- 3972,3982 ----
  416.       if (searchptr->fname[0] == 0)
  417.         continue;
  418.       strcpy (fname, searchptr->fname);
  419. + #ifdef atarist
  420. +     strcat (fname, "\\");
  421. + #else
  422.       strcat (fname, "/");
  423. + #endif
  424.       fname[strlen (fname) + flen] = 0;
  425.         } else {
  426.       fname[0] = 0;
  427. ***************
  428. *** 3945,3961 ****
  429.   
  430.       if (!no_precomp)
  431.         do {
  432.       sprintf (pcftry, "%s%d", fname, pcfnum++);
  433.       
  434.       pcf = open (pcftry, O_RDONLY, 0666);
  435.       if (pcf != -1)
  436.         {
  437.           struct stat s;
  438.   
  439.           fstat (pcf, &s);
  440.           if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
  441.           || stat_f.st_dev != s.st_dev)
  442. !           {
  443.           pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
  444.           /* Don't need it any more.  */
  445.           close (pcf);
  446. --- 4098,4156 ----
  447.   
  448.       if (!no_precomp)
  449.         do {
  450. + #ifdef atarist
  451. +     int numlen;
  452. +     char *dot;
  453. +     char *slash;
  454. + 
  455. +     /* cut extension to 3 chars and dont depend on UNIXMODE           */
  456. +     /* this will have to be done when saving precompiled headers, too */
  457. +     /* but as far as I tried, they dont work up to now, anyway   (AL) */
  458. + 
  459. +       if( pcfnum>=100 )     numlen=3;
  460. +       else if( pcfnum>=10 ) numlen=2;
  461. +       else                  numlen=1;
  462. + 
  463. +       dot=strrchr( fname, '.' );
  464. +       if( (slash=strrchr( fname, '/')) && slash>dot )
  465. +         dot=NULL;
  466. +       else
  467. +       if( (slash=strrchr( fname, '\\')) && slash>dot )
  468. +         dot=NULL;
  469. + 
  470. +       if( dot ) {
  471. +         if( strlen(dot)-1>3-numlen ) {
  472. +           sprintf(pcftry, "%.*s%d", strlen(fname)-(strlen(dot)-(4-numlen)),
  473. +                   fname, pcfnum++);
  474. +         } else {
  475. +           sprintf(pcftry, "%s%d", fname, pcfnum++);
  476. +         }
  477. +       } else {
  478. +         sprintf( pcftry, "%s.%d", fname, pcfnum++);
  479. +       }
  480. + #else    /* looks like we got a sane filesystem */
  481.       sprintf (pcftry, "%s%d", fname, pcfnum++);
  482. + #endif
  483. + #if 0
  484. +     fprintf ( stderr, "trying precompiled file %s.\n", pcftry );
  485. + #endif
  486.       
  487.       pcf = open (pcftry, O_RDONLY, 0666);
  488.       if (pcf != -1)
  489.         {
  490. + #ifndef atarist
  491. +         /* dont bother with this on the ST since these field are faked
  492. +          * anyways
  493. +              */
  494.           struct stat s;
  495.   
  496.           fstat (pcf, &s);
  497.           if (bcmp (&stat_f.st_ino, &s.st_ino, sizeof (s.st_ino))
  498.           || stat_f.st_dev != s.st_dev)
  499. ! #else
  500. !         if (1)
  501. ! #endif
  502. !               {
  503.           pcfbuf = check_precompiled (pcf, fname, &pcfbuflimit);
  504.           /* Don't need it any more.  */
  505.           close (pcf);
  506. ***************
  507. *** 6831,6838 ****
  508. --- 7026,7037 ----
  509.     check_expand (op, len + 1);
  510.     if (op->bufp > op->buf && op->bufp[-1] != '\n')
  511.       *op->bufp++ = '\n';
  512. + #ifdef atarist
  513. +   op->bufp = slashifying_bcopy (line_cmd_buf, op->bufp, len);
  514. + #else
  515.     bcopy (line_cmd_buf, op->bufp, len);
  516.     op->bufp += len;
  517. + #endif
  518.     op->lineno = ip->lineno;
  519.   }
  520.   
  521. ***************
  522. *** 8476,8481 ****
  523. --- 8675,8681 ----
  524.     deps_buffer[deps_size] = 0;
  525.   }
  526.   
  527. + #if (!(defined(atarist) || defined(atariminix)))
  528.   #if defined(USG) || defined(VMS)
  529.   #ifndef BSTRING
  530.   
  531. ***************
  532. *** 8512,8518 ****
  533.   }
  534.   #endif /* not BSTRING */
  535.   #endif /* USG or VMS */
  536. ! 
  537.   
  538.   static void
  539.   fatal (str, arg)
  540. --- 8712,8718 ----
  541.   }
  542.   #endif /* not BSTRING */
  543.   #endif /* USG or VMS */
  544. ! #endif /* any atari */
  545.   
  546.   static void
  547.   fatal (str, arg)
  548. *** 1.8    1992/11/07 04:57:45
  549. --- cp-tree.c    1992/11/08 00:48:47
  550. ***************
  551. *** 1692,1697 ****
  552. --- 1692,1698 ----
  553.     print_class_statistics ();
  554.   }
  555.   
  556. + #ifndef atarist
  557.   /* This is used by the `assert' macro.  It is provided in libgcc.a,
  558.      which `cc' doesn't know how to link.  */
  559.   void
  560. ***************
  561. *** 1712,1717 ****
  562. --- 1713,1719 ----
  563.     fflush (stderr);
  564.     abort ();
  565.   }
  566. + #endif
  567.   
  568.   /* Return, as an INTEGER_CST node, the number of elements for
  569.      TYPE (which is an ARRAY_TYPE).  This counts only elements of the top array. */
  570. *** 1.5    1992/11/07 04:57:45
  571. --- expr.c    1992/11/08 00:49:01
  572. ***************
  573. *** 1960,1965 ****
  574. --- 1960,1971 ----
  575.   
  576.     argvec = (struct arg *) alloca (nargs * sizeof (struct arg));
  577.   
  578. + /* how would you do this RIGHT ?? fake a DECL node? dunno... */
  579. + #ifdef ENCODE_SECTION_INFO
  580. +   /* mark it as a function (to be in the text section that is) */
  581. +   SYMBOL_REF_FLAG (fun) = 1;
  582. + #endif
  583. + 
  584.     INIT_CUMULATIVE_ARGS (args_so_far, (tree)0, fun);
  585.   
  586.     args_size.constant = 0;
  587. *** 1.10    1992/11/07 04:57:45
  588. --- final.c    1992/11/08 00:49:02
  589. ***************
  590. *** 67,74 ****
  591. --- 67,78 ----
  592.   #if defined (USG) || defined (NO_STAB_H)
  593.   #include "gstab.h"  /* If doing DBX on sysV, use our own stab.h.  */
  594.   #else
  595. + #if defined(CROSSATARI) || defined(atarist) || defined(atariminix)
  596. + #include "astab.h"
  597. + #else
  598.   #include <stab.h>  /* On BSD, use the system's stab.h.  */
  599.   #endif /* not USG */
  600. + #endif /* not atari */
  601.   #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
  602.   
  603.   #ifdef XCOFF_DEBUGGING_INFO
  604. *** 1.15    1992/11/07 04:57:45
  605. --- gcc.c    1992/11/08 00:49:08
  606. ***************
  607. *** 30,35 ****
  608. --- 30,44 ----
  609.   Once it knows which kind of compilation to perform, the procedure for
  610.   compilation is specified by a string called a "spec".  */
  611.   
  612. + #ifdef CROSSATARI
  613. + #ifdef atarist
  614. + #undef atarist
  615. + #endif
  616. + #ifdef atariminix
  617. + #undef atariminix
  618. + #endif
  619. + #endif
  620. +   
  621.   #include <sys/types.h>
  622.   #include <ctype.h>
  623.   #include <signal.h>
  624. ***************
  625. *** 40,45 ****
  626. --- 49,57 ----
  627.   #include "obstack.h"
  628.   #include "gvarargs.h"
  629.   #include <stdio.h>
  630. + #ifdef CROSSATARI
  631. + #include <ctype.h>
  632. + #endif
  633.   
  634.   #ifndef R_OK
  635.   #define R_OK 4
  636. ***************
  637. *** 65,71 ****
  638.   #define NULL_PTR ((GENERIC_PTR)0)
  639.   #endif
  640.   
  641. ! #ifdef USG
  642.   #define vfork fork
  643.   #endif /* USG */
  644.   
  645. --- 77,83 ----
  646.   #define NULL_PTR ((GENERIC_PTR)0)
  647.   #endif
  648.   
  649. ! #if (defined(USG) || defined(atariminix))
  650.   #define vfork fork
  651.   #endif /* USG */
  652.   
  653. ***************
  654. *** 97,102 ****
  655. --- 109,121 ----
  656.   #define PATH_SEPARATOR ':'
  657.   #endif
  658.   
  659. + #ifdef atarist
  660. + #include <osbind.h>
  661. + #include <ctype.h>
  662. + #include <fcntl.h>        /* fgth, for redirection of stderr */
  663. + long _stksize = 8192;
  664. + #endif
  665. + 
  666.   #define obstack_chunk_alloc xmalloc
  667.   #define obstack_chunk_free free
  668.   
  669. ***************
  670. *** 153,159 ****
  671. --- 172,180 ----
  672.      pass the compiler in building the list of pointers to constructors
  673.      and destructors.  */
  674.   
  675. + #if (!(defined(CROSSATARI) || defined(atarist)))
  676.   static struct obstack collect_obstack;
  677. + #endif
  678.   
  679.   extern char *version_string;
  680.   
  681. ***************
  682. *** 445,451 ****
  683.              %{aux-info*}\
  684.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  685.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  686. !               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  687.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  688.                         %{!pipe:%g.s} %A\n }}}}"},
  689.     {"-",
  690. --- 466,472 ----
  691.              %{aux-info*}\
  692.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  693.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  694. !               %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  695.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  696.                         %{!pipe:%g.s} %A\n }}}}"},
  697.     {"-",
  698. ***************
  699. *** 478,484 ****
  700.              %{aux-info*}\
  701.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  702.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  703. !               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  704.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  705.                         %{!pipe:%g.s} %A\n }}}}"},
  706.     {".h", "@c-header"},
  707. --- 499,505 ----
  708.              %{aux-info*}\
  709.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  710.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  711. !               %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  712.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  713.                         %{!pipe:%g.s} %A\n }}}}"},
  714.     {".h", "@c-header"},
  715. ***************
  716. *** 513,519 ****
  717.              %{aux-info*}\
  718.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  719.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  720. !               %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  721.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  722.                         %{!pipe:%g.s} %A\n }}}}"},
  723.     {".i", "@cpp-output"},
  724. --- 534,540 ----
  725.              %{aux-info*}\
  726.              %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  727.              %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  728. !               %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  729.                 %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  730.                         %{!pipe:%g.s} %A\n }}}}"},
  731.     {".i", "@cpp-output"},
  732. ***************
  733. *** 524,530 ****
  734.       %{aux-info*}\
  735.       %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  736.       %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  737. !     %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  738.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n }"},
  739.     {".ii", "@c++-cpp-output"},
  740.     {"@c++-cpp-output",
  741. --- 545,551 ----
  742.       %{aux-info*}\
  743.       %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  744.       %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  745. !     %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  746.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %{!pipe:%g.s} %A\n }"},
  747.     {".ii", "@c++-cpp-output"},
  748.     {"@c++-cpp-output",
  749. ***************
  750. *** 534,547 ****
  751.           %{aux-info*}\
  752.           %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  753.           %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  754. !        %{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  755.              %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  756.              %{!pipe:%g.s} %A\n }"},
  757.     {".s", "@assembler"},
  758.     {"@assembler",
  759. !    "%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  760.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %i %A\n }"},
  761.     {".S", "@assembler-with-cpp"},
  762.     {"@assembler-with-cpp",
  763.      "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{D*} %{U*} %{I*} %{i*} %{P} %I\
  764.       %{C:%{!E:%eGNU C does not support -C without using -E}}\
  765. --- 555,571 ----
  766.           %{aux-info*}\
  767.           %{pg:%{fomit-frame-pointer:%e-pg and -fomit-frame-pointer are incompatible}}\
  768.           %{S:%W{o*}%{!o*:-o %b.s}}%{!S:-o %{|!pipe:%g.s}} |\n\
  769. !        %{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  770.              %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  771.              %{!pipe:%g.s} %A\n }"},
  772.     {".s", "@assembler"},
  773.     {"@assembler",
  774. !    "%{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  775.               %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o} %i %A\n }"},
  776.     {".S", "@assembler-with-cpp"},
  777. +   {".ss", "@assembler-with-cpp"},
  778. +   {".cpp", "@assembler-with-cpp"},
  779. +   {".spp", "@assembler-with-cpp"},
  780.     {"@assembler-with-cpp",
  781.      "cpp -lang-asm %{nostdinc*} %{C} %{v} %{A*} %{D*} %{U*} %{I*} %{i*} %{P} %I\
  782.       %{C:%{!E:%eGNU C does not support -C without using -E}}\
  783. ***************
  784. *** 551,557 ****
  785.           %{traditional-cpp:-traditional}\
  786.       %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C\
  787.           %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
  788. !    "%{!M:%{!MM:%{!E:%{!S:as %{R} %{j} %{J} %{h} %{d2} %a %Y\
  789.                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  790.               %{!pipe:%g.s} %A\n }}}}"},
  791.     /* Mark end of table */
  792. --- 575,581 ----
  793.           %{traditional-cpp:-traditional}\
  794.       %{g*} %{W*} %{w} %{pedantic*} %{H} %{d*} %C\
  795.           %i %{!M:%{!MM:%{!E:%{!pipe:%g.s}}}}%{E:%W{o*}}%{M:%W{o*}}%{MM:%W{o*}} |\n",
  796. !    "%{!M:%{!MM:%{!E:%{!S:as %{v} %{R} %{j} %{J} %{h} %{d2} %a %Y\
  797.                       %{c:%W{o*}%{!o*:-o %w%b.o}}%{!c:-o %d%w%u.o}\
  798.               %{!pipe:%g.s} %A\n }}}}"},
  799.     /* Mark end of table */
  800. ***************
  801. *** 565,570 ****
  802. --- 589,603 ----
  803.   
  804.   /* Here is the spec for running the linker, after compiling all files.  */
  805.   
  806. + #if (defined(CROSSATARI) || defined(atarist) || defined(atariminix))
  807. + static char *link_command_spec = 
  808. +  "%{!c:%{!M*:%{!E:%{!S:ld %X %{v} %{G} %{o*} %l\
  809. +  %{A} %{d} %{e*} %{N} %{n} %{r} %{s} %{S} %{T*} %{t} %{u*} %{X} %{x} %{z}\
  810. +  %{y*} %{!nostdlib:%S} \
  811. +  %{L*} %o %{!nostdlib:%s %L}\n }}}}";
  812. + 
  813. + #else
  814. + 
  815.   #ifdef LINK_LIBGCC_SPECIAL
  816.   /* Have gcc do the search for libgcc.a.  */
  817.   /* -u* was put back because both BSD and SysV seem to support it.  */
  818. ***************
  819. *** 583,588 ****
  820. --- 616,622 ----
  821.               %{!A:%{!nostdlib:%S}} %{static:}\
  822.               %{L*} %D %o %{!nostdlib:-lgcc %L -lgcc %{!A:%E}}\n }}}}}";
  823.   #endif
  824. + #endif
  825.   
  826.   /* A vector of options to give to the linker.
  827.      These options are accumulated by -Xlinker and -Wl,
  828. ***************
  829. *** 596,601 ****
  830. --- 630,636 ----
  831.   static int n_assembler_options;
  832.   static char **assembler_options;
  833.   
  834. + #if (!(defined(atarist) || defined(CROSSATARI) || defined(atariminix)))
  835.   /* Read compilation specs from a file named FILENAME,
  836.      replacing the default ones.
  837.   
  838. ***************
  839. *** 734,739 ****
  840. --- 769,775 ----
  841.   
  842.     return p;
  843.   }
  844. + #endif /* ataris */
  845.   
  846.   /* Structure to keep track of the specs that have been defined so far.  These
  847.      are accessed using %(specname) or %[specname] in a compiler or link spec. */
  848. ***************
  849. *** 838,843 ****
  850. --- 874,886 ----
  851.   /* Name with which this program was invoked.  */
  852.   
  853.   static char *programname;
  854. + 
  855. + #ifdef atarist
  856. + /* Flag indicating, that stderr should be redirected for the child
  857. +    processes */
  858. + 
  859. + unsigned char zflag;
  860. + #endif
  861.   
  862.   /* Structures to keep track of prefixes to try when looking for files. */
  863.   
  864. ***************
  865. *** 1094,1102 ****
  866.   static void
  867.   choose_temp_base ()
  868.   {
  869. -   char *base = getenv ("TMPDIR");
  870.     int len;
  871.   
  872.     if (base == (char *)0)
  873.       {
  874.   #ifdef P_tmpdir
  875. --- 1137,1162 ----
  876.   static void
  877.   choose_temp_base ()
  878.   {
  879.     int len;
  880. + #if (!(defined(atarist) || defined(atariminix)))
  881. +   char *base = getenv ("TMPDIR");
  882. + #else
  883. +   char *base = getenv ("TEMP");
  884.   
  885. +   if(base == (char *)0)
  886. +   {
  887. +       base = getenv("TMPDIR");
  888. +       if(base == (char *)0)
  889. +       base = getenv("TMP");
  890. +   }
  891. +   if(base != (char *)0)
  892. +   {
  893. +       char *newbase = alloca(FILENAME_MAX);
  894. +       dos2unx(base,newbase);
  895. +       base = newbase;
  896. +   }
  897. + #endif
  898. + 
  899.     if (base == (char *)0)
  900.       {
  901.   #ifdef P_tmpdir
  902. ***************
  903. *** 1115,1121 ****
  904.     len = strlen (base);
  905.     temp_filename = xmalloc (len + sizeof("/ccXXXXXX"));
  906.     strcpy (temp_filename, base);
  907. !   if (len > 0 && temp_filename[len-1] != '/')
  908.       temp_filename[len++] = '/';
  909.     strcpy (temp_filename + len, "ccXXXXXX");
  910.   
  911. --- 1175,1185 ----
  912.     len = strlen (base);
  913.     temp_filename = xmalloc (len + sizeof("/ccXXXXXX"));
  914.     strcpy (temp_filename, base);
  915. !   if (len > 0 && (temp_filename[len-1] != '/' 
  916. ! #ifdef atarist
  917. !           || temp_filename[len-1] != '\\'
  918. ! #endif
  919. !            ))
  920.       temp_filename[len++] = '/';
  921.     strcpy (temp_filename + len, "ccXXXXXX");
  922.   
  923. ***************
  924. *** 1132,1137 ****
  925. --- 1196,1202 ----
  926.      use come from an obstack, we don't have to worry about allocating
  927.      space for them.  */
  928.   
  929. + #if (!(defined(CROSSATARI) || defined(atarist)))
  930.   #ifndef HAVE_PUTENV
  931.   
  932.   putenv (str)
  933. ***************
  934. *** 1226,1231 ****
  935. --- 1291,1297 ----
  936.     obstack_grow (&collect_obstack, "\0", 1);
  937.     putenv (obstack_finish (&collect_obstack));
  938.   }
  939. + #endif /* ataris */
  940.   
  941.   
  942.   /* Search for NAME using the prefix list PREFIXES.  MODE is passed to
  943. ***************
  944. *** 1501,1506 ****
  945. --- 1567,1573 ----
  946.   
  947.   #else /* not __MSDOS__ */
  948.   
  949. + #ifndef atarist
  950.   static int
  951.   pexecute (search_flag, program, argv, not_last)
  952.        int search_flag;
  953. ***************
  954. *** 1589,1594 ****
  955. --- 1656,1662 ----
  956.       }
  957.   }
  958.   
  959. + #endif /* not atarist */
  960.   #endif /* not __MSDOS__ */
  961.   #else /* not OS2 */
  962.   
  963. ***************
  964. *** 1619,1634 ****
  965.       {
  966.         char *prog;        /* program name.  */
  967.         char **argv;        /* vector of args.  */
  968.         int pid;            /* pid of process for this command.  */
  969.       };
  970.   
  971.     struct command *commands;    /* each command buffer with above info.  */
  972.   
  973.     /* Count # of piped commands.  */
  974.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  975.       if (strcmp (argbuf[i], "|") == 0)
  976.         n_commands++;
  977. ! 
  978.     /* Get storage for each command.  */
  979.     commands
  980.       = (struct command *) alloca (n_commands * sizeof (struct command));
  981. --- 1687,1707 ----
  982.       {
  983.         char *prog;        /* program name.  */
  984.         char **argv;        /* vector of args.  */
  985. + #ifndef atarist
  986.         int pid;            /* pid of process for this command.  */
  987. + #endif
  988.       };
  989.   
  990.     struct command *commands;    /* each command buffer with above info.  */
  991.   
  992. + #ifndef atarist
  993.     /* Count # of piped commands.  */
  994.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  995.       if (strcmp (argbuf[i], "|") == 0)
  996.         n_commands++;
  997. ! #else
  998. !   n_commands = 1;
  999. ! #endif
  1000.     /* Get storage for each command.  */
  1001.     commands
  1002.       = (struct command *) alloca (n_commands * sizeof (struct command));
  1003. ***************
  1004. *** 1643,1648 ****
  1005. --- 1716,1722 ----
  1006.     if (string)
  1007.       commands[0].argv[0] = string;
  1008.   
  1009. + #ifndef atarist
  1010.     for (n_commands = 1, i = 0; i < argbuf_index; i++)
  1011.       if (strcmp (argbuf[i], "|") == 0)
  1012.         {                /* each command.  */
  1013. ***************
  1014. *** 1657,1662 ****
  1015. --- 1731,1739 ----
  1016.         commands[n_commands].argv[0] = string;
  1017.       n_commands++;
  1018.         }
  1019. + #else
  1020. +   n_commands = 1;
  1021. + #endif
  1022.   
  1023.     argbuf[argbuf_index] = 0;
  1024.   
  1025. ***************
  1026. *** 1672,1680 ****
  1027. --- 1749,1759 ----
  1028.         for (j = commands[i].argv; *j; j++)
  1029.           fprintf (stderr, " %s", *j);
  1030.   
  1031. + #ifndef atarist
  1032.         /* Print a pipe symbol after all but the last command.  */
  1033.         if (i + 1 != n_commands)
  1034.           fprintf (stderr, " |");
  1035. + #endif
  1036.         fprintf (stderr, "\n");
  1037.       }
  1038.         fflush (stderr);
  1039. ***************
  1040. *** 1689,1699 ****
  1041. --- 1768,1780 ----
  1042.   #endif /* DEBUG */
  1043.       }
  1044.   
  1045. + #ifndef atarist
  1046.     /* Run each piped subprocess.  */
  1047.   
  1048.     last_pipe_input = STDIN_FILE_NO;
  1049.     for (i = 0; i < n_commands; i++)
  1050.       {
  1051. + #ifndef atariminix
  1052.         char *string = commands[i].argv[0];
  1053.   
  1054.         commands[i].pid = pexecute (string != commands[i].prog,
  1055. ***************
  1056. *** 1700,1705 ****
  1057. --- 1781,1794 ----
  1058.                     string, commands[i].argv,
  1059.                     i + 1 < n_commands);
  1060.   
  1061. + #else
  1062. +       extern int execv();
  1063. +       char *string = commands[i].argv[0];
  1064. + 
  1065. +       commands[i].pid = pexecute (execv,
  1066. +                   string, commands[i].argv,
  1067. +                   i + 1 < n_commands);
  1068. + #endif
  1069.         if (string != commands[i].prog)
  1070.       free (string);
  1071.       }
  1072. ***************
  1073. *** 1746,1751 ****
  1074. --- 1835,1885 ----
  1075.         }
  1076.       return ret_code;
  1077.     }
  1078. + #else /* atarist */
  1079. +  {
  1080. +      register int iii;
  1081. +      int errfd, oldfd;
  1082. +      char **j;
  1083. + 
  1084. +      execution_count++;
  1085. + 
  1086. +      if (zflag)
  1087. +        {
  1088. +      errfd = Fopen("compile.err", 2);
  1089. +      if (errfd < __SMALLEST_VALID_HANDLE)
  1090. +        errfd = Fcreate("compile.err", 0);
  1091. +      else
  1092. +        Fseek(0L, errfd, 2);
  1093. +      if (errfd >= __SMALLEST_VALID_HANDLE)
  1094. +        {
  1095. +          oldfd = Fdup (2);
  1096. +          Fforce(2, errfd);
  1097. +        }
  1098. +      else
  1099. +        {
  1100. +          error("cannot open %s", "compile.err");
  1101. +          zflag = 0;        /* no redirection */
  1102. +        }
  1103. +        }
  1104. +      for (i = 0; i < n_commands ; i++)
  1105. +      {
  1106. +          j = commands[i].argv;
  1107. +          iii = spawnve(0, j[0], j, NULL);
  1108. +      if(iii != 0)
  1109. +          break;
  1110. +      }
  1111. +      if (zflag)
  1112. +        {
  1113. +      Fforce(2, oldfd);
  1114. +      Fclose(oldfd);
  1115. +      Fclose(errfd);
  1116. +        }
  1117. +      if (iii != 0)
  1118. +        return -1;
  1119. +      else
  1120. +        return 0;
  1121. +  }
  1122. + #endif /* atarist */  
  1123.   }
  1124.   
  1125.   /* Find all the switches given to us
  1126. ***************
  1127. *** 1809,1814 ****
  1128. --- 1943,1949 ----
  1129.   
  1130.     /* Set up the default search paths.  */
  1131.   
  1132. + #ifndef CROSSATARI
  1133.     if (gcc_exec_prefix)
  1134.       {
  1135.         add_prefix (&exec_prefix, gcc_exec_prefix, 0, 0, NULL_PTR);
  1136. ***************
  1137. *** 1885,1890 ****
  1138. --- 2020,2026 ----
  1139.           endp++;
  1140.       }
  1141.       }
  1142. + #endif /* CROSSATARI */
  1143.   
  1144.     /* Use LPATH like LIBRARY_PATH (for the CMU build program).  */
  1145.     temp = getenv ("LPATH");
  1146. ***************
  1147. *** 2092,2097 ****
  1148. --- 2228,2239 ----
  1149.             n_switches++;
  1150.             break;
  1151.           }
  1152. + #ifdef atarist
  1153. +         case 'z':    /* redirect stderr to a file */
  1154. +           zflag++;
  1155. +           n_switches++;
  1156. +           break;
  1157. + #endif
  1158.           default:
  1159.             n_switches++;
  1160.   
  1161. ***************
  1162. *** 2111,2121 ****
  1163. --- 2253,2274 ----
  1164.        (such as cpp) rather than those of the host system.  */
  1165.     /* Use 2 as fourth arg meaning try just the machine as a suffix,
  1166.        as well as trying the machine and the version.  */
  1167. + #if (defined(atarist) || defined(CROSSATARI) || defined(WEIRD))
  1168. + /* NB defined(WEIRD) should not really be there, its only for my weird setup */
  1169. +   /* We are not using machine_suffix here, so do not make */
  1170. +   /* these prefixes available only when we have one       */
  1171. +   add_prefix (&exec_prefix, standard_exec_prefix, 0, 0, NULL_PTR);
  1172. +   add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 0, NULL_PTR);
  1173. + 
  1174. +   add_prefix (&startfile_prefix, standard_exec_prefix, 0, 0, NULL_PTR);
  1175. +   add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 0, NULL_PTR);
  1176. + #else
  1177.     add_prefix (&exec_prefix, standard_exec_prefix, 0, 2, NULL_PTR);
  1178.     add_prefix (&exec_prefix, standard_exec_prefix_1, 0, 2, NULL_PTR);
  1179.   
  1180.     add_prefix (&startfile_prefix, standard_exec_prefix, 0, 1, NULL_PTR);
  1181.     add_prefix (&startfile_prefix, standard_exec_prefix_1, 0, 1, NULL_PTR);
  1182. + #endif /* (defined(atarist) || defined(CROSSATARI)) */
  1183.   
  1184.     /* More prefixes are enabled in main, after we read the specs file
  1185.        and determine whether this is cross-compilation or not.  */
  1186. ***************
  1187. *** 2283,2288 ****
  1188. --- 2436,2450 ----
  1189.      search dirs for it.  */
  1190.   static int this_is_library_file;
  1191.   
  1192. + #ifdef atarist
  1193. + /* I don't know why this is necessary.  Recursive calls to do_spec_1
  1194. +    end up ignoring the error code from calls to execute().  That causes
  1195. +    do_spec to get a 0 return value, and do_spec_1("\n"), which causes the
  1196. +    command to get executed again.
  1197. + */
  1198. + int execute_return_error = 0;
  1199. + #endif
  1200. + 
  1201.   /* Process the spec SPEC and run the commands specified therein.
  1202.      Returns 0 if the spec is successfully processed; -1 if failed.  */
  1203.   
  1204. ***************
  1205. *** 2302,2311 ****
  1206. --- 2464,2482 ----
  1207.   
  1208.     /* Force out any unfinished command.
  1209.        If -pipe, this forces out the last command if it ended in `|'.  */
  1210. + #ifdef atarist
  1211. +   if (!value && execute_return_error)
  1212. +     {
  1213. +     value = execute_return_error;
  1214. +     execute_return_error = 0;
  1215. +     }
  1216. + #endif
  1217.     if (value == 0)
  1218.       {
  1219. + #ifndef atarist
  1220.         if (argbuf_index > 0 && !strcmp (argbuf[argbuf_index - 1], "|"))
  1221.       argbuf_index--;
  1222. + #endif
  1223.   
  1224.         if (argbuf_index > 0)
  1225.       value = execute ();
  1226. ***************
  1227. *** 2342,2347 ****
  1228. --- 2513,2569 ----
  1229.          Otherwise, NL, SPC, TAB and % are special.  */
  1230.       switch (inswitch ? 'a' : c)
  1231.         {
  1232. + #if (defined(atarist) || defined(CROSSATARI))
  1233. + /* this stuff added by jrd.  if see '$', expect name of env var, delimited
  1234. +    by '$'.  Find it's value, and subst it in.
  1235. + 
  1236. +    modified by ERS to only collect things that look like names; this
  1237. +    saves e.g. the -$ arg. to cpp from getting munged */
  1238. + 
  1239. +       case '$':
  1240. +       {
  1241. +     char varname[32];        /* should be enough */
  1242. +     char * value;            /* deciphered value string */
  1243. +     char *temp;
  1244. +     int i;
  1245. +     extern char *getenv(), *index();
  1246. +     
  1247. +     for (i = 0 ; ((c = *p) != '$') && isalnum(c) && i < 31 ; i++, p++)
  1248. +         varname[i] = c;
  1249. +     varname[i] = '\0';
  1250. +     if (strlen(varname) > 0) /* ++jrb fix */
  1251. +     {
  1252. +                  ++p;    /* skip trailing '$' */
  1253. +         value = getenv(varname); /* ++jrb fix */
  1254. +         if (value)
  1255. +         { /* if value is a path, only consider 1'st component */
  1256. + #ifdef atarist
  1257. +             if((temp = index(value, ',')) == NULL)
  1258. +                 temp = index(value, ';');
  1259. + #else
  1260. +             temp = index(value, ':');
  1261. + #endif
  1262. +             if(temp != NULL)
  1263. +             {
  1264. +                 char *t = (char *) alloca(strlen(value) + 1);
  1265. +                 strcpy(t, value);
  1266. +                 t[temp-value] = '\0';
  1267. +                 do_spec_1(t, 0);
  1268. +             }
  1269. +             else
  1270. +                 do_spec_1(value, 0);
  1271. +         }
  1272. +             else
  1273. +             do_spec_1(".", 0);    /* a compleat kludge... */
  1274. +     }
  1275. +         else
  1276. +         {
  1277. +              obstack_1grow(&obstack, '$');
  1278. +              arg_going = 1;
  1279. +         }
  1280. +       }
  1281. +      break;
  1282. + #endif /* atarist */
  1283.         case '\n':
  1284.       /* End of line: finish any pending argument,
  1285.          then run the pending command if one has been started.  */
  1286. ***************
  1287. *** 2379,2384 ****
  1288. --- 2601,2610 ----
  1289.       if (argbuf_index > 0)
  1290.         {
  1291.           int value = execute ();
  1292. + #ifdef atarist
  1293. +         if (!execute_return_error)
  1294. +             execute_return_error = value;
  1295. + #endif
  1296.           if (value)
  1297.             return value;
  1298.         }
  1299. ***************
  1300. *** 2923,2935 ****
  1301. --- 3149,3169 ----
  1302.           break;
  1303.   
  1304.         default:
  1305. + #if 1 /* atarist */
  1306. +         fprintf(stderr, "Bogus char '%c' found at pos %d of spec '%s'\n",
  1307. +         c, (p - spec - 1), spec);
  1308. + #endif
  1309.           abort ();
  1310.         }
  1311.       break;
  1312.   
  1313. + #ifndef atarist
  1314. +       /* on the atari it is important to preserve backslash in spec */
  1315. +       /* so just let it go into default case */
  1316.         case '\\':
  1317.       /* Backslash: treat next character as ordinary.  */
  1318.       c = *p++;
  1319. + #endif
  1320.   
  1321.       /* fall through */
  1322.         default:
  1323. ***************
  1324. *** 3197,3202 ****
  1325. --- 3431,3437 ----
  1326.   
  1327.   /* On fatal signals, delete all the temporary files.  */
  1328.   
  1329. + #ifndef atarist
  1330.   static void
  1331.   fatal_error (signum)
  1332.        int signum;
  1333. ***************
  1334. *** 3208,3213 ****
  1335. --- 3443,3449 ----
  1336.        so its normal effect occurs.  */
  1337.     kill (getpid (), signum);
  1338.   }
  1339. + #endif
  1340.   
  1341.   int
  1342.   main (argc, argv)
  1343. ***************
  1344. *** 3222,3227 ****
  1345. --- 3458,3468 ----
  1346.     char *explicit_link_files;
  1347.     char *specs_file;
  1348.   
  1349. + #ifdef atarist
  1350. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  1351. + /*  _malloczero(1); */     /* zero mallocs by default */
  1352. +   programname = "gcc";
  1353. + #else  
  1354.     programname = argv[0];
  1355.   
  1356.     if (signal (SIGINT, SIG_IGN) != SIG_IGN)
  1357. ***************
  1358. *** 3234,3239 ****
  1359. --- 3475,3481 ----
  1360.     if (signal (SIGPIPE, SIG_IGN) != SIG_IGN)
  1361.       signal (SIGPIPE, fatal_error);
  1362.   #endif
  1363. + #endif /* atarist */
  1364.   
  1365.     argbuf_length = 10;
  1366.     argbuf = (char **) xmalloc (argbuf_length * sizeof (char *));
  1367. ***************
  1368. *** 3240,3245 ****
  1369. --- 3482,3488 ----
  1370.   
  1371.     obstack_init (&obstack);
  1372.   
  1373. + #if (!(defined(atarist) || defined(CROSSATARI)))
  1374.     /* Set up to remember the pathname of gcc and any options
  1375.        needed for collect.  */
  1376.     obstack_init (&collect_obstack);
  1377. ***************
  1378. *** 3246,3251 ****
  1379. --- 3489,3495 ----
  1380.     obstack_grow (&collect_obstack, "COLLECT_GCC=", sizeof ("COLLECT_GCC=")-1);
  1381.     obstack_grow (&collect_obstack, programname, strlen (programname)+1);
  1382.     putenv (obstack_finish (&collect_obstack));
  1383. + #endif
  1384.   
  1385.     /* Choose directory for temp files.  */
  1386.   
  1387. ***************
  1388. *** 3257,3262 ****
  1389. --- 3501,3515 ----
  1390.   
  1391.     process_command (argc, argv);
  1392.   
  1393. + #if (defined(atarist) || defined(CROSSATARI))
  1394. +   {
  1395. +     char *temp;
  1396. +     
  1397. +     if((temp = getenv ("GCCEXEC")))
  1398. +     add_prefix (&exec_prefix, temp, 0, 0, 0);
  1399. +   }
  1400. + #endif
  1401. +   
  1402.     /* Initialize the vector of specs to just the default.
  1403.        This means one element containing 0s, as a terminator.  */
  1404.   
  1405. ***************
  1406. *** 3264,3269 ****
  1407. --- 3517,3526 ----
  1408.     bcopy (default_compilers, compilers, sizeof default_compilers);
  1409.     n_compilers = n_default_compilers;
  1410.   
  1411. + 
  1412. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  1413. +   specs_file = 0;
  1414. + #else
  1415.     /* Read specs from a file if there is one.  */
  1416.   
  1417.     machine_suffix = concat (spec_machine, "/", concat (spec_version, "/", ""));
  1418. ***************
  1419. *** 3273,3278 ****
  1420. --- 3530,3536 ----
  1421.     /* Read the specs file unless it is a default one.  */
  1422.     if (specs_file != 0 && strcmp (specs_file, "specs"))
  1423.       read_specs (specs_file);
  1424. + #endif
  1425.   
  1426.     /* If not cross-compiling, look for startfiles in the standard places.  */
  1427.     /* The fact that these are done here, after reading the specs file,
  1428. ***************
  1429. *** 3325,3331 ****
  1430. --- 3583,3595 ----
  1431.   
  1432.     if (verbose_flag)
  1433.       {
  1434. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  1435. + #include "PatchLev.h"
  1436. +       fprintf (stderr, "gcc-atariST version %s Patchlevel %s\n",
  1437. +            version_string, PatchLevel);
  1438. + #else
  1439.         fprintf (stderr, "gcc version %s\n", version_string);
  1440. + #endif
  1441.         if (n_infiles == 0)
  1442.       exit (0);
  1443.       }
  1444. ***************
  1445. *** 3373,3379 ****
  1446. --- 3637,3648 ----
  1447.   
  1448.         input_basename = input_filename;
  1449.         for (p = input_filename; *p; p++)
  1450. + #ifdef atarist
  1451. +         if (((*p == '/') || (*p == '\\')) && (*(p-1) != ':'))
  1452. +             /* allow both '\' and '/' with  our new lib */
  1453. + #else
  1454.           if (*p == '/')
  1455. + #endif
  1456.             input_basename = p + 1;
  1457.   
  1458.         /* Find a suffix starting with the last period,
  1459. ***************
  1460. *** 3436,3441 ****
  1461. --- 3705,3711 ----
  1462.         int i;
  1463.         int first_time;
  1464.   
  1465. + #if (!(defined(atarist) || defined(CROSSATARI)))
  1466.         /* Rebuild the COMPILER_PATH and LIBRARY_PATH environment variables
  1467.        for collect.  */
  1468.         putenv_from_prefixes (&exec_prefix, "COMPILER_PATH=");
  1469. ***************
  1470. *** 3466,3471 ****
  1471. --- 3736,3742 ----
  1472.       }
  1473.         obstack_grow (&collect_obstack, "\0", 1);
  1474.         putenv (obstack_finish (&collect_obstack));
  1475. + #endif
  1476.   
  1477.         value = do_spec (link_command_spec);
  1478.         if (value < 0)
  1479. *** 1.6    1992/11/07 04:57:45
  1480. --- getpwd.c    1992/11/08 00:49:15
  1481. ***************
  1482. *** 14,20 ****
  1483.      BSD systems) now provides getcwd as called for by POSIX.  Allow for
  1484.      the few exceptions to the general rule here.  */
  1485.   
  1486. ! #if !(defined (POSIX) || defined (USG) || defined (VMS))
  1487.   #include <sys/param.h>
  1488.   extern char *getwd ();
  1489.   #define getcwd(buf,len) getwd(buf)
  1490. --- 14,20 ----
  1491.      BSD systems) now provides getcwd as called for by POSIX.  Allow for
  1492.      the few exceptions to the general rule here.  */
  1493.   
  1494. ! #if !(defined (POSIX) || defined (USG) || defined (VMS) || defined(atarist) || defined(CROSSHPUX))
  1495.   #include <sys/param.h>
  1496.   extern char *getwd ();
  1497.   #define getcwd(buf,len) getwd(buf)
  1498. ***************
  1499. *** 48,58 ****
  1500.     if (!p && !(errno = failure_errno))
  1501.       {
  1502.         if (! ((p = getenv ("PWD")) != 0
  1503.            && *p == '/'
  1504.            && stat (p, &pwdstat) == 0
  1505.            && stat (".", &dotstat) == 0
  1506.            && dotstat.st_ino == pwdstat.st_ino
  1507. !          && dotstat.st_dev == pwdstat.st_dev))
  1508.   
  1509.       /* The shortcut didn't work.  Try the slow, ``sure'' way.  */
  1510.       for (s = GUESSPATHLEN;  ! getcwd (p = xmalloc (s), s);  s *= 2)
  1511. --- 48,61 ----
  1512.     if (!p && !(errno = failure_errno))
  1513.       {
  1514.         if (! ((p = getenv ("PWD")) != 0
  1515. + #ifndef atarist
  1516.            && *p == '/'
  1517.            && stat (p, &pwdstat) == 0
  1518.            && stat (".", &dotstat) == 0
  1519.            && dotstat.st_ino == pwdstat.st_ino
  1520. !          && dotstat.st_dev == pwdstat.st_dev
  1521. ! #endif
  1522. !          ))
  1523.   
  1524.       /* The shortcut didn't work.  Try the slow, ``sure'' way.  */
  1525.       for (s = GUESSPATHLEN;  ! getcwd (p = xmalloc (s), s);  s *= 2)
  1526. *** 1.13    1992/11/07 04:57:45
  1527. --- toplev.c    1992/11/08 00:50:00
  1528. ***************
  1529. *** 31,37 ****
  1530.   
  1531.   #include <sys/stat.h>
  1532.   
  1533. ! #ifdef USG
  1534.   #undef FLOAT
  1535.   #include <sys/param.h>
  1536.   /* This is for hpux.  It is a real screw.  They should change hpux.  */
  1537. --- 31,37 ----
  1538.   
  1539.   #include <sys/stat.h>
  1540.   
  1541. ! #if defined(USG) || defined(CROSSHPUX)
  1542.   #undef FLOAT
  1543.   #include <sys/param.h>
  1544.   /* This is for hpux.  It is a real screw.  They should change hpux.  */
  1545. ***************
  1546. *** 41,49 ****
  1547. --- 41,57 ----
  1548.   #undef FFS  /* Some systems define this in param.h.  */
  1549.   #else
  1550.   #ifndef VMS
  1551. + #if (!(defined(atarist) || defined(atariminix)))
  1552.   #include <sys/time.h>
  1553.   #include <sys/resource.h>
  1554. + #endif /* !(atarist || atariminix) */
  1555. + #endif
  1556.   #endif
  1557. + 
  1558. + #ifdef atariminix
  1559. + #include <sys/times.h>
  1560. + /* #include <minix/const.h>, avoid dragging this in */
  1561. + #define HZ 60    /* this is the only thing needed from minix/const.h */
  1562.   #endif
  1563.   
  1564.   #include "input.h"
  1565. ***************
  1566. *** 57,62 ****
  1567. --- 65,75 ----
  1568.   #include "xcoffout.h"
  1569.   #endif
  1570.   
  1571. + #ifdef atarist
  1572. + long _stksize = -1L;    /* for all sizes of ST's */
  1573. +     /* -1 means malloc from own heap and keep all  of memory */
  1574. + #endif /* atarist */
  1575. + 
  1576.   #ifdef VMS
  1577.   /* The extra parameters substantially improve the I/O performance.  */
  1578.   static FILE *
  1579. ***************
  1580. *** 739,745 ****
  1581.   int
  1582.   get_run_time ()
  1583.   {
  1584. ! #ifdef USG
  1585.     struct tms tms;
  1586.   #else
  1587.   #ifndef VMS
  1588. --- 752,761 ----
  1589.   int
  1590.   get_run_time ()
  1591.   {
  1592. ! #ifdef atarist
  1593. !   long now;
  1594. ! #else
  1595. ! #if (defined(USG) || defined(atariminix) || defined(CROSSHPUX))
  1596.     struct tms tms;
  1597.   #else
  1598.   #ifndef VMS
  1599. ***************
  1600. *** 754,764 ****
  1601.       } vms_times;
  1602.   #endif
  1603.   #endif
  1604.   
  1605.     if (quiet_flag)
  1606.       return 0;
  1607.   
  1608. ! #ifdef USG
  1609.     times (&tms);
  1610.     return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  1611.   #else
  1612. --- 770,784 ----
  1613.       } vms_times;
  1614.   #endif
  1615.   #endif
  1616. + #endif
  1617.   
  1618.     if (quiet_flag)
  1619.       return 0;
  1620.   
  1621. ! #ifdef atarist
  1622. !   return(time(NULL) * 1000000);
  1623. ! #else
  1624. ! #if (defined(USG) || defined(atariminix) || defined(CROSSHPUX))
  1625.     times (&tms);
  1626.     return (tms.tms_utime + tms.tms_stime) * (1000000 / HZ);
  1627.   #else
  1628. ***************
  1629. *** 771,776 ****
  1630. --- 791,797 ----
  1631.     return (vms_times.proc_user_time + vms_times.proc_system_time) * 10000;
  1632.   #endif
  1633.   #endif
  1634. + #endif
  1635.   }
  1636.   
  1637.   #define TIMEVAR(VAR, BODY)    \
  1638. ***************
  1639. *** 1407,1412 ****
  1640. --- 1428,1434 ----
  1641.     longjmp (float_handler, 1);
  1642.   }
  1643.   
  1644. + #ifndef atarist
  1645.   /* Handler for SIGPIPE.  */
  1646.   
  1647.   static void
  1648. ***************
  1649. *** 1416,1421 ****
  1650. --- 1438,1444 ----
  1651.   {
  1652.     fatal ("output pipe has been closed");
  1653.   }
  1654. + #endif
  1655.   
  1656.   /* Strip off a legitimate source ending from the input string NAME of
  1657.      length LEN. */
  1658. ***************
  1659. *** 1447,1452 ****
  1660. --- 1470,1476 ----
  1661.       name[len - 4] = 0;
  1662.   }
  1663.   
  1664. + #ifdef SYSV
  1665.   /* Output a file name in the form wanted by System V.  */
  1666.   
  1667.   void
  1668. ***************
  1669. *** 1475,1480 ****
  1670. --- 1499,1505 ----
  1671.   #endif
  1672.   #endif
  1673.   }
  1674. + #endif
  1675.   
  1676.   /* Compile an entire file of output from cpp, named NAME.
  1677.      Write a file of assembly output and various debugging dumps.  */
  1678. ***************
  1679. *** 1574,1580 ****
  1680. --- 1599,1609 ----
  1681.       {
  1682.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  1683.         strcpy (dumpname, dump_base_name);
  1684. + #ifndef atarist
  1685.         strcat (dumpname, ".jump");
  1686. + #else
  1687. +       strcat (dumpname, ".jmp");
  1688. + #endif
  1689.         jump_opt_dump_file = fopen (dumpname, "w");
  1690.         if (jump_opt_dump_file == 0)
  1691.       pfatal_with_name (dumpname);
  1692. ***************
  1693. *** 1596,1602 ****
  1694. --- 1625,1635 ----
  1695.       {
  1696.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  1697.         strcpy (dumpname, dump_base_name);
  1698. + #ifndef atarist
  1699.         strcat (dumpname, ".loop");
  1700. + #else
  1701. +       strcat (dumpname, ".lop");
  1702. + #endif
  1703.         loop_dump_file = fopen (dumpname, "w");
  1704.         if (loop_dump_file == 0)
  1705.       pfatal_with_name (dumpname);
  1706. ***************
  1707. *** 1607,1613 ****
  1708. --- 1640,1650 ----
  1709.       {
  1710.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  1711.         strcpy (dumpname, dump_base_name);
  1712. + #ifndef atarist
  1713.         strcat (dumpname, ".cse2");
  1714. + #else
  1715. +       strcat (dumpname, ".cs2");
  1716. + #endif
  1717.         cse2_dump_file = fopen (dumpname, "w");
  1718.         if (cse2_dump_file == 0)
  1719.       pfatal_with_name (dumpname);
  1720. ***************
  1721. *** 1618,1624 ****
  1722. --- 1655,1665 ----
  1723.       {
  1724.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  1725.         strcpy (dumpname, dump_base_name);
  1726. + #ifndef atarist
  1727.         strcat (dumpname, ".flow");
  1728. + #else
  1729. +       strcat (dumpname, ".flo");
  1730. + #endif
  1731.         flow_dump_file = fopen (dumpname, "w");
  1732.         if (flow_dump_file == 0)
  1733.       pfatal_with_name (dumpname);
  1734. ***************
  1735. *** 1629,1635 ****
  1736. --- 1670,1680 ----
  1737.       {
  1738.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
  1739.         strcpy (dumpname, dump_base_name);
  1740. + #ifndef atarist
  1741.         strcat (dumpname, ".combine");
  1742. + #else
  1743. +       strcat (dumpname, ".cmb");
  1744. + #endif
  1745.         combine_dump_file = fopen (dumpname, "w");
  1746.         if (combine_dump_file == 0)
  1747.       pfatal_with_name (dumpname);
  1748. ***************
  1749. *** 1640,1646 ****
  1750. --- 1685,1695 ----
  1751.       {
  1752.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
  1753.         strcpy (dumpname, dump_base_name);
  1754. + #ifndef atarist
  1755.         strcat (dumpname, ".sched");
  1756. + #else
  1757. +       strcat (dumpname, ".sch");
  1758. + #endif
  1759.         sched_dump_file = fopen (dumpname, "w");
  1760.         if (sched_dump_file == 0)
  1761.       pfatal_with_name (dumpname);
  1762. ***************
  1763. *** 1651,1657 ****
  1764. --- 1700,1710 ----
  1765.       {
  1766.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  1767.         strcpy (dumpname, dump_base_name);
  1768. + #ifndef atarist
  1769.         strcat (dumpname, ".lreg");
  1770. + #else
  1771. +       strcat (dumpname, ".lrg");
  1772. + #endif
  1773.         local_reg_dump_file = fopen (dumpname, "w");
  1774.         if (local_reg_dump_file == 0)
  1775.       pfatal_with_name (dumpname);
  1776. ***************
  1777. *** 1662,1668 ****
  1778. --- 1715,1725 ----
  1779.       {
  1780.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 6);
  1781.         strcpy (dumpname, dump_base_name);
  1782. + #ifndef atarist
  1783.         strcat (dumpname, ".greg");
  1784. + #else
  1785. +       strcat (dumpname, ".grg");
  1786. + #endif
  1787.         global_reg_dump_file = fopen (dumpname, "w");
  1788.         if (global_reg_dump_file == 0)
  1789.       pfatal_with_name (dumpname);
  1790. ***************
  1791. *** 1673,1679 ****
  1792. --- 1730,1740 ----
  1793.       {
  1794.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 8);
  1795.         strcpy (dumpname, dump_base_name);
  1796. + #ifndef atarist
  1797.         strcat (dumpname, ".sched2");
  1798. + #else
  1799. +       strcat (dumpname, ".sc2");
  1800. + #endif
  1801.         sched2_dump_file = fopen (dumpname, "w");
  1802.         if (sched2_dump_file == 0)
  1803.       pfatal_with_name (dumpname);
  1804. ***************
  1805. *** 1684,1690 ****
  1806. --- 1745,1755 ----
  1807.       {
  1808.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 7);
  1809.         strcpy (dumpname, dump_base_name);
  1810. + #ifndef atarist
  1811.         strcat (dumpname, ".jump2");
  1812. + #else
  1813. +       strcat (dumpname, ".jp2");
  1814. + #endif
  1815.         jump2_opt_dump_file = fopen (dumpname, "w");
  1816.         if (jump2_opt_dump_file == 0)
  1817.       pfatal_with_name (dumpname);
  1818. ***************
  1819. *** 1708,1714 ****
  1820. --- 1773,1783 ----
  1821.       {
  1822.         register char *dumpname = (char *) xmalloc (dump_base_name_length + 10);
  1823.         strcpy (dumpname, dump_base_name);
  1824. + #ifndef atarist
  1825.         strcat (dumpname, ".stack");
  1826. + #else
  1827. +       strcat (dumpname, ".stk");
  1828. + #endif
  1829.         stack_reg_dump_file = fopen (dumpname, "w");
  1830.         if (stack_reg_dump_file == 0)
  1831.       pfatal_with_name (dumpname);
  1832. ***************
  1833. *** 2749,2760 ****
  1834. --- 2818,2839 ----
  1835.     int version_flag = 0;
  1836.     char *p;
  1837.   
  1838. + #ifdef atarist
  1839. + /* turn this on if you are going to set the TOS 1.4 dont clear heap flag */
  1840. + /*  _malloczero(1); */     /* zero mallocs by default */
  1841. + #endif  
  1842. + 
  1843.     /* save in case md file wants to emit args as a comment.  */
  1844.     save_argc = argc;
  1845.     save_argv = argv;
  1846.   
  1847.     p = argv[0] + strlen (argv[0]);
  1848. + #ifndef atarist
  1849.     while (p != argv[0] && p[-1] != '/') --p;
  1850. + #else
  1851. +   while (p != argv[0] && ((p[-1] != '/') && (p[-1] != '\\') &&
  1852. +               (p[-1] != ':'))) --p;
  1853. + #endif
  1854.     progname = p;
  1855.   
  1856.   #ifdef RLIMIT_STACK
  1857. ***************
  1858. *** 2771,2777 ****
  1859. --- 2850,2858 ----
  1860.   
  1861.     signal (SIGFPE, float_signal);
  1862.   
  1863. + #ifndef atarist
  1864.     signal (SIGPIPE, pipe_closed);
  1865. + #endif
  1866.   
  1867.     decl_printable_name = decl_name;
  1868.     lang_expand_expr = (struct rtx_def *(*)()) do_abort;
  1869. ***************
  1870. *** 2869,2874 ****
  1871. --- 2950,2965 ----
  1872.         else if (!strcmp (str, "dumpbase"))
  1873.           {
  1874.             dump_base_name = argv[++i];
  1875. + #ifdef atarist
  1876. + /* dump_base_name will typically be 'foo.c' here.  Need to truncate at the '.',
  1877. +    cause dots mean something here */
  1878. +         {
  1879. +           char * n = dump_base_name;
  1880. +           for ( ; ((*n) && (*n != '.')) ; )
  1881. +         n++;
  1882. +           *n = '\0';
  1883. +         }
  1884. + #endif
  1885.           }
  1886.         else if (str[0] == 'd')
  1887.           {
  1888. ***************
  1889. *** 3261,3267 ****
  1890. --- 3352,3364 ----
  1891.        option flags in use.  */
  1892.     if (version_flag)
  1893.       {
  1894. + #if (defined(atarist) || defined(CROSSATARI) || defined(atariminix))
  1895. + #include "PatchLev.h"
  1896. +         fprintf (stderr, "%s version %s-atariST Patchlevel %s",
  1897. +          language_string, version_string, PatchLevel);
  1898. + #else
  1899.         fprintf (stderr, "%s version %s", language_string, version_string);
  1900. + #endif
  1901.   #ifdef TARGET_VERSION
  1902.         TARGET_VERSION;
  1903.   #endif
  1904. ***************
  1905. *** 3282,3287 ****
  1906. --- 3379,3386 ----
  1907.   
  1908.     compile_file (filename);
  1909.   
  1910. + #if (!(defined(atarist) || defined(atariminix)))
  1911. + #if (!(defined(CROSSHPUX)))
  1912.   #ifndef OS2
  1913.   #ifndef VMS
  1914.     if (flag_print_mem)
  1915. ***************
  1916. *** 3300,3305 ****
  1917. --- 3399,3406 ----
  1918.       }
  1919.   #endif /* not VMS */
  1920.   #endif /* not OS2 */
  1921. + #endif
  1922. + #endif
  1923.   
  1924.     if (errorcount)
  1925.       exit (FATAL_EXIT_CODE);
  1926. ***************
  1927. *** 3411,3413 ****
  1928. --- 3512,3545 ----
  1929.   
  1930.     fprintf (stderr, "\n");
  1931.   }
  1932. + 
  1933. + #ifdef atarist
  1934. + void atari_output_filename(file, filename)
  1935. + FILE *file;
  1936. + char *filename;
  1937. + {
  1938. +     if( (!file) || (!filename) ) return;
  1939. +     for(; *filename; filename++)
  1940. +     {
  1941. +     if(*filename == '\\') putc('\\', file);
  1942. +     putc(*filename, file);
  1943. +     }
  1944. + }
  1945. + 
  1946. + #include <string.h>
  1947. + 
  1948. + char *atari_filename_nondirectory(p)
  1949. + char *p;
  1950. + {
  1951. +     char *s;
  1952. +     
  1953. +     for(s = p + strlen(p); s != p; --s)
  1954. +     {
  1955. +     if((*s == '/') || (*s == '\\'))
  1956. +         break;
  1957. +     }
  1958. +     
  1959. +     return (s == p) ? p : s+1;
  1960. + }
  1961. + 
  1962. + #endif
  1963. *** 1.5    1992/11/07 04:57:45
  1964. --- varasm.c    1992/11/08 00:50:05
  1965. ***************
  1966. *** 978,991 ****
  1967.   assemble_external_libcall (fun)
  1968.        rtx fun;
  1969.   {
  1970. - #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  1971.     /* Declare library function name external when first used, if nec.  */
  1972.     if (! SYMBOL_REF_USED (fun))
  1973.       {
  1974.         SYMBOL_REF_USED (fun) = 1;
  1975.         ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
  1976. -     }
  1977.   #endif
  1978.   }
  1979.   
  1980.   /* Declare the label NAME global.  */
  1981. --- 978,991 ----
  1982.   assemble_external_libcall (fun)
  1983.        rtx fun;
  1984.   {
  1985.     /* Declare library function name external when first used, if nec.  */
  1986.     if (! SYMBOL_REF_USED (fun))
  1987.       {
  1988.         SYMBOL_REF_USED (fun) = 1;
  1989. + #ifdef ASM_OUTPUT_EXTERNAL_LIBCALL
  1990.         ASM_OUTPUT_EXTERNAL_LIBCALL (asm_out_file, fun);
  1991.   #endif
  1992. +     }
  1993.   }
  1994.   
  1995.   /* Declare the label NAME global.  */
  1996. *** 1.4    1992/11/07 05:03:40
  1997. --- m68k.c    1992/11/08 00:54:49
  1998. ***************
  1999. *** 60,66 ****
  2000.      
  2001.   finalize_pic ()
  2002.   {
  2003. !   if (flag_pic && current_function_uses_pic_offset_table)
  2004.       emit_insn (gen_rtx (USE, VOIDmode, pic_offset_table_rtx));
  2005.   }
  2006.   
  2007. --- 60,66 ----
  2008.      
  2009.   finalize_pic ()
  2010.   {
  2011. !   if (flag_pic && (flag_pic < 3) && current_function_uses_pic_offset_table)
  2012.       emit_insn (gen_rtx (USE, VOIDmode, pic_offset_table_rtx));
  2013.   }
  2014.   
  2015. ***************
  2016. *** 213,219 ****
  2017.         asm_fprintf (stream, "\tmoveml %0I0x%x,%Rsp@-\n", mask);
  2018.   #endif
  2019.       }
  2020. !   if (flag_pic && current_function_uses_pic_offset_table)
  2021.       {
  2022.   #ifdef MOTOROLA
  2023.         asm_fprintf (stream, "\t%Omove.l %0I__GLOBAL_OFFSET_TABLE_, %s\n",
  2024. --- 213,219 ----
  2025.         asm_fprintf (stream, "\tmoveml %0I0x%x,%Rsp@-\n", mask);
  2026.   #endif
  2027.       }
  2028. !   if (flag_pic && (flag_pic < 3) && current_function_uses_pic_offset_table)
  2029.       {
  2030.   #ifdef MOTOROLA
  2031.         asm_fprintf (stream, "\t%Omove.l %0I__GLOBAL_OFFSET_TABLE_, %s\n",
  2032. ***************
  2033. *** 803,814 ****
  2034.     /* First handle a simple SYMBOL_REF or LABEL_REF */
  2035.     if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
  2036.       {
  2037.         if (reg == 0)
  2038.       abort ();
  2039.   
  2040. !       pic_ref = gen_rtx (MEM, Pmode,
  2041. !              gen_rtx (PLUS, Pmode,
  2042. !                   pic_offset_table_rtx, orig));
  2043.         current_function_uses_pic_offset_table = 1;
  2044.         RTX_UNCHANGING_P (pic_ref) = 1;
  2045.         emit_move_insn (reg, pic_ref);
  2046. --- 803,822 ----
  2047.     /* First handle a simple SYMBOL_REF or LABEL_REF */
  2048.     if (GET_CODE (orig) == SYMBOL_REF || GET_CODE (orig) == LABEL_REF)
  2049.       {
  2050. + #ifdef LEGITIMATE_BASEREL_OPERAND_P
  2051. +   if (LEGITIMATE_BASEREL_OPERAND_P (orig))
  2052. +     return orig;
  2053. + #endif
  2054. + 
  2055.         if (reg == 0)
  2056.       abort ();
  2057.   
  2058. !       if (flag_pic == 3)
  2059. !         pic_ref = gen_rtx (PLUS, Pmode, pic_offset_table_rtx, orig);
  2060. !       else
  2061. !         pic_ref = gen_rtx (MEM, Pmode,
  2062. !                gen_rtx (PLUS, Pmode,
  2063. !                     pic_offset_table_rtx, orig));
  2064.         current_function_uses_pic_offset_table = 1;
  2065.         RTX_UNCHANGING_P (pic_ref) = 1;
  2066.         emit_move_insn (reg, pic_ref);
  2067. ***************
  2068. *** 840,845 ****
  2069. --- 848,854 ----
  2070.         pic_ref = gen_rtx (PLUS, Pmode, base, orig);
  2071.         /* Likewise, should we set special REG_NOTEs here?  */
  2072.       }
  2073. + 
  2074.     return pic_ref;
  2075.   }
  2076.   
  2077. ***************
  2078. *** 1582,1587 ****
  2079. --- 1591,1599 ----
  2080.         output_address (XEXP (op, 0));
  2081.         if (letter == 'd' && ! TARGET_68020
  2082.         && CONSTANT_ADDRESS_P (XEXP (op, 0))
  2083. +       && !(TARGET_PC_REL && GET_CODE (XEXP (op, 0)) == SYMBOL_REF
  2084. +            && SYMBOL_REF_FLAG (XEXP (op, 0))
  2085. +            && !SYMBOL_REF_USED (XEXP (op, 0)))
  2086.         && !(GET_CODE (XEXP (op, 0)) == CONST_INT
  2087.              && INTVAL (XEXP (op, 0)) < 0x8000
  2088.              && INTVAL (XEXP (op, 0)) >= -0x8000))
  2089. ***************
  2090. *** 1887,1892 ****
  2091. --- 1899,1906 ----
  2092.                 fprintf (file, ":w");
  2093.               if ((flag_pic == 2) && (breg == pic_offset_table_rtx))
  2094.                 fprintf (file, ":l");
  2095. +             if ((flag_pic == 3) && (breg == pic_offset_table_rtx))
  2096. +               fprintf (file, ":W");
  2097.             }
  2098.           if (addr != 0 && ireg != 0)
  2099.             {
  2100. ***************
  2101. *** 1964,1969 ****
  2102. --- 1978,1996 ----
  2103.           fprintf (file, "%d:w", INTVAL (addr));
  2104.   #endif
  2105.         }
  2106. +     else if (TARGET_PC_REL && GET_CODE (addr) == SYMBOL_REF
  2107. +          && SYMBOL_REF_FLAG (addr)
  2108. +          && !SYMBOL_REF_USED (addr))
  2109. +       {
  2110. + #ifdef MOTOROLA
  2111. +         output_addr_const (file, addr);
  2112. +         fputs ("(pc)", file);
  2113. + #else
  2114. +         fputs ("pc@(", file);
  2115. +         output_addr_const (file, addr);
  2116. +         putc (')', file);
  2117. + #endif
  2118. +       }
  2119.       else
  2120.         {
  2121.           output_addr_const (file, addr);
  2122. ***************
  2123. *** 1971,1973 ****
  2124. --- 1998,2015 ----
  2125.       break;
  2126.       }
  2127.   }
  2128. + #ifdef ENCODE_SECTION_INFO
  2129. + /* Does operand (which is a symbolic_operand) live in text space? If
  2130. +    so SYMBOL_REF_FLAG, which is set by ENCODE_SECTION_INFO, will be true.*/
  2131. + 
  2132. + int
  2133. + read_only_operand (operand)
  2134. +      rtx operand;
  2135. + {
  2136. +   if (GET_CODE (operand) == CONST)
  2137. +     operand = XEXP (XEXP (operand, 0), 0);
  2138. +   if (GET_CODE (operand) == SYMBOL_REF)
  2139. +     return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
  2140. +   return 1;
  2141. + }
  2142. + #endif
  2143. *** 1.6    1992/11/07 05:03:40
  2144. --- m68k.h    1992/11/08 00:54:49
  2145. ***************
  2146. *** 92,97 ****
  2147. --- 92,103 ----
  2148.   /* Use the 68040-only fp instructions (-m68040).  */
  2149.   #define TARGET_68040_ONLY (target_flags & 01000)
  2150.   
  2151. + /* Use PC-relative addressing for refs to read-only data */
  2152. + #define TARGET_PC_REL (target_flags & 02000)
  2153. + 
  2154. + /* Use base-relative addressing for refs to data&bss segments */
  2155. + #define TARGET_BASE_REL (target_flags & 04000)
  2156. + 
  2157.   /* Macro to define tables used to set the flags.
  2158.      This is a list in braces of pairs in braces,
  2159.      each pair being { "NAME", VALUE }
  2160. ***************
  2161. *** 119,124 ****
  2162. --- 125,134 ----
  2163.       { "68030", -01400},                \
  2164.       { "68030", 7},                \
  2165.       { "68040", 01007},            \
  2166. +     { "pcrel", 02000},                \
  2167. +     { "nopcrel", -02000},            \
  2168. +     { "baserel", 04000},            \
  2169. +     { "nobaserel", -04000},            \
  2170.       { "", TARGET_DEFAULT}}
  2171.   /* TARGET_DEFAULT is defined in sun*.h and isi.h, etc.  */
  2172.   
  2173. ***************
  2174. *** 130,135 ****
  2175. --- 140,146 ----
  2176.     if (TARGET_FPA) target_flags &= ~2;    \
  2177.     if (! TARGET_68020 && flag_pic == 2)    \
  2178.       error("-fPIC is not currently supported on the 68000 or 68010\n");    \
  2179. +   if (TARGET_BASE_REL) flag_pic = 3;    \
  2180.   }
  2181.   #else
  2182.   #define OVERRIDE_OPTIONS        \
  2183. ***************
  2184. *** 136,141 ****
  2185. --- 147,153 ----
  2186.   {                    \
  2187.     if (! TARGET_68020 && flag_pic == 2)    \
  2188.       error("-fPIC is not currently supported on the 68000 or 68010\n");    \
  2189. +   if (TARGET_BASE_REL) flag_pic = 3;    \
  2190.   }
  2191.   #endif /* defined SUPPORT_SUN_FPA */
  2192.   
  2193. ***************
  2194. *** 327,335 ****
  2195.   #ifndef SUPPORT_SUN_FPA
  2196.   
  2197.   #define CONDITIONAL_REGISTER_USAGE \
  2198. ! {                                               \
  2199. !   if (flag_pic)                                 \
  2200. !     fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;    \
  2201.   }
  2202.   
  2203.   #else /* defined SUPPORT_SUN_FPA */
  2204. --- 339,350 ----
  2205.   #ifndef SUPPORT_SUN_FPA
  2206.   
  2207.   #define CONDITIONAL_REGISTER_USAGE \
  2208. ! {                                                \
  2209. !   if (flag_pic)                                  \
  2210. !     fixed_regs[PIC_OFFSET_TABLE_REGNUM] = 1;     \
  2211. !   /* prevent saving/restoring of the base reg */ \
  2212. !   if (flag_pic == 3)                 \
  2213. !     call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1; \
  2214.   }
  2215.   
  2216.   #else /* defined SUPPORT_SUN_FPA */
  2217. ***************
  2218. *** 1111,1116 ****
  2219. --- 1126,1133 ----
  2220.          && REG_P (XEXP (X, 0)) && REG_OK_FOR_BASE_P (XEXP (X, 0))    \
  2221.          && GET_CODE (XEXP (X, 1)) == CONST_INT                \
  2222.          && ((unsigned) INTVAL (XEXP (X, 1)) + 0x8000) < 0x10000)        \
  2223. +    || (GET_CODE (X) == PLUS && XEXP (X, 0) == pic_offset_table_rtx     \
  2224. +        && flag_pic == 3 && CONSTANT_ADDRESS_P (XEXP (X, 1)))        \
  2225.      || (GET_CODE (X) == PLUS && XEXP (X, 0) == pic_offset_table_rtx     \
  2226.          && flag_pic && GET_CODE (XEXP (X, 1)) == SYMBOL_REF)        \
  2227.      || (GET_CODE (X) == PLUS && XEXP (X, 0) == pic_offset_table_rtx     \
  2228. *** 1.5    1992/11/07 05:03:40
  2229. --- m68k.md    1992/11/08 00:54:50
  2230. ***************
  2231. *** 704,716 ****
  2232.   {
  2233.     if (flag_pic && symbolic_operand (operands[1], SImode)) 
  2234.       {
  2235. !       /* The source is an address which requires PIC relocation.  
  2236. !          Call legitimize_pic_address with the source, mode, and a relocation
  2237. !          register (a new pseudo, or the final destination if reload_in_progress
  2238. !          is set).   Then fall through normally */
  2239. !       extern rtx legitimize_pic_address();
  2240. !       rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
  2241. !       operands[1] = legitimize_pic_address (operands[1], SImode, temp);
  2242.       }
  2243.   }")
  2244.   
  2245. --- 704,721 ----
  2246.   {
  2247.     if (flag_pic && symbolic_operand (operands[1], SImode)) 
  2248.       {
  2249. ! #ifdef LEGITIMATE_BASEREL_OPERAND_P
  2250. !       if (flag_pic != 3 || !LEGITIMATE_BASEREL_OPERAND_P (operands[1]))
  2251. ! #endif
  2252. !       {
  2253. !         /* The source is an address which requires PIC relocation.  
  2254. !            Call legitimize_pic_address with the source, mode, and a relocation
  2255. !            register (a new pseudo, or the final destination if reload_in_progress
  2256. !            is set).   Then fall through normally */
  2257. !         extern rtx legitimize_pic_address();
  2258. !         rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
  2259. !         operands[1] = legitimize_pic_address (operands[1], SImode, temp);
  2260. !       }
  2261.       }
  2262.   }")
  2263.   
  2264. ***************
  2265. *** 4651,4657 ****
  2266.     ""
  2267.     "
  2268.   {
  2269. !   if (flag_pic && GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF)
  2270.       operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
  2271.                  force_reg (Pmode, XEXP (operands[0], 0)));
  2272.   }")
  2273. --- 4656,4662 ----
  2274.     ""
  2275.     "
  2276.   {
  2277. !   if (flag_pic && flag_pic < 3 && GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF)
  2278.       operands[0] = gen_rtx (MEM, GET_MODE (operands[0]),
  2279.                  force_reg (Pmode, XEXP (operands[0], 0)));
  2280.   }")
  2281. ***************
  2282. *** 4662,4668 ****
  2283.        (match_operand:SI 1 "general_operand" "g"))]
  2284.     ;; Operand 1 not really used on the m68000.
  2285.   
  2286. !   "! flag_pic"
  2287.     "*
  2288.   #ifdef MOTOROLA
  2289.     return \"jsr %0\";
  2290. --- 4667,4673 ----
  2291.        (match_operand:SI 1 "general_operand" "g"))]
  2292.     ;; Operand 1 not really used on the m68000.
  2293.   
  2294. !   "(! flag_pic || flag_pic == 3)"
  2295.     "*
  2296.   #ifdef MOTOROLA
  2297.     return \"jsr %0\";
  2298. ***************
  2299. *** 4677,4683 ****
  2300.        (match_operand:SI 1 "general_operand" "g"))]
  2301.     ;; Operand 1 not really used on the m68000.
  2302.   
  2303. !   "flag_pic"
  2304.     "*
  2305.     return \"jsr %0\";
  2306.   ")
  2307. --- 4682,4688 ----
  2308.        (match_operand:SI 1 "general_operand" "g"))]
  2309.     ;; Operand 1 not really used on the m68000.
  2310.   
  2311. !   "(flag_pic && flag_pic < 3)"
  2312.     "*
  2313.     return \"jsr %0\";
  2314.   ")
  2315. ***************
  2316. *** 4693,4699 ****
  2317.     ""
  2318.     "
  2319.   {
  2320. !   if (flag_pic && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF)
  2321.       operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
  2322.                  force_reg (Pmode, XEXP (operands[1], 0)));
  2323.   }")
  2324. --- 4698,4704 ----
  2325.     ""
  2326.     "
  2327.   {
  2328. !   if (flag_pic && flag_pic < 3 && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF)
  2329.       operands[1] = gen_rtx (MEM, GET_MODE (operands[1]),
  2330.                  force_reg (Pmode, XEXP (operands[1], 0)));
  2331.   }")
  2332. ***************
  2333. *** 4704,4710 ****
  2334.       (call (match_operand:QI 1 "memory_operand" "o")
  2335.             (match_operand:SI 2 "general_operand" "g")))]
  2336.     ;; Operand 2 not really used on the m68000.
  2337. !   "! flag_pic"
  2338.     "*
  2339.   #ifdef MOTOROLA
  2340.     return \"jsr %1\";
  2341. --- 4709,4715 ----
  2342.       (call (match_operand:QI 1 "memory_operand" "o")
  2343.             (match_operand:SI 2 "general_operand" "g")))]
  2344.     ;; Operand 2 not really used on the m68000.
  2345. !   "(! flag_pic || flag_pic == 3)"
  2346.     "*
  2347.   #ifdef MOTOROLA
  2348.     return \"jsr %1\";
  2349. ***************
  2350. *** 4719,4725 ****
  2351.       (call (match_operand:QI 1 "memory_operand" "o")
  2352.             (match_operand:SI 2 "general_operand" "g")))]
  2353.     ;; Operand 2 not really used on the m68000.
  2354. !   "flag_pic"
  2355.     "*
  2356.     return \"jsr %1\";
  2357.   ")
  2358. --- 4724,4730 ----
  2359.       (call (match_operand:QI 1 "memory_operand" "o")
  2360.             (match_operand:SI 2 "general_operand" "g")))]
  2361.     ;; Operand 2 not really used on the m68000.
  2362. !   "(flag_pic && flag_pic < 3)"
  2363.     "*
  2364.     return \"jsr %1\";
  2365.   ")
  2366.