tools/MetaMake/cache.c

   1 /* MetaMake - A Make extension
   2    Copyright © 1995-2019, The AROS Development Team. All rights reserved.
   3
   4 This file is part of MetaMake.
   5
   6 MetaMake is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 MetaMake is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 //#define DEBUG_CACHE
  22
  23 #include "config.h"
  24
  25 #ifdef HAVE_STRING_H
  26 #   include <string.h>
  27 #else
  28 #   include <strings.h>
  29 #endif
  30 #ifdef HAVE_SYS_STAT_H
  31 #   include <sys/stat.h>
  32 #endif
  33 #ifdef HAVE_NETINET_IN_H
  34 #   include <netinet/in.h> /* for htonl/ntohl() */
  35 #endif
  36 #include <errno.h>
  37 #include <assert.h>
  38 #include <unistd.h>
  39 #include <stdlib.h>
  40 #ifndef PATH_MAX
  41 #include <limits.h>
  42 #endif
  43
  44 #include "cache.h"
  45 #include "mem.h"
  46 #include "io_.h"
  47 #include "var.h"
  48 #include "dep.h"
  49 #include "mmake.h"
  50 #include "win32.h"
  51
  52 #if defined(DEBUG_CACHE)
  53 #define debug(a) a
  54 #else
  55 #define debug(v)
  56 #endif
  57
  58 #define MAJOR           0L
  59 #define MINOR           9L
  60 #define REVISION        0L
  61 #define ID              ((MAJOR << 24) | (MINOR << 16) | REVISION)
  62 #define CHECK_ID(id)    (((id) & 0xFFFF0000) == ((ID) & 0xFFFF0000))
  63
  64 struct Cache_priv
  65 {
  66     struct Cache publicpart;
  67     struct Project * project;
  68     struct DirNode * topdir;
  69     struct List addedfiles;
  70 };
  71
  72 struct Regenerate
  73 {
  74     struct Node node;
  75
  76     char *dir;
  77     char *src;
  78     char *dest;
  79 };
  80
  81
  82 static void
  83 freetarget (struct Target * target)
  84 {
  85     xfree (target->node.name);
  86
  87     freelist (&target->makefiles);
  88
  89     xfree (target);
  90 }
  91
  92 static void
  93 freetargetlist (struct Cache_priv * cache)
  94 {
  95     struct Node * node, * next;
  96
  97     ForeachNodeSafe(&cache->publicpart.targets,node,next)
  98     {
  99         Remove (node);
 100         freetarget ((struct Target *)node);
 101     }
 102 }
 103
 104 static void
 105 printtargetlist (struct List * l)
 106 {
 107     struct Target * n;
 108
 109     ForeachNode (l,n)
 110     {
 111         struct List deps;
 112         struct MakefileRef * mfref;
 113         struct MakefileTarget * mftarget;
 114         struct Node * node;
 115
 116         printf ("target %s:\n", n->node.name);
 117         printf ("  updated=%d\n", n->updated);
 118         printf ("  makefiles=\n");
 119         ForeachNode (&n->makefiles, mfref)
 120             printf("    \"%s/%s\"\n",
 121                     buildpath(mfref->makefile->dir),
 122                     mfref->makefile->node.name
 123                   );
 124
 125         printf ("  deps=\n");
 126         NewList (&deps);
 127         ForeachNode (&n->makefiles, mfref)
 128         {
 129             mftarget = FindNode (&mfref->makefile->targets, n->node.name);
 130             ForeachNode (&mftarget->deps, node)
 131                 addnodeonce (&deps, node->name);
 132         }
 133
 134         printlist (&deps);
 135         freelist (&deps);
 136     }
 137 }
 138
 139
 140 static int progcount;
 141
 142 static void
 143 progress_reset (FILE * fh)
 144 {
 145     progcount = 0;
 146     fprintf(fh, "\n");
 147 }
 148
 149 static void
 150 progress (FILE * fh)
 151 {
 152     progcount++;
 153     if (progcount == 20)
 154     {
 155         progcount = 0;
 156         fprintf(fh, ".");
 157         fflush (fh);
 158     }
 159 }
 160
 161
 162 void
 163 readcache (struct Cache_priv * cache)
 164 {
 165     char path[256];
 166     FILE * fh;
 167     uint32_t id;
 168
 169     strcpy (path, cache->project->buildtop);
 170     strcat (path, "/mmake.cache");
 171     assert (strlen(path) < sizeof(path));
 172
 173     fh = fopen (path, "rb");
 174
 175     if (fh)
 176     {
 177         if (!readuint32 (fh, &id) || !CHECK_ID(id))
 178         {
 179             fclose (fh);
 180             fh = NULL;
 181         }
 182     }
 183
 184     if (fh)
 185     {
 186         char * name;
 187
 188         do
 189         {
 190             if (!readstring (fh, &name))
 191             {
 192                 fh = NULL;
 193                 break;
 194             }
 195
 196             if (name == NULL)
 197                 continue;
 198
 199             addnodeonce (&cache->addedfiles, name);
 200             xfree (name);
 201         }
 202         while (name != NULL);
 203
 204         if (!(cache->topdir = readcachedir (fh)))
 205         {
 206             fclose (fh);
 207             fh = NULL;
 208         }
 209     }
 210
 211     if (!fh)
 212     {
 213         cache->topdir = newnodesize (cache->project->srctop, sizeof (struct DirNode));
 214         cache->topdir->parent = NULL;
 215         NewList(&cache->topdir->subdirs);
 216         NewList(&cache->topdir->makefiles);
 217
 218         /* Force a check the first time */
 219         cache->topdir->time = 0;
 220     }
 221
 222     if (fh)
 223         fclose (fh);
 224
 225     if (debug)
 226     {
 227         printf ("readcache()\n");
 228         printdirnode (cache->topdir, 1);
 229     }
 230 }
 231
 232 void
 233 writecache (struct Cache_priv * cache)
 234 {
 235     int ok = 1;
 236     char path[256];
 237     FILE * fh = NULL;
 238     uint32_t id;
 239     struct Node *addedfile;
 240
 241     debug(printf("MMAKE:cache.c->writecache()\n"));
 242
 243     if (!cache->topdir)
 244         return;
 245
 246     strcpy (path, cache->project->buildtop);
 247     strcat (path, "/mmake.cache");
 248     assert (strlen(path) < sizeof(path));
 249
 250     fh = fopen (path, "wb");
 251
 252     if (!fh)
 253     {
 254         ok = 0;
 255         goto writecacheend;
 256     }
 257
 258     ok = writeuint32 (fh, ID);
 259     if (!ok)
 260         goto writecacheend;
 261
 262     ForeachNode (&cache->addedfiles, addedfile)
 263     {
 264         ok = writestring (fh, addedfile->name);
 265         if (!ok)
 266         {
 267             error ("writecache/writestring():%d", __LINE__);
 268             goto writecacheend;
 269         }
 270     }
 271
 272     ok = writestring (fh, NULL);
 273     if (!ok)
 274     {
 275         error("writecache/fwrite():%d", __LINE__);
 276         goto writecacheend;
 277     }
 278
 279     ok = writecachedir (fh, cache->topdir);
 280
 281 writecacheend:
 282     if (fh)
 283         fclose (fh);
 284
 285     if (!ok)
 286     {
 287         unlink (path);
 288
 289         printf ("[MMAKE] %s: Warning! - Creating the cache failed\n", __func__);
 290     }
 291 }
 292
 293
 294 void
 295 checknewsrc (struct Cache_priv * cache, struct Makefile * makefile, struct List * regeneratefiles)
 296 {
 297     char * mfsrc = xmalloc (strlen (makefile->node.name) + 5);
 298     char * mfdst = xmalloc (strlen (mm_builddir) + 1 + strlen (buildpath(makefile->dir)) + 1 + strlen (makefile->node.name) + 1);
 299     struct stat sst, dst;
 300
 301     debug(printf("[MMAKE] %s('%s')\n", __func__, makefile->node.name));
 302
 303     strcpy (mfsrc, makefile->node.name);
 304     strcat (mfsrc, ".src");
 305
 306     if (stat (mfsrc, &sst) == -1)
 307     {
 308         debug(printf("[MMAKE] %s: stat(\"%s\", ...) failed\n", __func__, mfsrc));
 309         xfree (mfsrc);
 310         return;
 311     }
 312
 313     strcpy (mfdst, mm_builddir);
 314     strcat (mfdst, "/");
 315     strcat (mfdst, buildpath(makefile->dir));
 316     strcat (mfdst, "/");
 317     strcat (mfdst, makefile->node.name);
 318
 319     if (stat (mfdst, &dst) == -1
 320             || sst.st_mtime > dst.st_mtime
 321             || checkdeps (&cache->project->genmakefiledeps, dst.st_mtime)
 322        )
 323     {
 324         static char currdir[PATH_MAX];
 325         struct Regenerate *reg = new (struct Regenerate);
 326
 327         ASSERT(getcwd(currdir, PATH_MAX) != NULL);
 328         reg->dir = xstrdup (buildpath(makefile->dir));
 329         reg->src = mfsrc;
 330         reg->dest = xstrdup (makefile->node.name);
 331
 332         debug(printf("MMAKE/cache.c:Added \"%s\" to be regenerated from \"%s\" in \"%s\"\n",
 333                      reg->dest, reg->src, reg->dir
 334         ));
 335         AddTail (regeneratefiles, reg);
 336     }
 337     else
 338     {
 339         debug(printf("MMAKE/cache.c:\"%s\" Not regenerated\n", makefile->node.name));
 340         xfree (mfsrc);
 341     }
 342 }
 343
 344
 345 int
 346 updatemflist (struct Cache_priv * cache, struct DirNode * node, struct List * regeneratefiles)
 347 {
 348     struct DirNode * subdir;
 349     struct Makefile * makefile;
 350     int goup = 0, reread = 0;
 351     char curdir[1024];
 352
 353     debug(printf("MMAKE:cache.c->updatemflist(\"%s\")\n", node->node.name));
 354
 355     if (strlen(node->node.name) != 0)
 356     {
 357         if (getcwd(curdir, sizeof(curdir)) == NULL)
 358         {
 359             error("Could not get current directory");
 360             exit (20);
 361         }
 362         if (chdir(node->node.name) < 0)
 363         {
 364             error("Could not change to dir '%s'", node->node.name);
 365             exit (20);
 366         }
 367         goup = 1;
 368     }
 369
 370     if (scandirnode(node, cache->project->defaultmakefilename, &cache->project->ignoredirs))
 371         reread ++;
 372
 373     ForeachNode(&node->subdirs, subdir)
 374     {
 375         debug(printf("MMAKE:cache.c->updatemflist: checking subdir ..\n"));
 376         reread += updatemflist(cache, subdir, regeneratefiles);
 377     }
 378
 379     ForeachNode(&node->makefiles, makefile)
 380     {
 381         debug(printf("MMAKE:cache.c->updatemflist: checking makefile ..\n"));
 382         checknewsrc(cache, makefile, regeneratefiles);
 383     }
 384
 385     if (goup)
 386         ASSERT(chdir(curdir) == 0);
 387
 388     progress (stdout);
 389
 390     return reread;
 391 }
 392
 393 int
 394 updatetargetlist (struct Project * prj, struct Cache_priv * cache, struct DirNode * node)
 395 {
 396     struct DirNode * subdir;
 397     int reread = 0;
 398
 399     debug(printf("MMAKE:cache.c->updatetargetlist('%s')\n", node->node.name));
 400
 401     reread = scanmakefiles(prj, node, &cache->project->vars);
 402
 403     ForeachNode(&node->subdirs, subdir)
 404         reread += updatetargetlist(prj, cache, subdir);
 405
 406     progress (stdout);
 407
 408     return reread;
 409 }
 410
 411 #ifdef _WIN32
 412
 413 int mktempfile(char **name)
 414 {
 415     char *temp = getenv("TEMP");
 416     size_t pathlen = strlen(temp) + 13;
 417     char *path = xmalloc(pathlen);
 418
 419     strcpy(path, temp);
 420     strcat(path, "\\genmfXXXXXX");
 421     *name = path;
 422     return mkstemps(path, 0);
 423 }
 424
 425 #else
 426
 427 int mktempfile(char **name)
 428 {
 429     static char tmpname[20];
 430
 431     strcpy(tmpname, "/tmp/genmfXXXXXX");
 432     *name = tmpname;
 433     return mkstemp(tmpname);
 434 }
 435
 436 #endif
 437
 438
 439 void
 440 regeneratemf (struct Cache_priv * cache, struct List * regeneratefiles)
 441 {
 442     struct Regenerate * reg,* reg2;
 443     char *tmpname;
 444     int fd;
 445     FILE *f;
 446
 447     debug(printf("MMAKE:cache.c->regeneratemf()\n"));
 448
 449     if (GetHead (regeneratefiles) == NULL)
 450         return;
 451
 452     fd = mktempfile(&tmpname);
 453     if (fd < 0)
 454     {
 455         error ("Could not create temporary file %s", tmpname);
 456         exit (10);
 457     }
 458     else
 459     {
 460         f = fdopen (fd, "w");
 461         if (f == NULL)
 462         {
 463             error ("Could not open temporary file %s", tmpname);
 464             exit (10);
 465         }
 466     }
 467
 468     ForeachNodeSafe (regeneratefiles, reg, reg2)
 469     {
 470         char * mfsrc = xmalloc (strlen(cache->project->srctop) + strlen(reg->dir) + strlen(reg->src) + 3);
 471         char * mfdst = xmalloc (strlen(cache->project->buildtop) + strlen(reg->dir) + strlen(reg->dest) + 3);
 472
 473         strcpy (mfsrc, cache->project->srctop);
 474         if (strlen(reg->dir) > 0)
 475         {
 476             strcat (mfsrc, "/");
 477             strcat (mfsrc, reg->dir);
 478         }
 479         strcat (mfsrc, "/");
 480         strcat (mfsrc, reg->src);
 481
 482         strcpy (mfdst, cache->project->buildtop);
 483         if (strlen(reg->dir) > 0)
 484         {
 485             strcat (mfdst, "/");
 486             strcat (mfdst, reg->dir);
 487         }
 488         strcat (mfdst, "/");
 489         strcat (mfdst, reg->dest);
 490
 491         debug(printf("MMAKE:cache.c->regeneratemf: regenerate '%s' as '%s'\n", mfsrc, mfdst));
 492
 493         fprintf (f, "%s %s\n", mfsrc, mfdst);
 494         Remove (reg);
 495         xfree (mfsrc);
 496         xfree (mfdst);
 497
 498         xfree (reg->dir);
 499         xfree (reg->src);
 500         xfree (reg->dest);
 501         xfree (reg);
 502     }
 503
 504     fclose (f);
 505
 506     setvar (&cache->project->vars, "MMLIST", tmpname);
 507     if (!execute (cache->project, cache->project->genmakefilescript,"-","-",""))
 508     {
 509         error ("Error regenerating makefile");
 510         exit (10);
 511     }
 512
 513     debug(printf("MMAKE:cache.c->regeneratemf: Finished\n"));
 514
 515     unlink (tmpname);
 516 }
 517
 518 void
 519 buildtargetlist (struct Cache_priv * cache, struct DirNode * node)
 520 {
 521     struct Makefile * makefile;
 522     struct MakefileRef * mfref;
 523     struct MakefileTarget * mftarget;
 524     struct DirNode * subdir;
 525     struct Target * target;
 526     struct Node * n;
 527
 528     debug(printf("MMAKE:cache.c->buildtargetlist()\n"));
 529
 530     ForeachNode (&node->makefiles, makefile)
 531     {
 532         ForeachNode (&makefile->targets, mftarget)
 533         {
 534             if (strchr (mftarget->node.name, '$') != NULL)
 535             {
 536                 char * s = substvars(&cache->project->vars, mftarget->node.name);
 537                 SETSTR (mftarget->node.name, s);
 538             }
 539
 540             ForeachNode (&mftarget->deps, n)
 541             {
 542                 if (strchr (n->name, '$') != NULL)
 543                 {
 544                     char * s = substvars(&cache->project->vars, n->name);
 545                     SETSTR (n->name, s);
 546                 }
 547             }
 548
 549             target = FindNode (&cache->publicpart.targets, mftarget->node.name);
 550
 551             if (target ==  NULL)
 552             {
 553                 target = newnodesize (mftarget->node.name, sizeof(struct Target));
 554                 target->updated = 0;
 555                 NewList (&target->makefiles);
 556                 AddTail (&cache->publicpart.targets, target);
 557             }
 558
 559             mfref = newnodesize ("", sizeof(struct MakefileRef));
 560             mfref->virtualtarget = mftarget->virtualtarget;
 561             mfref->makefile = makefile;
 562             AddTail (&target->makefiles, mfref);
 563         }
 564     }
 565
 566     ForeachNode (&node->subdirs, subdir)
 567         buildtargetlist (cache, subdir);
 568 }
 569
 570 struct Cache *
 571 activatecache (struct Project *prj)
 572 {
 573     struct Cache_priv * cache;
 574     struct List regeneratefiles;
 575     struct Node * addedfile, * extrafile;
 576     struct Makefile * makefile;
 577     struct List newadded;
 578     int reread;
 579
 580     debug(printf("MMAKE:cache.c->activatecache(Project @ %x)\n", prj));
 581
 582     cache = new (struct Cache_priv);
 583     if (!cache)
 584         return NULL;
 585     NewList (&regeneratefiles);
 586
 587     cache->project = prj;
 588
 589     debug(printf("MMAKE:cache.c->activatecache: Cache @ %x for Project @ %x\n", cache, prj));
 590
 591     NewList (&cache->addedfiles);
 592     NewList (&cache->publicpart.targets);
 593
 594     readcache (cache);
 595
 596     debug(printf("MMAKE:cache.c->activatecache: Cache read.\n"));
 597
 598     progress_reset (stdout);
 599     printf ("[MMAKE] Scanning dirs...\n");
 600     reread = updatemflist (cache, cache->topdir, &regeneratefiles);
 601     progress_reset (stdout);
 602
 603     debug(printf("MMAKE:cache.c->activatecache: Updated MF list.\n"));
 604
 605     if (verbose)
 606         printf ("[MMAKE] Reread %d dirs\n", reread);
 607
 608     if (debug)
 609     {
 610         printf ("[MMAKE] Directory tree for project %s\n", prj->node.name);
 611         printdirnode (cache->topdir, 0);
 612     }
 613
 614     /* Add the extra makefiles to the tree if needed */
 615     ASSERT(chdir (cache->project->buildtop) == 0);
 616     NewList (&newadded);
 617     ForeachNode (&cache->project->extramakefiles, extrafile)
 618     {
 619         addedfile = FindNode (&cache->addedfiles, extrafile->name);
 620         if (addedfile == NULL)
 621         {
 622             makefile = addmakefile (cache->topdir, extrafile->name);
 623
 624             if (makefile == NULL)
 625             {
 626                 error("Could not add makefile \"%s\"", extrafile->name);
 627                 exit (20);
 628             }
 629
 630             addnodeonce (&newadded, extrafile->name);
 631         }
 632         else /* addedfile != NULL => was already added before */
 633         {
 634             makefile = findmakefile (cache->topdir, extrafile->name);
 635
 636             if (makefile == NULL)
 637             {
 638                 error("Makefile \"%s\" has disappeared", extrafile->name);
 639                 exit (20);
 640             }
 641
 642             Remove (addedfile);
 643             AddTail (&newadded, addedfile);
 644         }
 645     }
 646     ForeachNode (&cache->addedfiles, addedfile)
 647     {
 648         makefile = findmakefile (cache->topdir, addedfile->name);
 649         if (makefile != NULL)
 650         {
 651             Remove (makefile);
 652             freemakefile (makefile);
 653         }
 654     }
 655     AssignList (&cache->addedfiles, &newadded);
 656
 657     regeneratemf (cache, &regeneratefiles);
 658
 659     debug(printf("MMAKE:cache.c->activatecache: Regenerated MFs\n"));
 660
 661     progress_reset (stdout);
 662     printf ("[MMAKE] Scanning makefiles...\n");
 663     reread = updatetargetlist (prj, cache, cache->topdir);
 664     if (verbose)
 665         printf ("[MMAKE] Reread %d makefiles\n", reread);
 666     if (debug)
 667     {
 668         printf ("[MMAKE] Makefile and target tree for project %s\n", prj->node.name);
 669         printdirnodemftarget (cache->topdir);
 670     }
 671
 672     writecache (cache);
 673
 674     progress_reset (stdout);
 675     printf ("[MMAKE] Collecting targets...\n");
 676     buildtargetlist (cache, cache->topdir);
 677     if (debug)
 678     {
 679         printf ("[MMAKE] Targetlist of project %s\n", prj->node.name);
 680         printtargetlist (&cache->publicpart.targets);
 681     }
 682
 683     debug(printf("MMAKE:cache.c->activatecache: Finished\n"));
 684
 685     return (struct Cache *)cache;
 686 }
 687
 688 void
 689 closecache (struct Cache * gl_cache)
 690 {
 691     struct Cache_priv * cache = (struct Cache_priv *)gl_cache;
 692
 693     freetargetlist (cache);
 694 }