tools/MetaMake/cache.c

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