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         xfree (mfsrc);
 316         return;
 317     }
 318
 319     strcpy (mfdst, mm_builddir);
 320     strcat (mfdst, "/");
 321     strcat (mfdst, buildpath(makefile->dir));
 322     strcat (mfdst, "/");
 323     strcat (mfdst, makefile->node.name);
 324
 325     if (stat (mfdst, &dst) == -1
 326             || sst.st_mtime > dst.st_mtime
 327             || checkdeps (&cache->project->genmakefiledeps, dst.st_mtime)
 328        )
 329     {
 330         static char currdir[PATH_MAX];
 331         struct Regenerate *reg = new (struct Regenerate);
 332
 333         getcwd(currdir, PATH_MAX);
 334         reg->dir = xstrdup (buildpath(makefile->dir));
 335         reg->src = mfsrc;
 336         reg->dest = xstrdup (makefile->node.name);
 337
 338         AddTail (regeneratefiles, reg);
 339     }
 340     else
 341     {
 342         xfree (mfsrc);
 343     }
 344 }
 345
 346
 347 int
 348 updatemflist (struct Cache_priv * cache, struct DirNode * node, struct List * regeneratefiles)
 349 {
 350     struct DirNode * subdir;
 351     struct Makefile * makefile;
 352     int goup = 0, reread = 0;
 353     char curdir[1024];
 354
 355     debug(printf("MMAKE:cache.c->updatemflist()\n"));
 356
 357     if (strlen(node->node.name) != 0)
 358     {
 359         if (getcwd(curdir, sizeof(curdir)) == NULL)
 360         {
 361             error("Could not get current directory");
 362             exit (20);
 363         }
 364         if (chdir(node->node.name) < 0)
 365         {
 366             error("Could not change to dir '%s'", node->node.name);
 367             exit (20);
 368         }
 369         goup = 1;
 370     }
 371
 372     if (scandirnode(node, cache->project->defaultmakefilename, &cache->project->ignoredirs))
 373         reread ++;
 374
 375     ForeachNode(&node->subdirs, subdir)
 376     {
 377         debug(printf("MMAKE:cache.c->updatemflist: checking subdir ..\n"));
 378         reread += updatemflist(cache, subdir, regeneratefiles);
 379     }
 380
 381     ForeachNode(&node->makefiles, makefile)
 382     {
 383         debug(printf("MMAKE:cache.c->updatemflist: checking makefile ..\n"));
 384         checknewsrc(cache, makefile, regeneratefiles);
 385     }
 386
 387     if (goup)
 388         chdir(curdir);
 389
 390     progress (stdout);
 391
 392     return reread;
 393 }
 394
 395 int
 396 updatetargetlist (struct Project * prj, struct Cache_priv * cache, struct DirNode * node)
 397 {
 398     struct DirNode * subdir;
 399     int reread = 0;
 400
 401     debug(printf("MMAKE:cache.c->updatetargetlist('%s')\n", node->node.name));
 402
 403     reread = scanmakefiles(prj, node, &cache->project->vars);
 404
 405     ForeachNode(&node->subdirs, subdir)
 406         reread += updatetargetlist(prj, cache, subdir);
 407
 408     progress (stdout);
 409
 410     return reread;
 411 }
 412
 413 #ifdef _WIN32
 414
 415 int mktempfile(char **name)
 416 {
 417     char *temp = getenv("TEMP");
 418     size_t pathlen = strlen(temp) + 13;
 419     char *path = xmalloc(pathlen);
 420
 421     strcpy(path, temp);
 422     strcat(path, "\\genmfXXXXXX");
 423     *name = path;
 424     return mkstemps(path, 0);
 425 }
 426
 427 #else
 428
 429 int mktempfile(char **name)
 430 {
 431     static char tmpname[20];
 432
 433     strcpy(tmpname, "/tmp/genmfXXXXXX");
 434     *name = tmpname;
 435     return mkstemp(tmpname);
 436 }
 437
 438 #endif
 439
 440
 441 void
 442 regeneratemf (struct Cache_priv * cache, struct List * regeneratefiles)
 443 {
 444     struct Regenerate * reg,* reg2;
 445     char *tmpname;
 446     int fd;
 447     FILE *f;
 448
 449     debug(printf("MMAKE:cache.c->regeneratemf()\n"));
 450
 451     if (GetHead (regeneratefiles) == NULL)
 452         return;
 453
 454     fd = mktempfile(&tmpname);
 455     if (fd < 0)
 456     {
 457         error ("Could not create temporary file %s", tmpname);
 458         exit (10);
 459     }
 460     else
 461     {
 462         f = fdopen (fd, "w");
 463         if (f == NULL)
 464         {
 465             error ("Could not open temporary file %s", tmpname);
 466             exit (10);
 467         }
 468     }
 469
 470     ForeachNodeSafe (regeneratefiles, reg, reg2)
 471     {
 472         char * mfsrc = xmalloc (strlen(cache->project->srctop) + strlen(reg->dir) + strlen(reg->src) + 3);
 473         char * mfdst = xmalloc (strlen(cache->project->buildtop) + strlen(reg->dir) + strlen(reg->dest) + 3);
 474
 475         strcpy (mfsrc, cache->project->srctop);
 476         if (strlen(reg->dir) > 0)
 477         {
 478             strcat (mfsrc, "/");
 479             strcat (mfsrc, reg->dir);
 480         }
 481         strcat (mfsrc, "/");
 482         strcat (mfsrc, reg->src);
 483
 484         strcpy (mfdst, cache->project->buildtop);
 485         if (strlen(reg->dir) > 0)
 486         {
 487             strcat (mfdst, "/");
 488             strcat (mfdst, reg->dir);
 489         }
 490         strcat (mfdst, "/");
 491         strcat (mfdst, reg->dest);
 492
 493         debug(printf("MMAKE:cache.c->regeneratemf: regenerate '%s' as '%s'\n", mfsrc, mfdst));
 494
 495         fprintf (f, "%s %s\n", mfsrc, mfdst);
 496         Remove (reg);
 497         xfree (mfsrc);
 498         xfree (mfdst);
 499
 500         xfree (reg->dir);
 501         xfree (reg->src);
 502         xfree (reg->dest);
 503         xfree (reg);
 504     }
 505
 506     fclose (f);
 507
 508     setvar (&cache->project->vars, "MMLIST", tmpname);
 509     if (!execute (cache->project, cache->project->genmakefilescript,"-","-",""))
 510     {
 511         error ("Error regenerating makefile");
 512         exit (10);
 513     }
 514
 515     debug(printf("MMAKE:cache.c->regeneratemf: Finished\n"));
 516
 517     unlink (tmpname);
 518 }
 519
 520 void
 521 buildtargetlist (struct Cache_priv * cache, struct DirNode * node)
 522 {
 523     struct Makefile * makefile;
 524     struct MakefileRef * mfref;
 525     struct MakefileTarget * mftarget;
 526     struct DirNode * subdir;
 527     struct Target * target;
 528     struct Node * n;
 529
 530     debug(printf("MMAKE:cache.c->buildtargetlist()\n"));
 531
 532     ForeachNode (&node->makefiles, makefile)
 533     {
 534         ForeachNode (&makefile->targets, mftarget)
 535         {
 536             if (strchr (mftarget->node.name, '$') != NULL)
 537             {
 538                 char * s = substvars(&cache->project->vars, mftarget->node.name);
 539                 SETSTR (mftarget->node.name, s);
 540             }
 541
 542             ForeachNode (&mftarget->deps, n)
 543             {
 544                 if (strchr (n->name, '$') != NULL)
 545                 {
 546                     char * s = substvars(&cache->project->vars, n->name);
 547                     SETSTR (n->name, s);
 548                 }
 549             }
 550
 551             target = FindNode (&cache->publicpart.targets, mftarget->node.name);
 552
 553             if (target ==  NULL)
 554             {
 555                 target = newnodesize (mftarget->node.name, sizeof(struct Target));
 556                 target->updated = 0;
 557                 NewList (&target->makefiles);
 558                 AddTail (&cache->publicpart.targets, target);
 559             }
 560
 561             mfref = newnodesize ("", sizeof(struct MakefileRef));
 562             mfref->virtualtarget = mftarget->virtualtarget;
 563             mfref->makefile = makefile;
 564             AddTail (&target->makefiles, mfref);
 565         }
 566     }
 567
 568     ForeachNode (&node->subdirs, subdir)
 569         buildtargetlist (cache, subdir);
 570 }
 571
 572 struct Cache *
 573 activatecache (struct Project *prj)
 574 {
 575     struct Cache_priv * cache;
 576     struct List regeneratefiles;
 577     struct Node * addedfile, * extrafile;
 578     struct Makefile * makefile;
 579     struct List newadded;
 580     int reread;
 581
 582     debug(printf("MMAKE:cache.c->activatecache(Project @ %x)\n", prj));
 583
 584     cache = new (struct Cache_priv);
 585     if (!cache)
 586         return NULL;
 587     NewList (&regeneratefiles);
 588
 589     cache->project = prj;
 590
 591     debug(printf("MMAKE:cache.c->activatecache: Cache @ %x for Project @ %x\n", cache, prj));
 592
 593     NewList (&cache->addedfiles);
 594     NewList (&cache->publicpart.targets);
 595
 596     readcache (cache);
 597
 598     debug(printf("MMAKE:cache.c->activatecache: Cache read.\n"));
 599
 600     progress_reset (stdout);
 601     printf ("Scanning dirs...\n");
 602     reread = updatemflist (cache, cache->topdir, &regeneratefiles);
 603
 604     debug(printf("MMAKE:cache.c->activatecache: Updated MF list.\n"));
 605
 606     if (verbose)
 607         printf ("Reread %d dirs\n", reread);
 608
 609     if (debug)
 610     {
 611         printf ("Directory tree for project %s\n", prj->node.name);
 612         printdirnode (cache->topdir, 0);
 613     }
 614
 615     /* Add the extra makefiles to the tree if needed */
 616     chdir (cache->project->buildtop);
 617     NewList (&newadded);
 618     ForeachNode (&cache->project->extramakefiles, extrafile)
 619     {
 620         addedfile = FindNode (&cache->addedfiles, extrafile->name);
 621         if (addedfile == NULL)
 622         {
 623             makefile = addmakefile (cache->topdir, extrafile->name);
 624
 625             if (makefile == NULL)
 626             {
 627                 error("Could not add makefile \"%s\"", extrafile->name);
 628                 exit (20);
 629             }
 630
 631             addnodeonce (&newadded, extrafile->name);
 632         }
 633         else /* addedfile != NULL => was already added before */
 634         {
 635             makefile = findmakefile (cache->topdir, extrafile->name);
 636
 637             if (makefile == NULL)
 638             {
 639                 error("Makefile \"%s\" has disappeared", extrafile->name);
 640                 exit (20);
 641             }
 642
 643             Remove (addedfile);
 644             AddTail (&newadded, addedfile);
 645         }
 646     }
 647     ForeachNode (&cache->addedfiles, addedfile)
 648     {
 649         makefile = findmakefile (cache->topdir, addedfile->name);
 650         if (makefile != NULL)
 651         {
 652             Remove (makefile);
 653             freemakefile (makefile);
 654         }
 655     }
 656     AssignList (&cache->addedfiles, &newadded);
 657
 658     regeneratemf (cache, &regeneratefiles);
 659
 660     debug(printf("MMAKE:cache.c->activatecache: Regenerated MFs\n"));
 661
 662     progress_reset (stdout);
 663     printf ("Scanning makefiles...\n");
 664     reread = updatetargetlist (prj, cache, cache->topdir);
 665     if (verbose)
 666         printf ("Reread %d makefiles\n", reread);
 667     if (debug)
 668     {
 669         printf ("Makefile and target tree for project %s\n", prj->node.name);
 670         printdirnodemftarget (cache->topdir);
 671     }
 672
 673     writecache (cache);
 674
 675     printf ("Collecting targets...\n");
 676     buildtargetlist (cache, cache->topdir);
 677     if (debug)
 678     {
 679         printf ("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 }