home *** CD-ROM | disk | FTP | other *** search
/ AMIGA PD 1 / AMIGA-PD-1.iso / Programme_zum_Heft / Programmieren / Kurztests / DiceC / cc / main.c < prev    next >
C/C++ Source or Header  |  1994-02-01  |  30KB  |  1,557 lines
  1.  
  2. /*
  3.  *  MAIN.C
  4.  *
  5.  *  (c)Copyright 1990, Matthew Dillon, All Rights Reserved
  6.  *
  7.  *  dcc <options> <files>
  8.  */
  9.  
  10. #include "defs.h"
  11.  
  12. #ifndef AZLAT_COMPAT
  13. #define DoLink_Dice    DoLink
  14. #define DoCompile_Dice    DoCompile
  15. #define DoAssemble_Dice DoAssemble
  16. #define DoPrelink_Dice    DoPrelink
  17. #endif
  18.  
  19. #ifdef _DCC
  20. IDENT("DCC",".37");
  21. DCOPYRIGHT;
  22. #endif
  23.  
  24. Prototype   void    myexit(void);
  25. Prototype   int     main(int, char **);
  26. Prototype   void    AddFile(char *);
  27. Prototype   void    help(int);
  28. Prototype   char    *TmpFileName(char *);
  29. Prototype   char    *MungeFile(char *, char *, char *);
  30. Prototype   void    AddName(LIST *, char *, char *);
  31. Prototype   void    AddOpt(LIST *, char *, char *);
  32. Prototype   char    *Tailer(char *);
  33. Prototype   char    *XFilePart(char *);
  34. Prototype   char    *OptListToStr(LIST *);
  35. Prototype   char    *OptListToStr2(LIST *, char *);
  36. Prototype   void    run_cmd(char *);
  37. Prototype   int     OutOfDate(char *, char *);
  38. Prototype   void    HandleCFile(char *, int);
  39. Prototype   void    HandleAFile(char *, int);
  40. Prototype   void    PushTmpFile(char *);
  41. Prototype   void    PopTmpFile(char *);
  42. Prototype   long    LoadSegLock(long);
  43.  
  44. Prototype   int     DoCompile(char *, char *);
  45. Prototype   int     DoCompile_Dice(char *, char *);
  46. Prototype   int     DoCompile_Aztec(char *, char *);
  47. Prototype   int     DoCompile_Lattice(char *, char *);
  48. Prototype   int     DoAssemble(char *, char *);
  49. Prototype   int     DoAssemble_Dice(char *, char *);
  50. Prototype   int     DoAssemble_Aztec(char *, char *);
  51. Prototype   int     DoAssemble_Lattice(char *, char *);
  52. Prototype   char    *DoPrelink(void);
  53. Prototype   char    *DoPrelink_Dice(void);
  54. Prototype   char    *DoPrelink_Aztec(void);
  55. Prototype   char    *DoPrelink_Lattice(void);
  56. Prototype   int     DoLink(char *);
  57. Prototype   int     DoLink_Dice(char *);
  58. Prototype   int     DoLink_Aztec(char *);
  59. Prototype   int     DoLink_Lattice(char *);
  60.  
  61. void OrderApp(char *);
  62. void AddLibApp(char *, char);
  63. void DelLibApp(char *, char);
  64.  
  65. /*
  66.  *  Note that we use exec_dcc if DCC, which only works with 'dcc' programs
  67.  *  thus, the executables are renamed to prevent problems.
  68.  */
  69.  
  70. Prototype __aligned char Buf[512];
  71.  
  72.  
  73. __aligned char Buf[512];
  74. char TmpFile[64];
  75. char ErrOptStr[128];
  76. char *ErrFile;
  77. char *OutFile;
  78. char *OutDir = "T:";
  79. char *TmpDir = "T:";
  80. char *AmigaLib = "dlib:amiga";
  81. char *CLib = "dlib:c";
  82. char ALibOS[4];
  83. char ALibApp[32] = { "s" };
  84. char CLibApp[32] = { "s" };
  85. LIST TmpList;
  86. short NewOpt;
  87. short FastOpt;
  88. short FragOpt;
  89. short ChipOpt;
  90. short MC68020Opt;
  91. short MC68881Opt;
  92. short FFPOpt;
  93. short DDebug;
  94. short RegCallOpt;
  95. short NoHeirOpt;
  96. short NoEnvOpt;
  97. short SlashSlashOpt;
  98. short ProfOpt;
  99. short DLinkPostFixOpt;
  100.  
  101. char DLINK[32];
  102. char DAS[32];
  103. char DC1[32];
  104. char DCPP[32];
  105.  
  106. typedef struct NameNode {
  107.     struct Node n_Node;
  108.     char    *n_In;
  109.     char    *n_Out;
  110.     short   n_IsTmp;
  111. } NameNode;
  112.  
  113. LIST   CList;
  114. LIST   AList;
  115. LIST   OList;
  116. LIST   LList;
  117.  
  118. LIST   CppOptList;
  119. LIST   LinkOptList;
  120.  
  121. short    NoLink;
  122. short    NoAsm;
  123. short    SmallCode = 1;
  124. short    SmallData = 1;
  125. short    ConstCode;        /*    -ms            */
  126. short    AbsData;        /*    -mw, -ma        */
  127. short    ResOpt;
  128. short    AltSectOpt;
  129. short    SymOpt;
  130. short    RomOpt;
  131. short    ProtoOnlyOpt;
  132. short    NoIntermediateAssembly;
  133. short    PIOpt;
  134. short    GenStackOpt;
  135. short    GenLinkOpt;
  136. short    Verbose;
  137. short    NoDefaultLibs;
  138. short    CompilerOpt = DICE_C;
  139. long    AbsDataStart;        /*    -mw <addr>  */
  140. char    DebugOpts[64];
  141.  
  142. extern struct Library *SysBase;
  143.  
  144. void
  145. myexit()
  146. {
  147.     NODE *node;
  148.  
  149.     while (node = RemHead(&TmpList)) {
  150.     remove(node->ln_Name);
  151.     free(node);
  152.     }
  153. }
  154.  
  155. int
  156. main(xac, xav)
  157. int xac;
  158. char *xav[];
  159. {
  160.     int fc = 0;
  161.     int ac;
  162.     char **av;
  163.  
  164. #ifdef LATTICE
  165.     {
  166.     long n = (long)Buf;
  167.     if (n & 3) {
  168.         puts("software error, Buf not aligned");
  169.         exit(1);
  170.     }
  171.     }
  172. #endif
  173. #ifdef NOTDEF
  174.     expand_args(xac, xav, &ac, &av);
  175. #else
  176.     ac = xac;
  177.     av = xav;
  178. #endif
  179.  
  180.     NewList(&CList);
  181.     NewList(&AList);
  182.     NewList(&OList);
  183.     NewList(&LList);
  184.  
  185.     NewList(&TmpList);
  186.  
  187.     NewList(&CppOptList);
  188.     NewList(&LinkOptList);
  189.  
  190.     atexit(myexit);
  191.  
  192.     if (ac == 1)
  193.     help(0);
  194.  
  195.     {
  196.     char *ptr = av[0];    /*  cmd name */
  197.     char prefix[32];
  198.     short i;
  199.  
  200.     for (i = strlen(ptr); i >= 0 && ptr[i] != ':' && ptr[i] != '/'; --i);
  201.     ++i;
  202.  
  203.     ptr = ptr + i;        /*  base name */
  204.     for (i = 0; ptr[i] && ptr[i] != '_'; ++i);
  205.     if (ptr[i] == '_') {
  206.         strncpy(prefix, ptr, i + 1);
  207.         prefix[i+1] = 0;
  208.     } else {
  209.         prefix[0] = 0;
  210.     }
  211.     sprintf(DLINK, "%s%s", prefix, "dlink");
  212.     sprintf(DAS  , "%s%s", prefix, "das");
  213.     sprintf(DC1  , "%s%s", prefix, "dc1");
  214.     sprintf(DCPP , "%s%s", prefix, "dcpp");
  215.     }
  216.  
  217.     /*
  218.      *    check for -no-env option before processing DCCOPTS
  219.      */
  220.  
  221.     {
  222.     long i;
  223.  
  224.     for (i = 1; i < ac; ++i) {
  225.         if (strcmp(av[i], "-no-env") == 0) {
  226.         NoEnvOpt = 1;
  227.         break;
  228.         }
  229.     }
  230.     }
  231.  
  232.     if (NoEnvOpt == 0) {
  233.     char **argv = av;
  234.     ac = ExtArgsEnv(ac, &argv, "DCCOPTS");
  235.     av = argv;
  236.     }
  237.  
  238.     {
  239.     long i;
  240.     char *dummy;
  241.  
  242.     for (i = 1; i < ac; ++i) {
  243.         char *ptr = av[i];
  244.  
  245.         if (*ptr == '-') {
  246.         ptr += 2;
  247.  
  248.         switch(ptr[-1]) {
  249.         case '0':       /*  -020        */
  250.             MC68020Opt = 1;
  251.             break;
  252.         case '1':       /*  1.4, 1.3    */
  253.         case '2':       /*  2.0, 2.1..  */
  254.             if (ptr[0] != '.')
  255.             help(1);
  256.             AddOpt(&CppOptList, ptr - 2, "");
  257.             ALibOS[0] = ptr[-1];
  258.             ALibOS[1] = ptr[1];
  259.             break;
  260.         case '8':
  261.             MC68881Opt = 1;
  262.             break;
  263.         case 'f':
  264.             if (*ptr == 0)
  265.             FastOpt = 1;
  266.             else if (*ptr == 'r')
  267.             FragOpt = 1;
  268.             else if (*ptr == 'f')
  269.             FFPOpt = 1;
  270.             break;
  271.         case 'r':
  272.             if (strcmp(ptr, "om") == 0) {
  273.             RomOpt = 1;
  274.             } else {
  275.             if (PIOpt && ResOpt == 0)
  276.                 puts("DCC: Warning, -r -pi = -pr");
  277.             ResOpt = 1;
  278.             }
  279.             break;
  280.         case 'c':
  281.             if (*ptr == 0)
  282.             NoLink = 1;
  283.             else if (stricmp(ptr, "hip") == 0)
  284.             ChipOpt = 1;
  285.             else
  286.             help(1);
  287.             break;
  288.         case 'a':
  289.             if (strcmp(ptr, "ztec") == 0) {
  290.             CompilerOpt = AZTEC_C;
  291.             break;
  292.             }
  293.             NoAsm = 1;
  294.             NoLink= 1;
  295.             break;
  296.         case 'g':
  297.             switch (*ptr) {
  298.             case 's':
  299.             GenStackOpt = 1;
  300.             break;
  301.             case 'l':
  302.             GenLinkOpt = 1;
  303.             break;
  304.             default:
  305.             help(1);
  306.             }
  307.             break;
  308.         case 'l':
  309.             if (strcmp(ptr, "attice") == 0) {
  310.             CompilerOpt = LATTICE_C;
  311.             break;
  312.             }
  313.             if (ptr[0] == '0' && ptr[1] == 0) {
  314.             NoDefaultLibs = 1;
  315.             break;
  316.             }
  317.             if (*ptr == 0)
  318.             ptr = av[++i];
  319.             AddName(&LList, ".lib", ptr);
  320.             DLinkPostFixOpt = 1;
  321.             break;
  322.         case 'L':   /*  -Idir   */
  323.             if (ptr[0] == '0' && ptr[1] == 0) {
  324.             AddOpt(&LinkOptList, "-L0", "");
  325.             break;
  326.             }
  327.             if (*ptr == 0)
  328.             ptr = av[++i];
  329.             AddOpt(&LinkOptList, "-L", ptr);
  330.             break;
  331.         case 'I':   /*  -Idir   */
  332.             if (ptr[0] == '0' && ptr[1] == 0) {
  333.             AddOpt(&CppOptList, "-I0", "");
  334.             break;
  335.             }
  336.             if (*ptr == 0)
  337.             ptr = av[++i];
  338.             AddOpt(&CppOptList, "-I", ptr);
  339.             break;
  340.         case 'd':   /*  -dice -d<n> -d<debug_opts>  */
  341.             if (strcmp(ptr, "ice") == 0) {
  342.             CompilerOpt = DICE_C;
  343.             break;
  344.             }
  345.             if (atoi(ptr)) {
  346.             DDebug = atoi(ptr);
  347.             break;
  348.             }
  349.             sprintf(DebugOpts, " -d%s", ptr);
  350.             break;
  351.         case 'D':   /*  -Ddefine[=str] */
  352.             if (*ptr == 0)
  353.             ptr = av[++i];
  354.             AddOpt(&CppOptList, "-D", ptr);
  355.             break;
  356.         case 'H':   /*  -H<path>=<include_name>    */
  357.             if (*ptr == 0)
  358.             ptr = av[++i];
  359.             AddOpt(&CppOptList, "-H", ptr);
  360.             break;
  361.         case 'U':   /*  -U      -undefine certain symbols */
  362.             AddOpt(&CppOptList, "-U", ptr);
  363.             break;
  364.         case 'o':
  365.             if (*ptr)
  366.             OutFile = ptr;
  367.             else
  368.             OutFile = av[++i];
  369.             {
  370.             short idx = strlen(OutFile) - 2;
  371.             if (idx >= 0) {
  372.                 if (stricmp(OutFile + idx, ".h") == 0 || stricmp(OutFile + idx, ".c") == 0) {
  373.                 puts("ERROR! -o output file may not end in .c or .h!");
  374.                 exit(20);
  375.                 }
  376.             }
  377.             }
  378.             break;
  379.         case 'O':
  380.             if (*ptr)
  381.             OutDir = ptr;
  382.             else
  383.             OutDir = av[++i];
  384.             break;
  385.         case 'E':   /*  error output append */
  386.             if (*ptr == 0)
  387.             ptr = av[++i];
  388.  
  389.             if (freopen(ptr, "a", stderr)) {
  390.             ErrFile = ptr;
  391.             sprintf(ErrOptStr," -E %s", ptr);
  392.             } else {
  393.             printf("unable to append to %s\n", ptr);
  394.             }
  395.             break;
  396.         case 'p':
  397.             if (strcmp(ptr, "roto") == 0) {
  398.             ProtoOnlyOpt = 1;
  399.             } else if (strncmp(ptr, "rof", 3) == 0) {
  400.             ProfOpt = atoi(ptr + 3);
  401.             if (ProfOpt == 0)
  402.                 ProfOpt = 1;
  403.             if (ProfOpt >= 2)
  404.                 AddLibApp(CLibApp, 'p');
  405.             if (ProfOpt >= 3)
  406.                 AddLibApp(ALibApp, 'p');
  407.             } else if (strcmp(ptr, "i") == 0) {
  408.             PIOpt = 1;
  409.             if (ResOpt)
  410.                 puts("DCC: Warning, -r -pi = -pr");
  411.             } else if (strcmp(ptr, "r") == 0) {
  412.             PIOpt = 1;
  413.             ResOpt = 1;
  414.             } else {
  415.             help(1);
  416.             }
  417.             break;
  418.         case 'T':
  419.             if (*ptr)
  420.             TmpDir = ptr;
  421.             else
  422.             TmpDir = av[++i];
  423.             break;
  424.         case 'm':
  425.             switch(*ptr) {
  426.             case 'C':
  427.             SmallCode = 0;
  428.             break;
  429.             case 'c':
  430.             SmallCode = 1;
  431.             break;
  432.             case 'D':
  433.             SmallData = 0;
  434.             DelLibApp(ALibApp, 's');
  435.             DelLibApp(CLibApp, 's');
  436.             AddLibApp(ALibApp, 'l');
  437.             AddLibApp(CLibApp, 'l');
  438.             break;
  439.             case 'd':
  440.             SmallData = 1;
  441.             DelLibApp(ALibApp, 'l');
  442.             DelLibApp(CLibApp, 'l');
  443.             AddLibApp(ALibApp, 's');
  444.             AddLibApp(CLibApp, 's');
  445.             break;
  446.             case 'a':
  447.             case 'w':
  448.             AbsData = 1;
  449.  
  450.             if (*ptr == 'a')
  451.                 AbsData = 2;
  452.  
  453.             ++ptr;
  454.             if (*ptr == 0)
  455.                 ptr = av[++i];
  456.  
  457. #ifdef LATTICE
  458.             AbsDataStart = atoi(ptr);   /*  bug in lattice */
  459. #else
  460.             AbsDataStart = strtol(ptr, &dummy, 0);
  461. #endif
  462.             break;
  463.             case 'r':
  464.             RegCallOpt = 1;
  465.             break;
  466.             case 'R':
  467.             AddLibApp(CLibApp, 'r');
  468.             AddLibApp(ALibApp, 'r');
  469.  
  470.             RegCallOpt = 2;
  471.             if (ptr[1] == 'R') {
  472.                 RegCallOpt = 3;
  473.                 if (ptr[2] == 'X')
  474.                 RegCallOpt = 4;
  475.             }
  476.             break;
  477.             case 's':
  478.             if (strcmp(ptr, "as") == 0) {
  479.                 CompilerOpt = LATTICE_C;
  480.                 break;
  481.             }
  482.             if (ptr[1] == '0')
  483.                 ConstCode = 0;
  484.             else
  485.                 ConstCode = 1;
  486.             break;
  487.             case 'S':
  488.             ConstCode = 2;
  489.             break;
  490.             default:
  491.             fprintf(stderr, "bad -s model\n");
  492.             exit(1);
  493.             }
  494.             break;
  495.         case 's':
  496.             SymOpt = 1;
  497.             break;
  498.         case 'S':
  499.             AltSectOpt = 1;
  500.             break;
  501.         case 'v':
  502.             Verbose = 1;
  503.             break;
  504.         case '/':
  505.             if (strcmp(ptr-1, "//") == 0) {
  506.             SlashSlashOpt = 1;
  507.             break;
  508.             }
  509.             goto def;
  510.         case 'n':
  511.             if (strcmp(ptr-1, "new") == 0) {
  512.             NewOpt = 1;
  513.             break;
  514.             }
  515.             if (strcmp(ptr-1, "noheir") == 0) {
  516.             NoHeirOpt = 1;
  517.             break;
  518.             }
  519.             if (strcmp(ptr-1, "no-env") == 0)
  520.             break;
  521.             /* fall through */
  522.         default:
  523.         def:
  524.             fprintf(stderr, "bad - option\n");
  525.             help(1);
  526.         }
  527.         continue;
  528.         }
  529.         if (*ptr == '+') {
  530.         ptr += 2;
  531.  
  532.         switch(ptr[-1]) {
  533.         case 'I':   /*  +Idir   */
  534.             if (*ptr == 0)
  535.             ptr = av[++i];
  536.             AddOpt(&CppOptList, "+I", ptr);
  537.             break;
  538.         default:
  539.             fprintf(stderr, "bad + option\n");
  540.             help(1);
  541.         }
  542.         continue;
  543.         }
  544.         if (*ptr == '@') {
  545.         FILE *fi = fopen(ptr + 1, "r");
  546.         char buf[128];
  547.  
  548.         if (fi == NULL) {
  549.             printf("unable to open %s\n", ptr + 1);
  550.             exit(1);
  551.         }
  552.         while (fgets(buf, sizeof(buf), fi)) {
  553.             short len = strlen(buf);
  554.             if (len > 0)
  555.             buf[len-1] = 0;
  556.             if (buf[0] && buf[0] != ';' && buf[0] != '#') {
  557.             ++fc;
  558.             AddFile(buf);
  559.             }
  560.         }
  561.         fclose(fi);
  562.         continue;
  563.         }
  564.         ++fc;
  565.         AddFile(ptr);
  566.     }
  567.     if (i > ac) {
  568.         fprintf(stderr, "file argument missing\n");
  569.         help(1);
  570.     }
  571.     }
  572.  
  573. #ifdef AZLAT_COMPAT
  574.     if (CompilerOpt == AZTEC_C) {
  575.     puts("DCC in AZTEC mode");
  576.     FastOpt = 0;
  577.     NoIntermediateAssembly = 1;
  578.     }
  579.     if (CompilerOpt == LATTICE_C) {
  580.     puts("DCC in LATTICE mode");
  581.     FastOpt = 0;
  582.     NoIntermediateAssembly = 1;
  583.     }
  584. #else
  585.     if (CompilerOpt != DICE_C)
  586.     puts("DCC must be recompiled w/ AZLAT_COMPAT defined");
  587. #endif
  588.  
  589.     /*
  590.      *    Ensure CLibApp and ALibApp ordering and remove duplicates
  591.      */
  592.  
  593.     OrderApp(CLibApp);
  594.     OrderApp(ALibApp);
  595.  
  596.     /*
  597.      *    Compile sources into assembly or objects
  598.      */
  599.  
  600.  
  601.     {
  602.     NameNode *nn;
  603.  
  604.     while (nn = (NameNode *)RemHead(&CList))
  605.         HandleCFile(nn->n_In, fc);
  606.     if (NoAsm == 0) {
  607.         while (nn = (NameNode *)RemHead(&AList))
  608.         HandleAFile(nn->n_In, fc);
  609.     }
  610.     }
  611.  
  612.     /*
  613.      *    Link objects into executable
  614.      */
  615.  
  616.     if (NoLink == 0) {
  617.     char *lfile = DoPrelink();
  618.     if (lfile)
  619.         PushTmpFile(lfile);
  620.     DoLink(lfile);
  621.     if (lfile) {
  622.         PopTmpFile(lfile);
  623.         remove(lfile);
  624.         free(lfile);
  625.     }
  626.     }
  627.     return(0);
  628. }
  629.  
  630. void
  631. AddFile(ptr)
  632. char *ptr;
  633. {
  634.     char *t = Tailer(ptr);
  635.  
  636.     if (strncmp(t, "a", 1) == 0) {
  637.     AddName(&AList, NULL, ptr);
  638.     } else
  639.     if (strncmp(t, "o", 1) == 0) {
  640.     AddName(&OList, NULL, ptr);
  641.     } else
  642.     if (strncmp(t, "l", 1) == 0) {
  643.     AddName(&LList, NULL, ptr);
  644.     } else {
  645.     AddName(&CList, NULL, ptr);
  646.     }
  647. }
  648.  
  649. DoCompile_Dice(in, out)
  650. char *in;
  651. char *out;
  652. {
  653.     char *qq = "";
  654.     char *cptmp = TmpFileName(".i");
  655.     char *code = (SmallCode) ? " -mc" : " -mC";
  656.     char *data = (SmallData) ? " -md" : " -mD";
  657.     char *rc = qq;
  658.     char *absdata;
  659.     char *concode;
  660.     char *res  = (ResOpt) ? " -r" : qq;
  661.     char *verb = (Verbose) ? " -v" : qq;
  662.     char *optsect = (AltSectOpt) ? " -S" : qq;
  663.     char *protoonly = (ProtoOnlyOpt) ? " -proto" : qq;
  664.     char *prof = (ProfOpt) ? " -prof" : qq;
  665.     char *mc68020 = (MC68020Opt) ? " -020" : qq;
  666.     char *mc68881 = (MC68881Opt) ? " -881" : qq;
  667.     char *piopt;
  668.     char *ffp = (FFPOpt) ? " -ffp" : qq;
  669.     char *genstack = (GenStackOpt) ? " -gs" : qq;
  670.     char *genlink  = (GenLinkOpt) ? " -gl" : qq;
  671.     char *slashopt = (SlashSlashOpt) ? " -//" : qq;
  672.  
  673.     switch(RegCallOpt) {
  674.     case 1:
  675.     rc = " -mr";
  676.     break;
  677.     case 2:
  678.     rc = " -mR";
  679.     break;
  680.     case 3:
  681.     rc = " -mRR";
  682.     break;
  683.     case 4:
  684.     rc = " -mRRX";
  685.     break;
  686.     }
  687.  
  688.     switch(ConstCode) {
  689.     case 1:
  690.     concode = " -ms";
  691.     break;
  692.     case 2:
  693.     concode = " -mS";
  694.     break;
  695.     default:
  696.     concode = qq;
  697.     break;
  698.     }
  699.  
  700.     switch(AbsData) {
  701.     case 1:
  702.     absdata = " -mw";
  703.     break;
  704.     case 2:
  705.     absdata = " -ma";
  706.     break;
  707.     default:
  708.     absdata = qq;
  709.     break;
  710.     }
  711.  
  712.     if (PIOpt) {
  713.     if (ResOpt)
  714.         piopt = " -pr";
  715.     else
  716.         piopt = " -pi";
  717.     res = qq;
  718.     absdata = qq;
  719.     code = qq;
  720.     data = qq;
  721.     } else {
  722.     piopt = qq;
  723.     }
  724.  
  725.     PushTmpFile(cptmp);
  726.     sprintf(Buf+1, "%s %s -o %s%s%s%s%s",
  727.     DCPP, in, cptmp, ErrOptStr, OptListToStr(&CppOptList),
  728.     ffp, slashopt
  729.     );
  730.     run_cmd(Buf+1);
  731.     sprintf(Buf+1, "%s %s -o %s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s%s",
  732.     DC1, cptmp, out, code, data, rc, res, verb,
  733.     optsect, protoonly, prof, concode, absdata, piopt, ErrOptStr,
  734.     mc68020, mc68881, ffp, genstack, genlink, DebugOpts
  735.     );
  736.     run_cmd(Buf+1);
  737.     PopTmpFile(cptmp);
  738.     remove(cptmp);
  739.     free(cptmp);
  740.     return(0);
  741. }
  742.  
  743. DoAssemble_Dice(in, out)
  744. char *in;
  745. char *out;
  746. {
  747.     sprintf(Buf+1, "%s -o%s %s%s", DAS, out, in, ErrOptStr);
  748.     run_cmd(Buf+1);
  749.     return(0);
  750. }
  751.  
  752. char *
  753. DoPrelink_Dice(void)
  754. {
  755.     NameNode *nn;
  756.     char *ltmp = TmpFileName(".lnk");
  757.     FILE *fi = fopen(ltmp, "w");
  758.  
  759.     if (fi == NULL) {
  760.     fprintf(stderr, "couldn't create %s\n", ltmp);
  761.     exit(1);
  762.     }
  763.  
  764.     while (nn = (NameNode *)RemHead(&OList)) {
  765.     fputs(nn->n_In, fi);
  766.     putc('\n', fi);
  767.     }
  768.     while (nn = (NameNode *)RemHead(&LList)) {
  769.     fputs(nn->n_In, fi);
  770.     putc('\n', fi);
  771.     }
  772.  
  773.     /*
  774.      *    only small-data version of auto.lib is supported currently
  775.      */
  776.  
  777.     if (RomOpt == 0 && NoDefaultLibs == 0) {
  778.     fprintf(fi, "%s%s.lib", CLib, CLibApp);
  779.     fprintf(fi, " %s%s%s.lib dlib:autos.lib\n",
  780.         AmigaLib, ALibApp, ALibOS
  781.     );
  782.     }
  783.     fclose(fi);
  784.     return(ltmp);
  785. }
  786.  
  787. /*
  788.  *  dlib:x.o is a special trailer for any autoinit code (in section autoinit,code)
  789.  *  This section is called in sequence just before main() with ac, av pushed on
  790.  *  the stack.    The idea is that any module may reference an autoinit section to
  791.  *  automatically initialize certain aspects of itself without requiring a call
  792.  *  from the main program.
  793.  */
  794.  
  795. DoLink_Dice(lfile)
  796. char *lfile;
  797. {
  798.     char *qq = "";
  799.     char *co = " ";
  800. #ifdef NOTDEF
  801.     char *ro = (NoDefaultLibs) ? qq : "dlib:x.o";
  802. #endif
  803.     char *ro = "dlib:x.o";
  804.     char *symopt = (SymOpt) ? " -s" : qq;
  805.     char *resopt = (ResOpt) ? " -r" : qq;
  806.     char *fragopt= (FragOpt) ? " -frag" : qq;
  807.     char *chipopt= (ChipOpt) ? " -chip" : qq;
  808.     char *postfix= qq;
  809.     char *piopt;
  810.     char absdata[20];
  811.  
  812.     if (DLinkPostFixOpt) {
  813.     static char PostFix[sizeof(CLibApp)+3];
  814.     postfix = PostFix;
  815.     sprintf(postfix, " -P%s", CLibApp);
  816.     }
  817.  
  818.     if (RomOpt == 0 && NoDefaultLibs == 0) {       /*  RomOpt PIOpt ResOpt */
  819.     static char *SCode[] = { "dlib:c.o ",       /*    0      0      0   */
  820.                  "dlib:c.o ",       /*    0      0      1   */
  821.                  "dlib:c_pi.o ",    /*    0      1      0   */
  822.                  "dlib:c_pr.o "     /*    0      1      1   */
  823.                    };
  824.     co = SCode[(short)((PIOpt << 1) | ResOpt)];
  825.     }
  826.  
  827.     if (OutFile == NULL)
  828.     OutFile = "a.out";
  829.  
  830.     if (AbsData) {
  831.     sprintf(absdata, " -ma 0x%lx", AbsDataStart);
  832.     } else {
  833.     absdata[0] = 0;
  834.     }
  835.  
  836.     if (PIOpt) {
  837.     if (ResOpt)
  838.         piopt = " -pr";
  839.     else
  840.         piopt = " -pi";
  841.     resopt = qq;
  842.     if (AbsData) {
  843.         absdata[0] = 0;
  844.         puts("Warning: cannot mix -pi and -ma/-mw");
  845.     }
  846.     } else {
  847.     piopt = qq;
  848.     }
  849.     if (FragOpt) {
  850.     if (ResOpt) {
  851.         puts("Warning: cannot use -frag with -r");
  852.         fragopt = qq;
  853.     }
  854.     }
  855.  
  856.     sprintf(Buf+1, "%s %s @%s %s -o %s%s%s%s%s%s%s%s%s%s",
  857.     DLINK, co, lfile, ro, OutFile,
  858.     symopt,
  859.     resopt,
  860.     fragopt,
  861.     piopt,
  862.     absdata,
  863.     postfix,
  864.     chipopt,
  865.     OptListToStr(&LinkOptList),
  866.     ErrOptStr
  867.     );
  868.     run_cmd(Buf+1);
  869.     return(0);
  870. }
  871.  
  872.  
  873.  
  874. void
  875. help(code)
  876. {
  877. #ifdef _DCC
  878.     printf("%s\n%s\n", Ident, DCopyright);
  879. #endif
  880.     puts("Refer to DOC/DCC.DOC for options. -f for resident-hack-fast-load");
  881.     exit(code);
  882. }
  883.  
  884. char *
  885. TmpFileName(tail)
  886. char *tail;
  887. {
  888.     char *buf = malloc(strlen(TmpDir) + strlen(tail) + 32);
  889.     char dummy = 0;
  890.  
  891.     sprintf(buf, "%s%06lx%s", TmpDir, (long)&dummy >> 8, tail);
  892.     return(buf);
  893. }
  894.  
  895. char *
  896. MungeFile(file, hdr, tail)
  897. char *file;
  898. char *hdr;
  899. char *tail;
  900. {
  901.     char *base = file;
  902.     char *name;
  903.     short i;
  904.     short hlen = 0;
  905.  
  906.     if (hdr) {
  907.     hlen = strlen(hdr);
  908.     if (base = strchr(base, ':'))
  909.         ++base;
  910.     else
  911.         base = file;
  912. #ifdef NOTDEF
  913.     while (*base && *base != ':' && *base != '/')
  914.         ++base;
  915.     if (*base == 0)
  916.         base = file;
  917.     else
  918.         ++base;
  919. #endif
  920.     } else {
  921.     hdr = "";
  922.     }
  923.     for (i = strlen(base) - 1; i >= 0; --i) {
  924.     if (base[i] == '.')
  925.         break;
  926.     }
  927.     if (i < 0)
  928.     i = strlen(base);
  929.  
  930.     name = malloc(hlen + i + strlen(tail) + 2);
  931.     strcpy(name, hdr);
  932.     if (hlen && hdr[hlen-1] != ':' && hdr[hlen-1] != '/')
  933.     strcat(name, "/");
  934.     sprintf(name + strlen(name), "%.*s%s", i, base, tail);
  935.     return(name);
  936. }
  937.  
  938. void
  939. AddName(list, tailifnone, file)
  940. LIST *list;
  941. char *tailifnone;
  942. char *file;
  943. {
  944.     NameNode *nn = malloc(sizeof(NameNode));
  945.     short i;
  946.  
  947.     for (i = strlen(file) - 1; i >= 0 && file[i] != '.'; --i) {
  948.     if (file[i] == '/' || file[i] == ':')
  949.         i = 0;
  950.     }
  951.  
  952.     if (i < 0 && tailifnone) {
  953.     nn->n_In = malloc(strlen(file) + strlen(tailifnone) + 1);
  954.     sprintf(nn->n_In, "%s%s", file, tailifnone);
  955.     } else {
  956.     nn->n_In = malloc(strlen(file) + 1);
  957.     strcpy(nn->n_In, file);
  958.     }
  959.     nn->n_Out = NULL;
  960.     nn->n_IsTmp = 0;
  961.     AddTail(list, &nn->n_Node);
  962. }
  963.  
  964. void
  965. AddOpt(list, opt, body)
  966. LIST *list;
  967. char *opt;
  968. char *body;
  969. {
  970.     NameNode *nn = malloc(sizeof(NameNode));
  971.  
  972.     nn->n_In = opt;
  973.     nn->n_Out= body;
  974.     AddTail(list, &nn->n_Node);
  975. }
  976.  
  977. char *
  978. Tailer(ptr)
  979. char *ptr;
  980. {
  981.     short i;
  982.  
  983.     for (i = strlen(ptr) - 1; i >= 0 && ptr[i] != '.'; --i);
  984.     if (i < 0)
  985.     return("");
  986.     return(ptr + i + 1);
  987. }
  988.  
  989. char *
  990. XFilePart(ptr)
  991. char *ptr;
  992. {
  993.     short i;
  994.  
  995.     for (i = strlen(ptr) - 1; i >= 0 && ptr[i] != ':' && ptr[i] != '/'; --i);
  996.     ++i;
  997.     return(ptr + i);
  998. }
  999.  
  1000. char *
  1001. OptListToStr(list)
  1002. LIST *list;
  1003. {
  1004.     static char Tmp[512];
  1005.     short i;
  1006.     NameNode *scan;
  1007.  
  1008.     i = 0;
  1009.     Tmp[0] = 0;
  1010.     for (scan = (NameNode *)list->lh_Head; scan != (NameNode *)&list->lh_Tail; scan = (NameNode *)scan->n_Node.ln_Succ) {
  1011.     sprintf(Tmp + i, " %s%s", scan->n_In, scan->n_Out);
  1012.     i += strlen(Tmp + i);
  1013.     }
  1014.     return(Tmp);
  1015. }
  1016.  
  1017. #ifdef AZLAT_COMPAT
  1018.  
  1019. char *
  1020. OptListToStr2(list, cvt)
  1021. LIST *list;
  1022. char *cvt;
  1023. {
  1024.     static char Tmp[512];
  1025.     short i;
  1026.     NameNode *scan;
  1027.  
  1028.     i = 0;
  1029.     for (scan = (NameNode *)list->lh_Head; scan != (NameNode *)&list->lh_Tail; scan = (NameNode *)scan->n_Node.ln_Succ) {
  1030.     sprintf(Tmp + i, " %s%s", scan->n_In, scan->n_Out);
  1031.     {
  1032.         char *ptr;
  1033.         for (ptr = cvt; *ptr; ptr += 2) {
  1034.         if (Tmp[i+2] == ptr[0])
  1035.             Tmp[i+2] = ptr[1];
  1036.         }
  1037.     }
  1038.     i += strlen(Tmp + i);
  1039.     }
  1040.     return(Tmp);
  1041. }
  1042.  
  1043. #endif
  1044.  
  1045. /*
  1046.  *  run_cmd(buf)        buf[-1] is valid for BCPL stuff, buf[-1] is
  1047.  *            long word aligned.
  1048.  */
  1049.  
  1050. void
  1051. run_cmd(buf)
  1052. char *buf;
  1053. {
  1054.     short i;
  1055.     short j = strlen(buf);
  1056.     int r;
  1057.  
  1058.     if (Verbose)
  1059.     printf("%s\n", buf);
  1060.  
  1061.     if (ErrFile)
  1062.     fclose(stderr);
  1063.  
  1064. #if INCLUDE_VERSION >= 36
  1065.     if (SysBase->lib_Version >= 36) {
  1066.     long seg;
  1067.     long lock;
  1068.     char c;
  1069.  
  1070.     Process *proc = FindTask(NULL);
  1071.     CLI *cli = BTOC(proc->pr_CLI, CLI);
  1072.     long oldCommandName;
  1073.  
  1074.     if (DDebug)
  1075.         puts("cmd-begin");
  1076.  
  1077.     for (i = 0; buf[i] && buf[i] != ' '; ++i);
  1078.     c = buf[i];
  1079.     buf[i] = 0;
  1080.  
  1081.     if (cli) {
  1082.         oldCommandName = (long)cli->cli_CommandName;
  1083.         buf[-1] = i;
  1084.         cli->cli_CommandName = CTOB(buf - 1);
  1085.     }
  1086.  
  1087.     if (seg = FindSegment(buf, 0L, 0)) {
  1088.         r = RunCommand(((long *)seg)[2], 8192, buf + i + 1, strlen(buf + i + 1));
  1089.     } else if ((lock = _SearchPath(buf)) && seg = LoadSegLock(lock)) {
  1090.         r = RunCommand(seg, 8192, buf + i + 1, strlen(buf + i + 1));
  1091.         UnLoadSeg(seg);
  1092.     } else {
  1093.         buf[i] = c;
  1094.         r = System(buf, NULL);
  1095.     }
  1096.     if (cli)
  1097.         cli->cli_CommandName = (BSTR)oldCommandName;
  1098.  
  1099.     if (DDebug)
  1100.         puts("cmd-end");
  1101.     } else {
  1102. #else
  1103.     {
  1104. #endif
  1105.  
  1106. #ifdef _DCC
  1107.     if (FastOpt == 0) {
  1108. #endif
  1109.         if (Execute(buf, NULL, Output()) != -1) {
  1110.         printf("Unable to Execute %s\n", buf);
  1111.         exit(1);
  1112.         }
  1113.         r = 0;
  1114. #ifdef NOTDEF
  1115.         r = IoErr();
  1116.         if (r && r != -1) {
  1117.         puts("Non-Zero exit code");
  1118.         exit(1);
  1119.         }
  1120. #endif
  1121.  
  1122. #ifdef _DCC
  1123.     } else {
  1124.         for (i = 0; buf[i] && buf[i] != ' '; ++i);
  1125.         buf[i] = 0;
  1126.         if (i != j) {
  1127.         for (++i; buf[i] == ' '; ++i);
  1128.         }
  1129.         r = exec_dcc(buf, buf + i);
  1130.     }
  1131. #endif
  1132.     }
  1133.     if (r) {
  1134.     printf("Exit code %d\n", r);
  1135.     exit(1);
  1136.     }
  1137.     if (ErrFile)
  1138.     freopen(ErrFile, "a", stderr);
  1139. }
  1140.  
  1141. int
  1142. OutOfDate(in, out)
  1143. char *in;
  1144. char *out;
  1145. {
  1146.     static FIB *InFib;
  1147.     static FIB *OutFib;
  1148.     BPTR inLock, outLock;
  1149.     FIB *inFib;
  1150.     FIB *outFib;
  1151.     int r = 1;
  1152.  
  1153.     if (NewOpt == 0)
  1154.     return(1);
  1155.  
  1156.     if (InFib == NULL) {
  1157.     InFib = malloc(sizeof(FIB));
  1158.     OutFib = malloc(sizeof(FIB));
  1159.     }
  1160.     inFib = InFib;
  1161.     outFib = OutFib;
  1162.  
  1163.     if (inLock = Lock(in, SHARED_LOCK)) {
  1164.     if (outLock = Lock(out, SHARED_LOCK)) {
  1165.         if (Examine(inLock, inFib) && Examine(outLock, outFib)) {
  1166.         if (inFib->fib_Date.ds_Days < outFib->fib_Date.ds_Days)
  1167.             r = 0;
  1168.         else if (inFib->fib_Date.ds_Days == outFib->fib_Date.ds_Days) {
  1169.             if (inFib->fib_Date.ds_Minute < outFib->fib_Date.ds_Minute)
  1170.             r = 0;
  1171.             else if (inFib->fib_Date.ds_Minute == outFib->fib_Date.ds_Minute) {
  1172.             if (inFib->fib_Date.ds_Tick < outFib->fib_Date.ds_Tick)
  1173.                 r = 0;
  1174.             }
  1175.         }
  1176.         }
  1177.         UnLock(outLock);
  1178.     }
  1179.     UnLock(inLock);
  1180.     }
  1181.     return(r);
  1182. }
  1183.  
  1184. void
  1185. HandleCFile(in, fc)
  1186. char *in;
  1187. int fc;
  1188. {
  1189.     char *asmName;
  1190.     char *objName;
  1191.  
  1192.     if (fc == 1 && OutFile && NoAsm)
  1193.     asmName = OutFile;
  1194.     else
  1195.     asmName = MungeFile(XFilePart(in), TmpDir, ".a");
  1196.  
  1197.     if (fc == 1 && OutFile && NoLink)
  1198.     objName = OutFile;
  1199.     else
  1200.     objName = MungeFile(in, OutDir, ".o");
  1201.  
  1202.     if (NoAsm) {        /*  in -> asmName           */
  1203.     if (OutOfDate(in, asmName))
  1204.         DoCompile(in, asmName);
  1205.     } else {        /*  in -> asmName -> objName*/
  1206.     if (OutOfDate(in, objName)) {
  1207.         PushTmpFile(asmName);
  1208.         if (NoIntermediateAssembly) {
  1209.         DoCompile(in, objName);
  1210.         } else {
  1211.         DoCompile(in, asmName);
  1212.         if (NoHeirOpt == 0)
  1213.             CreateObjPath(objName);
  1214.         DoAssemble(asmName, objName);
  1215.         }
  1216.         PopTmpFile(asmName);
  1217.         remove(asmName);
  1218.     }
  1219.     }
  1220.     AddName(&OList, NULL, objName);
  1221. }
  1222.  
  1223. void
  1224. HandleAFile(in, fc)
  1225. char *in;
  1226. int fc;
  1227. {
  1228.     char *objName;
  1229.  
  1230.     if (fc == 1 && OutFile && NoLink)
  1231.     objName = OutFile;
  1232.     else
  1233.     objName = MungeFile(in, OutDir, ".o");
  1234.  
  1235.     if (OutOfDate(in, objName)) {
  1236.     if (NoHeirOpt == 0)
  1237.         CreateObjPath(objName);
  1238.     DoAssemble(in, objName);
  1239.     }
  1240.     AddName(&OList, NULL, objName);
  1241. }
  1242.  
  1243. void
  1244. PushTmpFile(name)
  1245. char *name;
  1246. {
  1247.     NODE *node = malloc(sizeof(NODE) + strlen(name) + 1);
  1248.     if (node == NULL) {
  1249.     puts("Ran out of memory!");
  1250.     exit(1);
  1251.     }
  1252.     node->ln_Name = (char *)(node + 1);
  1253.     strcpy(node->ln_Name, name);
  1254.     AddHead(&TmpList, node);
  1255. }
  1256.  
  1257. void
  1258. PopTmpFile(name)
  1259. char *name;
  1260. {
  1261.     NODE *node = RemHead(&TmpList);
  1262.  
  1263.     if (node == NULL || strcmp(name, node->ln_Name) != 0) {
  1264.     puts("PopTmpFile: software error");
  1265.     exit(1);
  1266.     }
  1267.     free(node);
  1268. }
  1269.  
  1270. LoadSegLock(lock)
  1271. long lock;
  1272. {
  1273.     long oldLock;
  1274.     long seg;
  1275.  
  1276.     oldLock = CurrentDir(lock);
  1277.     seg = LoadSeg("");
  1278.     CurrentDir(oldLock);
  1279.     return(seg);
  1280. }
  1281.  
  1282. /*
  1283.  *    AZTEC C, LATTICE C COMPATIBILITY OPTIONS
  1284.  */
  1285.  
  1286. #ifdef AZLAT_COMPAT
  1287.  
  1288. DoLink(lfile)
  1289. char *lfile;
  1290. {
  1291.     switch(CompilerOpt) {
  1292.     case DICE_C:
  1293.     return(DoLink_Dice(lfile));
  1294.     case LATTICE_C:
  1295.     return(DoLink_Lattice(lfile));
  1296.     case AZTEC_C:
  1297.     return(DoLink_Aztec(lfile));
  1298.     }
  1299. }
  1300.  
  1301. DoCompile(in, out)
  1302. char *in;
  1303. char *out;
  1304. {
  1305.     switch(CompilerOpt) {
  1306.     case DICE_C:
  1307.     return(DoCompile_Dice(in, out));
  1308.     case LATTICE_C:
  1309.     return(DoCompile_Lattice(in, out));
  1310.     case AZTEC_C:
  1311.     return(DoCompile_Aztec(in, out));
  1312.     }
  1313.     return(0);
  1314. }
  1315.  
  1316. DoAssemble(in, out)
  1317. char *in;
  1318. char *out;
  1319. {
  1320.     switch(CompilerOpt) {
  1321.     case DICE_C:
  1322.     return(DoAssemble_Dice(in, out));
  1323.     case LATTICE_C:
  1324.     return(DoAssemble_Lattice(in, out));
  1325.     case AZTEC_C:
  1326.     return(DoAssemble_Aztec(in, out));
  1327.     }
  1328.     return(0);
  1329. }
  1330.  
  1331. char *
  1332. DoPrelink(void)
  1333. {
  1334.     switch(CompilerOpt) {
  1335.     case DICE_C:
  1336.     return(DoPrelink_Dice());
  1337.     case LATTICE_C:
  1338.     return(DoPrelink_Lattice());
  1339.     case AZTEC_C:
  1340.     return(DoPrelink_Aztec());
  1341.     }
  1342.     return(0);
  1343. }
  1344.  
  1345. /*
  1346.  *    ------------------------------------------------------------------
  1347.  */
  1348.  
  1349. DoCompile_Lattice(in, out)
  1350. char *in;
  1351. char *out;
  1352. {
  1353.     char *qq = "";
  1354.     char *cptmp = TmpFileName(".i");
  1355.     char *data = (SmallData) ? qq : " -b0";
  1356.  
  1357.     sprintf(Buf, "lc -o%s %s %s %s",
  1358.     out, OptListToStr2(&CppOptList, "DdIi"), data, in
  1359.     );
  1360.     run_cmd(Buf);
  1361.  
  1362.     free(cptmp);
  1363.     return(0);
  1364. }
  1365.  
  1366. DoAssemble_Lattice(in, out)
  1367. char *in;
  1368. char *out;
  1369. {
  1370.     sprintf(Buf, "asm -o%s %s", out, in);
  1371.     run_cmd(Buf);
  1372.     return(0);
  1373. }
  1374.  
  1375. char *
  1376. DoPrelink_Lattice(void)
  1377. {
  1378.     NameNode *nn;
  1379.     char *ltmp = TmpFileName(".lnk");
  1380.     FILE *fi = fopen(ltmp, "w");
  1381.     short libs = 0;
  1382.  
  1383.     if (fi == NULL) {
  1384.     fprintf(stderr, "couldn't create %s\n", ltmp);
  1385.     exit(1);
  1386.     }
  1387.  
  1388.     while (nn = (NameNode *)RemHead(&OList)) {
  1389.     fputs(nn->n_In, fi);
  1390.     putc('\n', fi);
  1391.     }
  1392.  
  1393.     while (nn = (NameNode *)RemHead(&LList)) {
  1394.     if (libs == 0) {
  1395.         fprintf(fi, "LIB ");
  1396.         libs = 1;
  1397.     }
  1398.     fputs(nn->n_In, fi);
  1399.     putc('\n', fi);
  1400.     }
  1401.     if (RomOpt == 0 && NoDefaultLibs == 0) {
  1402.     if (libs == 0) {
  1403.         fprintf(fi, "LIB ");
  1404.         libs = 1;
  1405.     }
  1406.     fprintf(fi, "lib:lc.lib lib:amiga.lib\n");
  1407.     }
  1408.  
  1409.     fclose(fi);
  1410.     return(ltmp);
  1411. }
  1412.  
  1413. DoLink_Lattice(lfile)
  1414. char *lfile;
  1415. {
  1416.     char *qq = "";
  1417.     char *co = " ";
  1418.     char *symopt = (SymOpt) ? " ADDSYM" : qq;
  1419.     char *scopt = (SmallData) ? " SD" : qq;
  1420.     char *sdopt = (SmallCode) ? " SC" : qq;
  1421.  
  1422.     if (RomOpt == 0 && NoDefaultLibs == 0) {       /*  RomOpt PIOpt ResOpt */
  1423.     static char *SCode[] = { "lib:c.o",         /*    0      0      0   */
  1424.                  "lib:cres.o",      /*    0      0      1   */
  1425.                  "lib:c.o",         /*    0      1      0   */
  1426.                  "lib:cres.o"       /*    0      1      1   */
  1427.                    };
  1428.     co = SCode[(short)((PIOpt << 1) | ResOpt)];
  1429.     }
  1430.  
  1431.     if (OutFile == NULL)
  1432.     OutFile = "a.out";
  1433.  
  1434.     sprintf(Buf, "BLink from %s with %s to %s%s%s%s",
  1435.     co, lfile, OutFile, symopt, scopt, sdopt
  1436.     );
  1437.     run_cmd(Buf);
  1438.     return(0);
  1439. }
  1440.  
  1441. /*
  1442.  *  ---------------------------------------------------------------------
  1443.  */
  1444.  
  1445. DoCompile_Aztec(in, out)
  1446. char *in;
  1447. char *out;
  1448. {
  1449.     char *qq = "";
  1450.     char *cptmp = TmpFileName(".i");
  1451.     char *data = (SmallData) ? qq : qq;
  1452.  
  1453.     sprintf(Buf, "cc %s %s %s -o %s",
  1454.     OptListToStr2(&CppOptList, ""), data, in, out
  1455.     );
  1456.     run_cmd(Buf);
  1457.  
  1458.     free(cptmp);
  1459.     return(0);
  1460. }
  1461.  
  1462. DoAssemble_Aztec(in, out)
  1463. char *in;
  1464. char *out;
  1465. {
  1466.     sprintf(Buf, "as %s -o %s", in, out);
  1467.     run_cmd(Buf);
  1468.     return(0);
  1469. }
  1470.  
  1471. char *
  1472. DoPrelink_Aztec(void)
  1473. {
  1474.     NameNode *nn;
  1475.     char *ltmp = TmpFileName(".lnk");
  1476.     FILE *fi = fopen(ltmp, "w");
  1477.  
  1478.     if (fi == NULL) {
  1479.     fprintf(stderr, "couldn't create %s\n", ltmp);
  1480.     exit(1);
  1481.     }
  1482.  
  1483.     while (nn = (NameNode *)RemHead(&OList)) {
  1484.     fputs(nn->n_In, fi);
  1485.     putc('\n', fi);
  1486.     }
  1487.     while (nn = (NameNode *)RemHead(&LList)) {
  1488.     fputs(nn->n_In, fi);
  1489.     putc('\n', fi);
  1490.     }
  1491.     if (RomOpt == 0 && NoDefaultLibs == 0) {
  1492.     fprintf(fi, "-lc\n");
  1493.     }
  1494.     fclose(fi);
  1495.     return(ltmp);
  1496. }
  1497.  
  1498. DoLink_Aztec(lfile)
  1499. char *lfile;
  1500. {
  1501.     char *qq = "";
  1502.  
  1503.     if (OutFile == NULL)
  1504.     OutFile = "a.out";
  1505.  
  1506.     sprintf(Buf, "ln -f %s -o %s", lfile, OutFile);
  1507.     run_cmd(Buf);
  1508.     return(0);
  1509. }
  1510.  
  1511. #endif
  1512.  
  1513. void
  1514. OrderApp(buf)
  1515. char *buf;
  1516. {
  1517.     short i;
  1518.     short c;
  1519.     char sort[26];
  1520.  
  1521.     setmem(sort, sizeof(sort), 0);
  1522.     for (i = 0; c = buf[i]; ++i) {
  1523.     if (c >= 'a' && c <= 'z')
  1524.         sort[c-'a'] = 1;
  1525.     }
  1526.     for (i = sizeof(sort) - 1, c = 0; i >= 0; --i) {
  1527.     if (sort[i])
  1528.         buf[c++] = i + 'a';
  1529.     }
  1530.     buf[c] = 0;
  1531. }
  1532.  
  1533. void
  1534. AddLibApp(buf, c)
  1535. char *buf;
  1536. char c;
  1537. {
  1538.     short i = strlen(buf);
  1539.  
  1540.     if (strchr(buf, c) == NULL) {
  1541.     buf[i+0] = c;
  1542.     buf[i+1] = 0;
  1543.     }
  1544. }
  1545.  
  1546. void
  1547. DelLibApp(buf, c)
  1548. char *buf;
  1549. char c;
  1550. {
  1551.     char *ptr;
  1552.  
  1553.     if (ptr = strchr(buf, c))
  1554.     movmem(ptr + 1, ptr, strlen(ptr + 1) + 1);
  1555. }
  1556.  
  1557.