home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / prog_c / cc.lzh / CC / LATTICE / LC.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-11-01  |  8.8 KB  |  440 lines
  1. /* Z editor options
  2. :ma=1
  3. :ts=6
  4. :bk=0
  5. :wm=0
  6. */
  7.  
  8. /*
  9.     This program, both executable and sources, are
  10.     Copyright 1986, Jay Ts, Box 890 West Oneonta NY 13861.
  11.     You may copy, distribute, alter, and use them, but absolutely no
  12.     permission is granted to remove copyright notices from them or
  13.     distribute them, in whole or in part, as, or as part of, a
  14.     commercial product.
  15. */
  16.  
  17. /* put copyright notice in executable */
  18. char copyright_notice[] = "\nCopyright 1986, Jay Ts\n";
  19.  
  20. #include "lc.h"
  21.  
  22. extern int geterrs();
  23.  
  24. /* CLI command line used in DOS Execute()'s */
  25.  
  26. char cli[256];
  27.  
  28. /* option strings for the different phases */
  29.  
  30. char c1opts[128], c2opts[128], asopts[128];
  31.  
  32. /* lists of Assembly, C, and object files, and numbers of each */
  33.  
  34. #define MFIL 32
  35. char afiles[MFIL][32], cfiles[MFIL][32], ofiles[MFIL][32];
  36. int numcfiles = 0, numafiles = 0, numofiles = 0;
  37.  
  38. char pname[64];    /* the name of the output executable program */
  39. char qfile[64];    /* where to put the Lattice ".q" file (default in ram:) */
  40. char errfile[32];    /* the error redirection file - gets filtered by geterrs() */
  41.  
  42. /* FLAGS */
  43.  
  44. int saveobj = 0;        /* move object files from ram: when done; don't rm */
  45. int printonly = 0;    /* just print what is to be done; don't execute */
  46. int linting = 0;        /* check for errors only; don't compile/link */
  47. int debugflag = 0;    /* compile/link for debugging environment */
  48. int fastlink = 0;        /* link with "faster" option */
  49.  
  50. /*
  51.     CorOfiles: if only assembling into an object file,
  52.     and no C compiles or .o files from previous compiles are involved
  53. */
  54. int CorOfiles = 1;
  55.  
  56. int errors = 0;    /* true if ran into errors */
  57.  
  58. main(argc,argv)
  59. int argc;
  60. char *argv[];
  61. {
  62.     int i, l;
  63.  
  64.     if(argc == 1 || argv[1][0] == '?')
  65.     {
  66.         Execute("more <* >* lc:src/lc.doc",0L,0L);
  67.         exit(0);
  68.     }
  69.  
  70.     /* initialize file names ... */
  71.  
  72.     strcpy(errfile,"ram:lcom_errs");
  73.     strcpy(qfile,"ram:");
  74.     strcpy(pname,"");
  75.  
  76.     /* ... and file lists, and options strings */
  77.  
  78.     for(i = 0; i < MFIL; i++)
  79.     {
  80.         strcpy(ofiles[i],"");
  81.         strcpy(cfiles[i],"");
  82.         strcpy(afiles[i],"");
  83.     }
  84.  
  85.     strcpy(c1opts," -ilc:include/");
  86.     strcat(c1opts," -ilc:include/lattice/");
  87.     strcpy(c2opts,"");
  88.     strcpy(asopts,"-i lc:include_asm/ ");
  89.  
  90.     /*
  91.         process command line =>
  92.         options for (LC1 | LC2 | assem)
  93.         or files (.c | .a | .o)
  94.     */
  95.  
  96.     for(i = 1; i < argc; i++)
  97.     {
  98.         if(argv[i][0] == '-') /* an option */
  99.         {
  100.             switch(argv[i][1])
  101.             {
  102.                  case 'A':
  103.                       CorOfiles = 0;
  104.                       break;
  105.                  case 'C':
  106.                       saveobj = 1;
  107.                       break;
  108.                  case 'F':
  109.                       fastlink = 1;
  110.                       break;
  111.                  case 'P':
  112.                       printonly = 1;
  113.                       break;
  114.                  case 'L':
  115.                       linting = 1;
  116.                       break;
  117.                  case 'a':
  118.                       argv[i][1] = argv[i][2];
  119.                       argv[i][2] = '\0';
  120.                       strcat(asopts,argv[i]);
  121.                       strcat(asopts," ");
  122.                       strcat(asopts,argv[++i]);
  123.                       strcat(asopts," ");
  124.                       break;
  125.                  case 'b':
  126.                  case 'c':
  127.                  case 'i':
  128.                  case 'l':
  129.                  case 'n':
  130.                  case 'p':
  131.                  case 'u':
  132.                  case 'x':
  133.                       strcat(c1opts," ");
  134.                       strcat(c1opts,argv[i]);
  135.                       break;
  136.                  case 'q':
  137.                       strcpy(qfile, &argv[i][2]);
  138.                       break;
  139.                  case 'f':
  140.                  case 'o':
  141.                  case 'r':
  142.                  case 's':
  143.                  case 'v':
  144.                       strcat(c2opts," ");
  145.                       strcat(c2opts,argv[i]);
  146.                       break;
  147.                  case 'd':
  148.                       strcat(c1opts," ");
  149.                       strcat(c1opts,argv[i]);
  150.                       if(strlen(argv[i]) == 2)
  151.                       {
  152.                            debugflag = 1;
  153.                            strcat(c2opts," ");
  154.                            strcat(c2opts,argv[i]);
  155.                       }
  156.                       break;
  157.                  default:
  158.                       printf("unknown option: \"%s\"\n", argv[i]);
  159.                       exit(1);
  160.                       break;
  161.             }
  162.         }
  163.         else /* a file - set pname if it's the first seen */
  164.         {
  165.             l = strlen(argv[i]);
  166.             if(argv[i][l-2] == '.')
  167.             {
  168.                  switch(argv[i][l-1])
  169.                  {
  170.                       case 'c':
  171.                            if(!numcfiles && !numafiles && !numofiles)
  172.                         {
  173.                             strncpy(pname,argv[i],l-2);
  174.                             pname[l-2] = '\0';
  175.                         }
  176.                         if(numcfiles == MFIL) toomany(".c");
  177.                            strncpy(cfiles[numcfiles],argv[i],l-2);
  178.                         cfiles[numcfiles][l-2] = '\0';
  179.                         numcfiles++;
  180.                            break;
  181.                       case 'a':
  182.                            if(!numcfiles && !numafiles && !numofiles)
  183.                         {
  184.                             strncpy(pname,argv[i],l-2);
  185.                             pname[l-2] = '\0';
  186.                         }
  187.                         if(numafiles == MFIL) toomany(".a");
  188.                            strncpy(afiles[numafiles],argv[i],l-2);
  189.                         afiles[numafiles][l-2] = '\0';
  190.                         numafiles++;
  191.                            break;
  192.                       case 'o':
  193.                            if(!numcfiles && !numafiles && !numofiles)
  194.                         {
  195.                             strncpy(pname,argv[i],l-2);
  196.                             pname[l-2] = '\0';
  197.                         }
  198.                         if(numofiles == MFIL) toomany(".o");
  199.                            strcpy(ofiles[numofiles],argv[i]);
  200.                         numofiles++;
  201.                            break;
  202.                       default:
  203.                            printf("not a .[cao] file: \"%s\"\n",
  204.                             argv[i]);
  205.                            exit(1);
  206.                            break;
  207.                  }
  208.             }
  209.             else
  210.             {
  211.                  printf("not a .c or .a or .o file: \"%s\"\n", argv[i]);
  212.                  exit(1);
  213.             }
  214.         }
  215.     }
  216.  
  217.     if(!numcfiles && !numafiles && !numofiles)
  218.     {
  219.         printf("no files to compile, assemble or link\n");
  220.         exit(1);
  221.     }
  222.  
  223.     if(numcfiles == 0 && numofiles == 0) CorOfiles = 0;
  224.  
  225.     /* COMPILE */
  226.  
  227.     strcat(c1opts," -o");
  228.     strcat(c1opts,qfile);
  229.  
  230.     for(i = 0; i < numcfiles; ++i)
  231.     {
  232.         /* Do PHASE 1 */
  233.  
  234.         /* build CLI command string */
  235.         strcpy(cli,"lc:c/lc1 > ");
  236.         strcat(cli,errfile);
  237.         strcat(cli,c1opts);    /* add options */
  238.         strcat(cli," ");
  239.         strcat(cli,cfiles[i]);    /* add file name */
  240.  
  241.         if(printonly) printf("%s\n",cli);
  242.         else
  243.         {
  244.             Execute(cli,0L,0L);
  245.             errors = geterrs(errfile, cfiles[i], c1phase, linting);
  246.         }
  247.  
  248.         if(errors || linting)    /* lint: just do 1st file & quit */
  249.         {
  250.             strcpy(cli,qfile);
  251.             strcat(cli,cfiles[i]);
  252.             strcat(cli,".q");
  253.             DeleteFile(cli);
  254.  
  255.             if(linting)
  256.             {
  257.                 if(i == numcfiles-1) exit(0);
  258.                 errors = 0;
  259.                 continue;
  260.             }
  261.             else cleanup(10);
  262.         }
  263.  
  264.         /* Do PHASE 2 */
  265.  
  266.         /* build CLI command string */
  267.         strcpy(cli,"lc:c/lc2 > ");
  268.         strcat(cli,errfile);
  269.         strcat(cli,c2opts);    /* add options */
  270.         strcat(cli," ");
  271.         strcat(cli,qfile);    /* input is phase 1 output - .q file */
  272.         strcat(cli,cfiles[i]);
  273.  
  274.         if(printonly) printf("%s\n",cli);
  275.         else
  276.         {
  277.             Execute(cli,0L,0L);
  278.             errors = geterrs(errfile,cfiles[i],c2phase,linting);
  279.         }
  280.         if(errors) cleanup(10);
  281.     }
  282.  
  283.     /* ASSEMBLE */
  284.  
  285.     for(i = 0; i < numafiles; i++)
  286.     {
  287.         /* build CLI command string */
  288.         strcpy(cli,"lc:c/assem ");
  289.         strcat(cli,afiles[i]);    /* file to assemble - source */
  290.         strcat(cli,".a ");
  291.         strcat(cli,asopts);    /* add options */
  292.         strcat(cli,"-v ");
  293.         strcat(cli,errfile);
  294.         strcat(cli," ");
  295.         if(debugflag) strcat(cli,"-c S ");
  296.         if( ! linting)    /* want an output file */
  297.         {
  298.             strcat(cli,"-o ");
  299.             strcat(cli,qfile);
  300.             strcat(cli,afiles[i]);
  301.             strcat(cli,".o");
  302.         }
  303.  
  304.         if(printonly) printf("%s\n",cli);
  305.         else
  306.         {
  307.             Execute(cli,0L,0L);
  308.             errors = geterrs(errfile,afiles[i],asphase,linting);
  309.         }
  310.  
  311.         if(linting) errors = 0;
  312.         if(errors) cleanup(10);
  313.     }
  314.  
  315.     if(linting) exit(0);
  316.     if(saveobj) cleanup(0);
  317.  
  318.     /* LINK */
  319.  
  320.     /* build command line */
  321.     strcpy(cli,"lc:c/alink > ");
  322.     strcat(cli,errfile);
  323.     strcat(cli," ");
  324.     if(CorOfiles) strcat(cli,"lc:lib/LStartup.obj");
  325.  
  326.     /* build list of .o files from C, Assy and .o files */
  327.  
  328.     for(i = 0; i < numcfiles; i++)
  329.     {
  330.         strcat(cli, "+");
  331.         strcat(cli, qfile);
  332.         strcat(cli, cfiles[i]);
  333.         strcat(cli, ".o");
  334.     }
  335.  
  336.     for(i = 0; i < numafiles; i++)
  337.     {
  338.         if(CorOfiles || i > 0) strcat(cli, "+");
  339.         strcat(cli, qfile);
  340.         strcat(cli, afiles[i]);
  341.         strcat(cli, ".o");
  342.     }
  343.  
  344.     for(i = 0; i < numofiles; i++)
  345.     {
  346.         strcat(cli, "+");
  347.         strcat(cli, ofiles[i]);
  348.     }
  349.  
  350.     strcat(cli, " TO ");
  351.     strcat(cli, pname);
  352.     strcat(cli, " LIB ");
  353.     if(CorOfiles) strcat(cli,"lc:lib/lc.lib+");
  354.     strcat(cli,"lc:lib/amiga.lib");
  355.     if(debugflag) strcat(cli,"+lc:lib/debug.lib");
  356.     if(fastlink) strcat(cli," faster");
  357.  
  358.     if(printonly) printf("%s\n",cli);
  359.     else
  360.     {
  361.         Execute(cli,0L,0L);
  362.         errors = geterrs(errfile,"link",lkphase,linting);
  363.     }
  364.  
  365.     if(errors) cleanup(10);
  366.     else cleanup(0);
  367. }
  368.  
  369. cleanup(err)
  370. int err;
  371. {
  372.     int i;
  373.  
  374.     if(err) DeleteFile(pname);
  375.  
  376.     if(saveobj)
  377.     {
  378.         /* save object files from ram: */
  379.  
  380.         for(i = 0; i < numcfiles; ++i)
  381.         {
  382.             strcpy(cli,"copy ");
  383.             strcat(cli,qfile);
  384.             strcat(cli,cfiles[i]);
  385.             strcat(cli,".o ");
  386.             strcat(cli,cfiles[i]);
  387.             strcat(cli,".o");
  388.  
  389.             if(printonly) printf("%s\n",cli);
  390.             else Execute(cli,0L,0L);
  391.         }
  392.  
  393.         for(i = 0; i < numafiles; ++i)
  394.         {
  395.             strcpy(cli,"copy ");
  396.             strcat(cli,qfile);
  397.             strcat(cli,afiles[i]);
  398.             strcat(cli,".o ");
  399.             strcat(cli,afiles[i]);
  400.             strcat(cli,".o");
  401.  
  402.             if(printonly) printf("%s\n",cli);
  403.             else Execute(cli,0L,0L);
  404.         }
  405.     }
  406.  
  407.     /* delete object files in ram: that were made by compile */
  408.  
  409.     for(i = 0; i < numcfiles; i++)
  410.     {
  411.         strcpy(cli,qfile);
  412.         strcat(cli,cfiles[i]);
  413.         strcat(cli,".o");
  414.  
  415.         if(printonly) printf("delete %s\n",cli);
  416.         else DeleteFile(cli);
  417.     }
  418.  
  419.     /* delete .o files in ram: made by assembler */
  420.  
  421.     for(i = 0; i < numafiles; i++)
  422.     {
  423.         strcpy(cli,qfile);
  424.         strcat(cli,afiles[i]);
  425.         strcat(cli,".o");
  426.  
  427.         if(printonly) printf("delete %s\n",cli);
  428.         else DeleteFile(cli);
  429.     }
  430.     exit(err);
  431. }
  432.  
  433. toomany(s)
  434. char *s;
  435. {
  436.     printf("lc: can't handle more than %d ",MFIL);
  437.     printf("%s files\n",s);
  438.     exit(10);
  439. }
  440.