home *** CD-ROM | disk | FTP | other *** search
/ CP/M / CPM_CDROM.iso / cpm / cpm3 / cpmmake.ark / MAIN.C < prev    next >
Encoding:
C/C++ Source or Header  |  1986-08-31  |  6.1 KB  |  273 lines
  1. /*
  2.  *      make [-f makefile] [-nprst] [macro=val ...] [target(s) ...]
  3.  *
  4.  *    (Better than EON mk & old CPM make but not quite as good as UNIX make)
  5.  *
  6.  *    -f makefile name
  7.  *    -i don't ignore exit status         
  8.  *    -n Pretend to make
  9.  *    -p Print all macros & targets
  10.  *    -q Question up-to-dateness of target.  Return exit status 1 if not
  11.  *    -r Don't not use inbuilt rules
  12.  *    -s Make silently
  13.  *    -t Touch files instead of making them
  14.  *    -m Change memory requirements    - N/A under CP/M
  15.  */
  16.  
  17. #include "c:stdio.h"            /* c: is my ramdisk  */
  18. #include "c:fcntl.h"
  19. #include "h.h"
  20.  
  21. char Usage1[]="    -f makefile name\n\
  22.     -i don't ignore exit status\n\
  23.     -n Pretend to make\n\
  24.     -p Print all macros & targets\n\
  25.     -r Do not use inbuilt rules\n\
  26.     -s Make silently\n\
  27.     -t Touch files instead of making them\n";
  28.  
  29.  
  30. #define MEMSPACE    (16384)        /* superfluous under cp/m */
  31.  
  32.  
  33. char *            myname;
  34. char *            makefile;    /*  The make file  */
  35. unsigned        memspace = MEMSPACE;
  36.  
  37. extern FILE *execfile;
  38.  
  39. FILE *            ifd;        /*  Input file desciptor  */
  40. bool            domake = TRUE;    /*  Go through the motions option  */
  41. bool            ignore = TRUE;    /*  Ignore exit status option  */
  42. bool            silent = FALSE;    /*  Silent option  */
  43. bool            print = FALSE;    /*  Print debuging information  */
  44. bool            rules = TRUE;    /*  Use inbuilt rules  */
  45. bool            dotouch = FALSE;/*  Touch files instead of making  */
  46. bool            quest = FALSE;    /*  Question up-to-dateness of file  */
  47.  
  48.  
  49. void
  50. main(argc, argv)
  51. char **            argv;
  52. int            argc;
  53. {
  54.     register char *        p;    /*  For argument processing  */
  55.     int            estat;    /*  For question  */
  56.     register struct name *    np;
  57.  
  58.  
  59.     /*
  60.      * CP/M makes all command line junque upper case.  All things
  61.      * being equal, I'd rather they be all forced lower.  So I will.
  62.      *
  63.      * I have also forced everything in the makefile to lower case,
  64.      * so everything should be case insensitive.
  65.      */
  66.     for (estat = argc ; --estat > 0 ;) {
  67.             strlower(argv[estat]);
  68.     }
  69.  
  70.     unlink(MAKERUN);    /* delete possible existing make-submit file */
  71.  
  72.     myname = (argc-- < 1) ? "make" : *argv++;
  73.     /*
  74.      * CP/M can't do argv[0] (OS limitation), so we don't know who we are.
  75.      */
  76.     myname = "make";
  77.  
  78.     while ((argc > 0) && (**argv == '-'))
  79.     {
  80.         argc--;        /*  One less to process  */
  81.         p = *argv++;    /*  Now processing this one  */
  82.  
  83.         while (*++p != '\0')
  84.         {
  85.             /*
  86.              * Elaborate switch not really needed, but I
  87.              * hacked this in before I made all argv parameters
  88.              * lower case (for cp/m).
  89.              */
  90.             switch( isupper(*p) ? tolower (*p) : *p )
  91.             {
  92.             case 'f':    /*  Alternate file name  */
  93.                 if (*++p == '\0')
  94.                 {
  95.                     if (argc-- <= 0)
  96.                         usage();
  97.                     p = *argv++;
  98.                 }
  99.                 makefile = p;
  100.                 goto end_of_args;
  101.             case 'm':    /*  Change space requirements  */
  102.                 if (*++p == '\0')
  103.                 {
  104.                     if (argc-- <= 0)
  105.                         usage();
  106.                     p = *argv++;
  107.                 }
  108.                 memspace = atoi(p);
  109.                 goto end_of_args;
  110.             case 'n':    /*  Pretend mode  */
  111.                 domake = FALSE;
  112.                 break;
  113.             case 'i':    /*  Ignore fault mode  */
  114.                 ignore = FALSE;
  115.                 break;
  116.             case 's':    /*  Silent about commands  */
  117.                 silent = TRUE;
  118.                 break;
  119.             case 'p':
  120.                 print = TRUE;
  121.                 break;
  122.             case 'r':
  123.                 rules = FALSE;
  124.                 break;
  125.             case 't':
  126.                 dotouch = TRUE;
  127.                 break;
  128.             case 'q':
  129.                 quest = TRUE;
  130.                 break;
  131.             default:    /*  Wrong option  */
  132.                 usage();
  133.             }
  134.         }
  135.     end_of_args:;
  136.     }
  137.  
  138. /*    if (initalloc(memspace) == 0xffff)    Must get memory for alloc  
  139.         fatal("Cannot initalloc memory");
  140. */
  141.     if (strcmp(makefile, "-") == 0)    /*  Can use stdin as makefile  */
  142.         ifd = stdin;
  143.     else
  144.         if (!makefile)        /*  If no file, then use default */
  145.         {
  146.              if ((ifd = fopen(DEFN1, "r")) == (FILE *)0 
  147.               && ((ifd = fopen(DEFN2, "r")) == (FILE *)0)) {
  148.                 fatal("Can't open %s or %s; error %02x",
  149.                              DEFN1,DEFN2, errno);
  150.              }
  151.             
  152.         }
  153.         else
  154.             if ((ifd = fopen(makefile, "r")) == (FILE *)0)
  155.                 fatal("Can't open %s", makefile);
  156.  
  157.     if (rules)
  158.         makerules();
  159.  
  160.     setmacro("$", "$");
  161.  
  162.     while (argc && (p = index(*argv, '=')))
  163.     {
  164.         char        c;
  165.  
  166.         c = *p;
  167.         *p = '\0';
  168.         setmacro(*argv, p+1);
  169.         *p = c;
  170.  
  171.         argv++;
  172.         argc--;
  173.     }
  174.  
  175.     input(ifd);    /*  Input all the gunga  */
  176.     fclose(ifd);    /*  Finished with makefile  */
  177.     lineno = 0;    /*  Any calls to error now print no line number */
  178.  
  179.     if (print)
  180.         prt();    /*  Print out structures  */
  181.  
  182.     np = newname(".SILENT");
  183.     if (np->n_flag & N_TARG)
  184.         silent = TRUE;
  185.  
  186.     np = newname(".IGNORE");
  187.     if (np->n_flag & N_TARG)
  188.         ignore = TRUE;
  189.  
  190.     precious();
  191.  
  192.     if (!domake)
  193.         silent = FALSE;
  194.  
  195.     if (!firstname)
  196.         fatal("No targets defined");
  197.  
  198.     circh();    /*  Check circles in target definitions  */
  199.  
  200.     if (!argc)
  201.         estat = make(firstname, 0);
  202.     else while (argc--)
  203.     {
  204.         if (!print && !silent && strcmp(*argv, "love") == 0)
  205.             printf("Not war!\n");
  206.         estat |= make(newname(*argv++), 0);
  207.     }
  208.  
  209.  
  210.     if (execfile == NULL) {
  211.         exit(0);    /* no file made, must be up to date! */
  212.     }
  213.  
  214.     /*
  215.      * The "trick" algorithm used for CP/M (which can't execute
  216.      * commands while "make" is running) is that dosh() really
  217.      * puts commands into a submit file MAKERUN, then after
  218.      * the make is "done", that submit file is chained-to (below).
  219.      * The first code-line below enters the submit file's last command
  220.      * to delete itself (so this chaining trick is mostly transparent.
  221.      *
  222.      *                        -mdk
  223.      */
  224.  
  225.     dosh("era ",MAKERUN);   /* have the submit file delete itself */
  226.     dosh("\n","");
  227.     fclose(execfile);    /* close the writing to this file     */
  228.  
  229.     bdos(108,0);        /* Reset CP/M Program return code     */
  230.  
  231.     strcpy((char *)0x80,MAKERUN);    /* load submit file name into DMA buf*/
  232.     bdos(47,0xff);        /* chain to the generated submit file */
  233.  
  234.  
  235. /*    if (quest)
  236.         exit(estat);
  237.     else
  238.         exit(0);
  239. */
  240.  
  241. }
  242.  
  243.  
  244. usage()
  245. {
  246.     fprintf(stderr, "Usage: %s [-f makefile] [-nprst] [macro=val ...] [target(s) ...]\n%s", myname,Usage1);
  247.     exit(1);
  248. }
  249.  
  250.  
  251. void
  252. fatal(msg, a1, a2, a3)
  253. char    *msg;
  254. {
  255.     fprintf(stderr, "%s: ", myname);
  256.     fprintf(stderr, msg, a1, a2, a3);
  257.     fputc('\n', stderr);
  258.     exit(1);
  259. }
  260.  
  261.  
  262.     
  263. strlower(string)
  264. char *string;
  265. {
  266.     register char *pointer;
  267.     char c;
  268.     for (pointer = string ; (c=*pointer) != '\0' ; pointer++ ) {
  269.         if (isupper(c))
  270.             *pointer = tolower(c);
  271.     }
  272. }
  273.