home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 387b.lha / dice_v2.02 / lib / libmake.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-05-30  |  6.7 KB  |  412 lines
  1.  
  2. /*
  3.  *  libmake.c
  4.  *
  5.  *  libmake  -n -oobjdir -l library file [-clean]
  6.  *
  7.  *  loads 'files' list and compiles out of date files accordingly, putting
  8.  *  objects in an alternate directory if requested.
  9.  *
  10.  */
  11.  
  12. #include <stdio.h>
  13. #include <stdlib.h>
  14. #include <exec/types.h>
  15. #include <libraries/dos.h>
  16.  
  17. #define EF_OOD        0x01
  18. #define EF_COMP     0x02
  19.  
  20. typedef struct {
  21.     char *SrcName;
  22.     char *ObjName;
  23.     long Flags;
  24. } NameNode;
  25.  
  26. typedef struct DateStamp DateStamp;
  27.  
  28. char Prefix[64];
  29. char *CtlFile = "files";
  30. char *ObjDir;
  31. char *DestLib;
  32. NameNode *NList;
  33. short    NumFiles;
  34. short    DccExec;
  35. short    DryRun;
  36. short    Verbose;
  37. short    Broke;
  38. short    Clean;
  39. static char Buf[128];
  40.  
  41. char *MungeFile();
  42. char *GetIndex();
  43. void TimeCompareFiles();
  44. void help();
  45.  
  46. int
  47. brk()
  48. {
  49.     Broke = 1;
  50.     return(0);
  51. }
  52.  
  53. main(ac, av)
  54. char *av[];
  55. {
  56.     char *nameBuf;
  57.  
  58.     onbreak(brk);
  59.  
  60.     /*
  61.      *    calculate prefix
  62.      */
  63.  
  64. #ifdef _DCC
  65.     DccExec = 1;
  66. #else
  67.     DccExec = 0;
  68. #endif
  69.  
  70.     {
  71.     char *ptr = av[0];
  72.     short len = strlen(ptr);
  73.  
  74.     while (len >= 0 && ptr[len] != '/' && ptr[len] != ':')
  75.         --len;
  76.     ptr = ptr + len + 1;    /*  file part    */
  77.  
  78.     for (len = 0; ptr[len] && ptr[len] != '_'; ++len);
  79.     if (ptr[len] == '_')
  80.         ++len;
  81.     else
  82.         len = 0;
  83.     strncpy(Prefix, ptr, len);
  84.     Prefix[len] = 0;
  85.     }
  86.     {
  87.     short i;
  88.  
  89.     for (i = 1; i < ac; ++i) {
  90.         char *ptr = av[i];
  91.         if (*ptr != '-') {
  92.         CtlFile = ptr;
  93.         continue;
  94.         }
  95.         ptr += 2;
  96.         switch(ptr[-1]) {
  97.         case 'v':
  98.         Verbose = 1;
  99.         break;
  100.         case 'n':
  101.         DryRun = 1;
  102.         break;
  103.         case 'o':
  104.         if (*ptr)
  105.             ObjDir = ptr;
  106.         else
  107.             ObjDir = av[++i];
  108.         break;
  109.         case 'l':
  110.         if (*ptr)
  111.             DestLib = ptr;
  112.         else
  113.             DestLib = av[++i];
  114.         break;
  115.         case 'c':
  116.         Clean = 1;
  117.         DestLib = "";
  118.         break;
  119.         default:
  120.         help();
  121.         exit(1);
  122.         }
  123.     }
  124.     if (i > ac) {
  125.         help();
  126.         exit(1);
  127.     }
  128.     }
  129.     if (ObjDir == NULL) {
  130.     puts("must specify an output directory for objects (-o)");
  131.     exit(1);
  132.     }
  133.     if (DestLib == NULL) {
  134.     puts("must specify output library (-l)");
  135.     exit(1);
  136.     }
  137.     {
  138.     FILE *fi = fopen(CtlFile, "r");
  139.     long siz;
  140.  
  141.     if (fi == NULL) {
  142.         perror("fopen");
  143.         exit(1);
  144.     }
  145.     fseek(fi, 0L, 2);
  146.     siz = ftell(fi);
  147.     if (siz < 0) {
  148.         perror("fseek");
  149.         exit(1);
  150.     }
  151.     fseek(fi, 0L, 0);
  152.     nameBuf = malloc(siz + 1);
  153.     if (fread(nameBuf, siz, 1, fi) != 1) {
  154.         perror("fread");
  155.         exit(1);
  156.     }
  157.     fclose(fi);
  158.     nameBuf[siz] = 0;
  159.     }
  160.     {
  161.     char *namePtr;
  162.     char *getIdx;
  163.     long files = 0;
  164.     NameNode *nn;
  165.  
  166.     getIdx = nameBuf;
  167.  
  168.     for (namePtr = GetIndex(&getIdx); *namePtr; namePtr = GetIndex(&getIdx))
  169.         ++files;
  170.     NList = malloc(sizeof(NameNode) * files);
  171.  
  172.     nn = NList;
  173.  
  174.     getIdx = nameBuf;
  175.     NumFiles = 0;
  176.     for (namePtr = GetIndex(&getIdx); *namePtr; namePtr = GetIndex(&getIdx)) {
  177.         if (*namePtr == ';')
  178.         continue;
  179.         nn->Flags = 0;
  180.         nn->SrcName = namePtr;
  181.         nn->ObjName = MungeFile(nn->SrcName, ObjDir);
  182.         ++nn;
  183.         ++NumFiles;
  184.     }
  185.     }
  186.  
  187.     if (Clean) {
  188.     NameNode *nn;
  189.     short i;
  190.  
  191.     for (i = 0, nn = NList; i < NumFiles; ++i, ++nn) {
  192.         printf("%s\n", nn->ObjName);
  193.         remove(nn->ObjName);
  194.     }
  195.     } else {
  196.     TimeCompareFiles();
  197.     if (CompileFiles() == 0) {
  198.         ALibMake();
  199.     }
  200.     }
  201.     return(0);
  202. }
  203.  
  204. void
  205. help()
  206. {
  207.     fprintf(stderr, "libmake [-n] files -o objdir/ -l library [-clean]\n");
  208. }
  209.  
  210. void
  211. TimeCompareFiles()
  212. {
  213.     NameNode *nn;
  214.     short i;
  215.     DateStamp d1;
  216.     DateStamp d2;
  217.  
  218.     for (i = 0, nn = NList; i < NumFiles; ++i, ++nn) {
  219.     if (GetFileTime(nn->SrcName, &d1)) {
  220.         fprintf(stderr, "unable to find %s\n", nn->SrcName);
  221.         continue;
  222.     }
  223.     if (GetFileTime(nn->ObjName, &d2) == 0) {
  224.         if (d1.ds_Days < d2.ds_Days)
  225.         continue;
  226.         if (d1.ds_Days == d2.ds_Days) {
  227.         if (d1.ds_Minute < d2.ds_Minute)
  228.             continue;
  229.         if (d1.ds_Minute == d2.ds_Minute) {
  230.             if (d1.ds_Tick < d2.ds_Tick)
  231.             continue;
  232.         }
  233.         }
  234.     }
  235.     nn->Flags |= EF_OOD;
  236.     }
  237. }
  238.  
  239. CompileFiles()
  240. {
  241.     NameNode *nn;
  242.     short i;
  243.     int errs = 0;
  244.  
  245.     for (i = 0, nn = NList; i < NumFiles; ++i, ++nn) {
  246.     if (nn->Flags & EF_OOD) {
  247.         short j;
  248.         for (j = strlen(nn->SrcName) - 1; j >= 0 && nn->SrcName[j] != '.'; --j);
  249.         ++j;
  250.         if (j > 0 && (nn->SrcName[j]|0x20) == 'a') {
  251.         if (nn->SrcName[j+1] == '6')
  252.             errs += AssembleA68K(nn->SrcName, nn->ObjName);
  253.         else
  254.             errs += Assemble(nn->SrcName, nn->ObjName);
  255.         } else {
  256.         errs += Compile(nn->SrcName, nn->ObjName);
  257.         }
  258.     }
  259.     }
  260.     return(errs);
  261. }
  262.  
  263. Assemble(src, obj)
  264. char *src;
  265. char *obj;
  266. {
  267.     sprintf(Buf, "%sdas -o%s %s", Prefix, obj, src);
  268.     return(run_cmd(Buf, DccExec));
  269. }
  270.  
  271. AssembleA68K(src, obj)
  272. char *src;
  273. char *obj;
  274. {
  275.     sprintf(Buf, "a68k -o%s %s -q", obj, src);
  276.     return(run_cmd(Buf, 0));
  277. }
  278.  
  279.  
  280. Compile(src, obj)
  281. char *src;
  282. char *obj;
  283. {
  284.     char *verb = (Verbose) ? "-v" : "";
  285.  
  286.     sprintf(Buf, "%sdcc -c %s -o %s %s -S -r", Prefix, src, obj, verb);
  287.     return(run_cmd(Buf, DccExec));
  288. }
  289.  
  290. ALibMake()
  291. {
  292.     NameNode *nn;
  293.     short i;
  294.     FILE *fo;
  295.  
  296.     if (DryRun)
  297.     return(0);
  298.  
  299.     printf("Creating alink 'join' type libray %s\n", DestLib);
  300.     if (fo = fopen(DestLib, "w")) {
  301.     for (i = 0, nn = NList; i < NumFiles; ++i, ++nn) {
  302.         FILE *fi;
  303.         if (fi = fopen(nn->ObjName, "r")) {
  304.         int c;
  305.         while ((c = getc(fi)) != EOF)
  306.             putc(c, fo);
  307.         fclose(fi);
  308.         } else {
  309.         printf("Couldn't read %s\n", nn->ObjName);
  310.         }
  311.     }
  312.     fclose(fo);
  313.     } else {
  314.     printf("Unable to create %s\n", DestLib);
  315.     }
  316.     return(0);
  317. }
  318.  
  319.  
  320.  
  321. char *
  322. MungeFile(name, prefix)
  323. char *name;
  324. char *prefix;
  325. {
  326.     char *str;
  327.     char *postfix = ".o";
  328.     short i;
  329.  
  330.     for (i = strlen(name) - 1; i >= 0 && name[i] != '.'; --i);
  331.     if (i < 0)
  332.     i = strlen(name);
  333.     str = malloc(strlen(prefix) + i + strlen(postfix) + 1);
  334.     strcpy(str, prefix);
  335.     sprintf(str + strlen(str), "%.*s%s", (long)i, name, postfix);
  336.     return(str);
  337. }
  338.  
  339. char *
  340. GetIndex(ip)
  341. char **ip;
  342. {
  343.     char *ptr = *ip;
  344.     char *rp;
  345.  
  346.     while (*ptr == ' ' || *ptr == '\t' || *ptr == '\n')
  347.     ++ptr;
  348.     if (*ptr == 0)
  349.     return(ptr);
  350.     rp = ptr;
  351.     while (*ptr && *ptr != '\n')
  352.     ++ptr;
  353.     *ptr = 0;
  354.     *ip = ptr + 1;
  355.     return(rp);
  356. }
  357.  
  358. run_cmd(buf, dccExec)
  359. char *buf;
  360. {
  361.     printf("%s\n", buf);
  362.     if (Broke) {
  363.     printf("^C\n");
  364.     exit(1);
  365.     }
  366.     if (DryRun)
  367.     return(0);
  368.  
  369. #ifdef _DCC
  370.     if (dccExec) {
  371.     short i;
  372.     long r;
  373.  
  374.     for (i = 0; buf[i] && buf[i] != ' '; ++i);
  375.     if (buf[i] == ' ') {
  376.         buf[i] = 0;
  377.         for (++i; buf[i] == ' '; ++i);
  378.     }
  379.     r = exec_dcc(buf, buf + i);
  380.     if (r) {
  381.         printf("Exit code %d\n", r);
  382.         exit(1);
  383.     }
  384.     return(r);
  385.     }
  386. #endif
  387.  
  388.     Execute(buf, NULL, Output());
  389.     return(0);
  390. }
  391.  
  392. GetFileTime(file, ds)
  393. char *file;
  394. DateStamp *ds;
  395. {
  396.     static struct FileInfoBlock *Fib;
  397.     long rv = -1;
  398.     APTR lock;
  399.  
  400.     if (Fib == NULL)
  401.     Fib = malloc(sizeof(struct FileInfoBlock));
  402.     if (lock = (APTR)Lock(file, SHARED_LOCK)) {
  403.     if (Examine(lock, Fib)) {
  404.         *ds = Fib->fib_Date;
  405.         rv = 0;
  406.     }
  407.     UnLock(lock);
  408.     }
  409.     return(rv);
  410. }
  411.  
  412.