tools/MetaMake/cache.c

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