tools/MetaMake/cache.c

   1 /* MetaMake - A Make extension
   2    Copyright © 1995-2009, 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 static int token;
 142 static char tokens[]="|/-\\";
 143
 144 static void
 145 progress_reset (FILE * fh)
 146 {
 147     progcount = 0;
 148     token = 0;
 149     fprintf (fh, "\r|\r");
 150     fflush (fh);
 151 }
 152
 153 static void
 154 progress (FILE * fh)
 155 {
 156     progcount++;
 157     if (progcount == 13)
 158     {
 159         progcount = 0;
 160         token++;
 161         if (token == 4)
 162             token = 0;
 163         fprintf (fh, "%c\r", tokens[token]);
 164         fflush (fh);
 165     }
 166 }
 167
 168
 169 void
 170 readcache (struct Cache_priv * cache)
 171 {
 172     char path[256];
 173     FILE * fh;
 174     uint32_t id;
 175
 176     strcpy (path, cache->project->buildtop);
 177     strcat (path, "/mmake.cache");
 178     assert (strlen(path) < sizeof(path));
 179
 180     fh = fopen (path, "rb");
 181
 182     if (fh)
 183     {
 184         if (!readuint32 (fh, &id) || !CHECK_ID(id))
 185         {
 186             fclose (fh);
 187             fh = NULL;
 188         }
 189     }
 190
 191     if (fh)
 192     {
 193         char * name;
 194
 195         do
 196         {
 197             if (!readstring (fh, &name))
 198             {
 199                 fh = NULL;
 200                 break;
 201             }
 202
 203             if (name == NULL)
 204                 continue;
 205
 206             addnodeonce (&cache->addedfiles, name);
 207             xfree (name);
 208         }
 209         while (name != NULL);
 210
 211         if (!(cache->topdir = readcachedir (fh)))
 212         {
 213             fclose (fh);
 214             fh = NULL;
 215         }
 216     }
 217
 218     if (!fh)
 219     {
 220         cache->topdir = newnodesize (cache->project->srctop, sizeof (struct DirNode));
 221         cache->topdir->parent = NULL;
 222         NewList(&cache->topdir->subdirs);
 223         NewList(&cache->topdir->makefiles);
 224
 225         /* Force a check the first time */
 226         cache->topdir->time = 0;
 227     }
 228
 229     if (fh)
 230         fclose (fh);
 231
 232     if (debug)
 233     {
 234         printf ("readcache()\n");
 235         printdirnode (cache->topdir, 1);
 236     }
 237 }
 238
 239 void
 240 writecache (struct Cache_priv * cache)
 241 {
 242     int ok = 1;
 243     char path[256];
 244     FILE * fh = NULL;
 245     uint32_t id;
 246     struct Node *addedfile;
 247
 248     debug(printf("MMAKE:cache.c->writecache()\n"));
 249
 250     if (!cache->topdir)
 251         return;
 252
 253     strcpy (path, cache->project->buildtop);
 254     strcat (path, "/mmake.cache");
 255     assert (strlen(path) < sizeof(path));
 256
 257     fh = fopen (path, "wb");
 258
 259     if (!fh)
 260     {
 261         ok = 0;
 262         goto writecacheend;
 263     }
 264
 265     ok = writeuint32 (fh, ID);
 266     if (!ok)
 267         goto writecacheend;
 268
 269     ForeachNode (&cache->addedfiles, addedfile)
 270     {
 271         ok = writestring (fh, addedfile->name);
 272         if (!ok)
 273         {
 274             error ("writecache/writestring():%d", __LINE__);
 275             goto writecacheend;
 276         }
 277     }
 278
 279     ok = writestring (fh, NULL);
 280     if (!ok)
 281     {
 282         error("writecache/fwrite():%d", __LINE__);
 283         goto writecacheend;
 284     }
 285
 286     ok = writecachedir (fh, cache->topdir);
 287
 288 writecacheend:
 289     if (fh)
 290         fclose (fh);
 291
 292     if (!ok)
 293     {
 294         unlink (path);
 295
 296         printf ("Warning: Creating the cache failed\n");
 297     }
 298 }
 299
 300
 301 void
 302 checknewsrc (struct Cache_priv * cache, struct Makefile * makefile, struct List * regeneratefiles)
 303 {
 304     char * mfsrc = xmalloc (strlen (makefile->node.name) + 5);
 305     char * mfdst = xmalloc (strlen (mm_builddir) + 1 + strlen (buildpath(makefile->dir)) + 1 + strlen (makefile->node.name) + 1);
 306     struct stat sst, dst;
 307
 308     debug(printf("MMAKE:cache.c->checknewsrc('%s')\n", makefile->node.name));
 309
 310     strcpy (mfsrc, makefile->node.name);
 311     strcat (mfsrc, ".src");
 312
 313     if (stat (mfsrc, &sst) == -1)
 314     {
 315         debug(printf("MMAKE/cache.c:stat(\"%s\", ...) failed\n", mfsrc));
 316         xfree (mfsrc);
 317         return;
 318     }
 319
 320     strcpy (mfdst, mm_builddir);
 321     strcat (mfdst, "/");
 322     strcat (mfdst, buildpath(makefile->dir));
 323     strcat (mfdst, "/");
 324     strcat (mfdst, makefile->node.name);
 325
 326     if (stat (mfdst, &dst) == -1
 327             || sst.st_mtime > dst.st_mtime
 328             || checkdeps (&cache->project->genmakefiledeps, dst.st_mtime)
 329        )
 330     {
 331         static char currdir[PATH_MAX];
 332         struct Regenerate *reg = new (struct Regenerate);
 333
 334         getcwd(currdir, PATH_MAX);
 335         reg->dir = xstrdup (buildpath(makefile->dir));
 336         reg->src = mfsrc;
 337         reg->dest = xstrdup (makefile->node.name);
 338
 339         debug(printf("MMAKE/cache.c:Added \"%s\" to be regenerated from \"%s\" in \"%s\"\n",
 340                      reg->dest, reg->src, reg->dir
 341         ));
 342         AddTail (regeneratefiles, reg);
 343     }
 344     else
 345     {
 346         debug(printf("MMAKE/cache.c:\"%s\" Not regenerated\n", makefile->node.name));
 347         xfree (mfsrc);
 348     }
 349 }
 350
 351
 352 int
 353 updatemflist (struct Cache_priv * cache, struct DirNode * node, struct List * regeneratefiles)
 354 {
 355     struct DirNode * subdir;
 356     struct Makefile * makefile;
 357     int goup = 0, reread = 0;
 358     char curdir[1024];
 359
 360     debug(printf("MMAKE:cache.c->updatemflist(\"%s\")\n", node->node.name));
 361
 362     if (strlen(node->node.name) != 0)
 363     {
 364         if (getcwd(curdir, sizeof(curdir)) == NULL)
 365         {
 366             error("Could not get current directory");
 367             exit (20);
 368         }
 369         if (chdir(node->node.name) < 0)
 370         {
 371             error("Could not change to dir '%s'", node->node.name);
 372             exit (20);
 373         }
 374         goup = 1;
 375     }
 376
 377     if (scandirnode(node, cache->project->defaultmakefilename, &cache->project->ignoredirs))
 378         reread ++;
 379
 380     ForeachNode(&node->subdirs, subdir)
 381     {
 382         debug(printf("MMAKE:cache.c->updatemflist: checking subdir ..\n"));
 383         reread += updatemflist(cache, subdir, regeneratefiles);
 384     }
 385
 386     ForeachNode(&node->makefiles, makefile)
 387     {
 388         debug(printf("MMAKE:cache.c->updatemflist: checking makefile ..\n"));
 389         checknewsrc(cache, makefile, regeneratefiles);
 390     }
 391
 392     if (goup)
 393         chdir(curdir);
 394
 395     progress (stdout);
 396
 397     return reread;
 398 }
 399
 400 int
 401 updatetargetlist (struct Project * prj, struct Cache_priv * cache, struct DirNode * node)
 402 {
 403     struct DirNode * subdir;
 404     int reread = 0;
 405
 406     debug(printf("MMAKE:cache.c->updatetargetlist('%s')\n", node->node.name));
 407
 408     reread = scanmakefiles(prj, node, &cache->project->vars);
 409
 410     ForeachNode(&node->subdirs, subdir)
 411         reread += updatetargetlist(prj, cache, subdir);
 412
 413     progress (stdout);
 414
 415     return reread;
 416 }
 417
 418 #ifdef _WIN32
 419
 420 int mktempfile(char **name)
 421 {
 422     char *temp = getenv("TEMP");
 423     size_t pathlen = strlen(temp) + 13;
 424     char *path = xmalloc(pathlen);
 425
 426     strcpy(path, temp);
 427     strcat(path, "\\genmfXXXXXX");
 428     *name = path;
 429     return mkstemps(path, 0);
 430 }
 431
 432 #else
 433
 434 int mktempfile(char **name)
 435 {
 436     static char tmpname[20];
 437
 438     strcpy(tmpname, "/tmp/genmfXXXXXX");
 439     *name = tmpname;
 440     return mkstemp(tmpname);
 441 }
 442
 443 #endif
 444
 445
 446 void
 447 regeneratemf (struct Cache_priv * cache, struct List * regeneratefiles)
 448 {
 449     struct Regenerate * reg,* reg2;
 450     char *tmpname;
 451     int fd;
 452     FILE *f;
 453
 454     debug(printf("MMAKE:cache.c->regeneratemf()\n"));
 455
 456     if (GetHead (regeneratefiles) == NULL)
 457         return;
 458
 459     fd = mktempfile(&tmpname);
 460     if (fd < 0)
 461     {
 462         error ("Could not create temporary file %s", tmpname);
 463         exit (10);
 464     }
 465     else
 466     {
 467         f = fdopen (fd, "w");
 468         if (f == NULL)
 469         {
 470             error ("Could not open temporary file %s", tmpname);
 471             exit (10);
 472         }
 473     }
 474
 475     ForeachNodeSafe (regeneratefiles, reg, reg2)
 476     {
 477         char * mfsrc = xmalloc (strlen(cache->project->srctop) + strlen(reg->dir) + strlen(reg->src) + 3);
 478         char * mfdst = xmalloc (strlen(cache->project->buildtop) + strlen(reg->dir) + strlen(reg->dest) + 3);
 479
 480         strcpy (mfsrc, cache->project->srctop);
 481         if (strlen(reg->dir) > 0)
 482         {
 483             strcat (mfsrc, "/");
 484             strcat (mfsrc, reg->dir);
 485         }
 486         strcat (mfsrc, "/");
 487         strcat (mfsrc, reg->src);
 488
 489         strcpy (mfdst, cache->project->buildtop);
 490         if (strlen(reg->dir) > 0)
 491         {
 492             strcat (mfdst, "/");
 493             strcat (mfdst, reg->dir);
 494         }
 495         strcat (mfdst, "/");
 496         strcat (mfdst, reg->dest);
 497
 498         debug(printf("MMAKE:cache.c->regeneratemf: regenerate '%s' as '%s'\n", mfsrc, mfdst));
 499
 500         fprintf (f, "%s %s\n", mfsrc, mfdst);
 501         Remove (reg);
 502         xfree (mfsrc);
 503         xfree (mfdst);
 504
 505         xfree (reg->dir);
 506         xfree (reg->src);
 507         xfree (reg->dest);
 508         xfree (reg);
 509     }
 510
 511     fclose (f);
 512
 513     setvar (&cache->project->vars, "MMLIST", tmpname);
 514     if (!execute (cache->project, cache->project->genmakefilescript,"-","-",""))
 515     {
 516         error ("Error regenerating makefile");
 517         exit (10);
 518     }
 519
 520     debug(printf("MMAKE:cache.c->regeneratemf: Finished\n"));
 521
 522     unlink (tmpname);
 523 }
 524
 525 void
 526 buildtargetlist (struct Cache_priv * cache, struct DirNode * node)
 527 {
 528     struct Makefile * makefile;
 529     struct MakefileRef * mfref;
 530     struct MakefileTarget * mftarget;
 531     struct DirNode * subdir;
 532     struct Target * target;
 533     struct Node * n;
 534
 535     debug(printf("MMAKE:cache.c->buildtargetlist()\n"));
 536
 537     ForeachNode (&node->makefiles, makefile)
 538     {
 539         ForeachNode (&makefile->targets, mftarget)
 540         {
 541             if (strchr (mftarget->node.name, '$') != NULL)
 542             {
 543                 char * s = substvars(&cache->project->vars, mftarget->node.name);
 544                 SETSTR (mftarget->node.name, s);
 545             }
 546
 547             ForeachNode (&mftarget->deps, n)
 548             {
 549                 if (strchr (n->name, '$') != NULL)
 550                 {
 551                     char * s = substvars(&cache->project->vars, n->name);
 552                     SETSTR (n->name, s);
 553                 }
 554             }
 555
 556             target = FindNode (&cache->publicpart.targets, mftarget->node.name);
 557
 558             if (target ==  NULL)
 559             {
 560                 target = newnodesize (mftarget->node.name, sizeof(struct Target));
 561                 target->updated = 0;
 562                 NewList (&target->makefiles);
 563                 AddTail (&cache->publicpart.targets, target);
 564             }
 565
 566             mfref = newnodesize ("", sizeof(struct MakefileRef));
 567             mfref->virtualtarget = mftarget->virtualtarget;
 568             mfref->makefile = makefile;
 569             AddTail (&target->makefiles, mfref);
 570         }
 571     }
 572
 573     ForeachNode (&node->subdirs, subdir)
 574         buildtargetlist (cache, subdir);
 575 }
 576
 577 struct Cache *
 578 activatecache (struct Project *prj)
 579 {
 580     struct Cache_priv * cache;
 581     struct List regeneratefiles;
 582     struct Node * addedfile, * extrafile;
 583     struct Makefile * makefile;
 584     struct List newadded;
 585     int reread;
 586
 587     debug(printf("MMAKE:cache.c->activatecache(Project @ %x)\n", prj));
 588
 589     cache = new (struct Cache_priv);
 590     if (!cache)
 591         return NULL;
 592     NewList (&regeneratefiles);
 593
 594     cache->project = prj;
 595
 596     debug(printf("MMAKE:cache.c->activatecache: Cache @ %x for Project @ %x\n", cache, prj));
 597
 598     NewList (&cache->addedfiles);
 599     NewList (&cache->publicpart.targets);
 600
 601     readcache (cache);
 602
 603     debug(printf("MMAKE:cache.c->activatecache: Cache read.\n"));
 604
 605     progress_reset (stdout);
 606     printf ("Scanning dirs...\n");
 607     reread = updatemflist (cache, cache->topdir, &regeneratefiles);
 608
 609     debug(printf("MMAKE:cache.c->activatecache: Updated MF list.\n"));
 610
 611     if (verbose)
 612         printf ("Reread %d dirs\n", reread);
 613
 614     if (debug)
 615     {
 616         printf ("Directory tree for project %s\n", prj->node.name);
 617         printdirnode (cache->topdir, 0);
 618     }
 619
 620     /* Add the extra makefiles to the tree if needed */
 621     chdir (cache->project->buildtop);
 622     NewList (&newadded);
 623     ForeachNode (&cache->project->extramakefiles, extrafile)
 624     {
 625         addedfile = FindNode (&cache->addedfiles, extrafile->name);
 626         if (addedfile == NULL)
 627         {
 628             makefile = addmakefile (cache->topdir, extrafile->name);
 629
 630             if (makefile == NULL)
 631             {
 632                 error("Could not add makefile \"%s\"", extrafile->name);
 633                 exit (20);
 634             }
 635
 636             addnodeonce (&newadded, extrafile->name);
 637         }
 638         else /* addedfile != NULL => was already added before */
 639         {
 640             makefile = findmakefile (cache->topdir, extrafile->name);
 641
 642             if (makefile == NULL)
 643             {
 644                 error("Makefile \"%s\" has disappeared", extrafile->name);
 645                 exit (20);
 646             }
 647
 648             Remove (addedfile);
 649             AddTail (&newadded, addedfile);
 650         }
 651     }
 652     ForeachNode (&cache->addedfiles, addedfile)
 653     {
 654         makefile = findmakefile (cache->topdir, addedfile->name);
 655         if (makefile != NULL)
 656         {
 657             Remove (makefile);
 658             freemakefile (makefile);
 659         }
 660     }
 661     AssignList (&cache->addedfiles, &newadded);
 662
 663     regeneratemf (cache, &regeneratefiles);
 664
 665     debug(printf("MMAKE:cache.c->activatecache: Regenerated MFs\n"));
 666
 667     progress_reset (stdout);
 668     printf ("Scanning makefiles...\n");
 669     reread = updatetargetlist (prj, cache, cache->topdir);
 670     if (verbose)
 671         printf ("Reread %d makefiles\n", reread);
 672     if (debug)
 673     {
 674         printf ("Makefile and target tree for project %s\n", prj->node.name);
 675         printdirnodemftarget (cache->topdir);
 676     }
 677
 678     writecache (cache);
 679
 680     printf ("Collecting targets...\n");
 681     buildtargetlist (cache, cache->topdir);
 682     if (debug)
 683     {
 684         printf ("Targetlist of project %s\n", prj->node.name);
 685         printtargetlist (&cache->publicpart.targets);
 686     }
 687
 688     debug(printf("MMAKE:cache.c->activatecache: Finished\n"));
 689
 690     return (struct Cache *)cache;
 691 }
 692
 693 void
 694 closecache (struct Cache * gl_cache)
 695 {
 696     struct Cache_priv * cache = (struct Cache_priv *)gl_cache;
 697
 698     freetargetlist (cache);
 699 }