home *** CD-ROM | disk | FTP | other *** search
/ messroms.de / 2007-01-13_www.messroms.de.zip / VZ200 / TOOLS / ZCCSRC.ZIP / zcc / zcc.c < prev   
C/C++ Source or Header  |  2000-03-03  |  6KB  |  250 lines
  1. /*
  2.  *    Driver for dcpp, sccz80, copt, asz80 and aslink
  3.  */
  4.  
  5. #include <stdlib.h>
  6. #include <stdio.h>
  7. #include <string.h>
  8.  
  9. #define PREPROCESSOR    "dcpp"
  10. #define    COMPILER    "sccz80"
  11. #define    ASSEMBLER    "asz80"
  12. #define    COPT        "copt"
  13. #define    COPTRULES    "rules"
  14. #define    LINKER        "aslink"
  15. #define    RTSTARTUP    "0crt.rel"
  16.  
  17. enum iostyle {
  18.     outimplied, outspecified, filter
  19. };
  20.  
  21. extern void *malloc();
  22.  
  23. int compileonly = 0;
  24. int verbose = 0;
  25. int peepholeopt = 0;
  26. int ncppargs = 0;
  27. char **cpparglist;
  28. int nfiles = 0;
  29. char **filelist;
  30. int nparms = 0;
  31. char **parmlist;
  32. char binpath[260];
  33. char libpath[260];
  34.  
  35. void *mustmalloc(int n)
  36. {
  37.     void *p;
  38.  
  39.     if ((p = malloc(n)) == 0)
  40.     {
  41.         fprintf(stderr, "malloc failed\n");
  42.         exit(1);
  43.     }
  44.     return (p);
  45. }
  46.  
  47. int hassuffix(char *name, char *suffix)
  48. {
  49.     int nlen, slen;
  50.  
  51.     nlen = strlen(name);
  52.     slen = strlen(suffix);
  53.  
  54.     if (slen > nlen)
  55.         return (0);
  56.     return (strcmp(&name[nlen - slen], suffix) == 0);
  57. }
  58.  
  59. char *changesuffix(char *name, char *suffix)
  60. {
  61.     char *p, *r;
  62.  
  63.     if ((p = strrchr(name, '.')) == 0)
  64.     {
  65.         r = mustmalloc(strlen(name) + strlen(suffix) + 1);
  66.         sprintf(r, "%s%s", name, suffix);
  67.     }
  68.     else
  69.     {
  70.         r = mustmalloc(p - name + strlen(suffix) + 1);
  71.         r[0] = '\0';
  72.         strncat(r, name, p - name);
  73.         strcat(r, suffix);
  74.     }
  75.     return (r);
  76. }
  77.  
  78. int process(char *suffix, char *nextsuffix, char *processor, char *extraargs, enum iostyle ios)
  79. {
  80.     int i, status, errs;
  81.     char *buffer = NULL, *outname;
  82.  
  83.     errs = 0;
  84.     for (i = 0; i < nfiles; ++i)
  85.     {
  86.         if (!hassuffix(filelist[i], suffix))
  87.             continue;
  88.         switch (ios)
  89.         {
  90.         case outimplied:
  91.             buffer = mustmalloc(strlen(binpath) + strlen(processor) + strlen(extraargs) + strlen(filelist[i]) + 3);
  92.             sprintf(buffer, "%s%s %s %s", binpath, processor, extraargs, filelist[i]);
  93.             break;
  94.         case outspecified:
  95.             outname = changesuffix(filelist[i], nextsuffix);
  96.             buffer = mustmalloc(strlen(binpath) + strlen(processor) + strlen(extraargs) + strlen(filelist[i]) + strlen(outname) + 4);
  97.             sprintf(buffer, "%s%s %s %s %s", binpath, processor, extraargs, filelist[i], outname);
  98.             free(outname);
  99.             break;
  100.         case filter:
  101.             outname = changesuffix(filelist[i], nextsuffix);
  102.             buffer = mustmalloc(strlen(binpath) + strlen(processor) + strlen(binpath) + strlen(extraargs) + strlen(filelist[i]) + strlen(outname) + 8);
  103.             sprintf(buffer, "%s%s %s%s < %s > %s", binpath, processor, binpath, extraargs, filelist[i], outname);
  104.             free(outname);
  105.         }
  106.         if (verbose)
  107.             puts(buffer);
  108.         status = system(buffer);
  109.         if ((status >> 8) != 0)
  110.             errs = 1;
  111.         else
  112.             filelist[i] = changesuffix(filelist[i], nextsuffix);
  113.         free(buffer);
  114.     }
  115.     return (errs);
  116. }
  117.  
  118. int linkthem(char *linker)
  119. {
  120.     int i, n, status;
  121.     char *output, *p;
  122.  
  123.     n = strlen(binpath);
  124.     n += strlen(linker) + 1;
  125.     n += sizeof ("-v -m -o");
  126.     output = changesuffix(filelist[0], ".ihx");
  127.     n += strlen(output) + 1;
  128.     n += strlen(libpath) + 1;
  129.     n += sizeof (RTSTARTUP);
  130.     for (i = 0; i < nparms; ++i)
  131.         n += strlen(parmlist[i]) + 1;
  132.     for (i = 0; i < nfiles; ++i)
  133.     {
  134.         if (hassuffix(filelist[i], ".rel"))
  135.             n += strlen(filelist[i]) + 1;
  136.     }
  137.     p = mustmalloc(n);
  138.     sprintf(p, "%s%s -v -m -o %s", binpath, linker, output);
  139.     for (i = 0; i < nparms; ++i)
  140.     {
  141.         strcat(p, " ");
  142.         strcat(p, parmlist[i]);
  143.     }
  144.     strcat(p, " ");
  145.     strcat(p, libpath);
  146.     strcat(p, RTSTARTUP);
  147.     for (i = 0; i < nfiles; ++i)
  148.     {
  149.         if (hassuffix(filelist[i], ".rel"))
  150.         {
  151.             strcat(p, " ");
  152.             strcat(p, filelist[i]);
  153.         }
  154.     }
  155.     if (verbose)
  156.         printf("%s\n", p);
  157.     status = system(p);
  158.     free(p);
  159.     return ((status >> 8) != 0);
  160. }
  161.  
  162. int main(int argc, char **argv)
  163. {
  164.     int i, n;
  165.     char *cpparg, *name;
  166.  
  167.     strcpy(binpath, argv[0]);
  168.     name = strrchr(binpath, '/');
  169.     if (name)
  170.         name[1] = '\0';
  171.     else
  172.         strcpy(binpath, "./");
  173.     strcpy(libpath, "lib/");
  174.  
  175.     /* allocate enough pointers for all files, slight overestimate */
  176.     filelist = (char **)mustmalloc(sizeof (char *) * argc);
  177.  
  178.     /* ditto for -Ddef=val, -Udef, -I, huge overestimate */
  179.     cpparglist = (char **)mustmalloc(sizeof (char *) * argc);
  180.  
  181.     /* ditto for -bX=Y and -gX=Y, huge overestimate */
  182.     parmlist = (char **)mustmalloc(sizeof (char *) * argc);
  183.  
  184.     for (i = 1; i < argc; ++i)
  185.     {
  186.         if (argv[i][0] == '-')
  187.         {
  188.             switch (argv[i][1])
  189.             {
  190.             case 'b':
  191.             case 'g':
  192.                 parmlist[nparms++] = argv[i];
  193.                 break;
  194.             case 'c':
  195.                 compileonly = 1;
  196.                 break;
  197.             case 'D':
  198.             case 'I':
  199.             case 'U':
  200.                 cpparglist[ncppargs++] = argv[i];
  201.                 break;
  202.             case 'O':
  203.                 peepholeopt = 1;
  204.                 break;
  205.             case 'v':
  206.                 verbose = 1;
  207.                 break;
  208.             }
  209.         }
  210.         else
  211.             filelist[nfiles++] = argv[i];
  212.     }
  213.     n = 1;        /* guarantee that we'll malloc something */
  214.     for (i = 0; i < ncppargs; ++i)
  215.         n += strlen(cpparglist[i]) + 1;
  216.     cpparg = mustmalloc(n);
  217.     cpparg[0] = '\0';
  218.     for (i = 0; i < ncppargs; ++i)
  219.     {
  220.         strcat(cpparg, cpparglist[i]);
  221.         if (i < ncppargs - 1)
  222.             strcat(cpparg, " ");
  223.     }
  224.     if (nfiles <= 0)
  225.         exit(0);
  226.     if (process(".c", ".i", PREPROCESSOR, cpparg, outspecified))
  227.         exit(1);
  228.     if (peepholeopt)
  229.     {
  230.         if (process(".i", ".asm", COMPILER, "-x", outimplied))
  231.             exit(1);
  232.         if (process(".asm", ".opt", COPT, COPTRULES, filter))
  233.             exit(1);
  234.         if (process(".opt", ".rel", ASSEMBLER, "", outimplied))
  235.             exit(1);
  236.     }
  237.     else
  238.     {
  239.         if (process(".i", ".asm", COMPILER, "", outimplied))
  240.             exit(1);
  241.         if (process(".asm", ".rel", ASSEMBLER, "", outimplied))
  242.             exit(1);
  243.     }
  244.     if (compileonly)
  245.         exit(0);
  246.     if (linkthem(LINKER))
  247.         exit(1);
  248.     return 0;
  249. }
  250.