tools/MetaMake/dirnode.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_DIRNODE
  22
  23 #include "config.h"
  24
  25 #include <stdio.h>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #include <errno.h>
  29 #ifdef HAVE_STRING_H
  30 #   include <string.h>
  31 #else
  32 #   include <strings.h>
  33 #endif
  34 #ifdef HAVE_SYS_STAT_H
  35 #   include <sys/stat.h>
  36 #endif
  37 #ifdef HAVE_SYS_TYPES_H
  38 #   include <sys/types.h>
  39 #endif
  40 #ifndef PATH_MAX
  41 #include <limits.h>
  42 #endif
  43
  44 #include "dirnode.h"
  45 #include "mem.h"
  46 #include "var.h"
  47 #include "mmake.h"
  48 #include "io.h"
  49
  50 #if defined(DEBUG_DIRNODE)
  51 #define debug(a) a
  52 #else
  53 #define debug(v)
  54 #endif
  55
  56 #define FLAG_VIRTUAL    0x0001
  57
  58 extern char *mm_srcdir;
  59 extern char *mm_builddir;
  60
  61 static MakefileTarget *
  62 newmakefiletarget (char *name, int virtualtarget)
  63 {
  64     MakefileTarget * mftarget;
  65
  66     mftarget = newnodesize (name, sizeof(MakefileTarget));
  67     mftarget->virtualtarget = virtualtarget;
  68     NewList (&mftarget->deps);
  69
  70     return mftarget;
  71 }
  72
  73 void
  74 freemakefiletarget (MakefileTarget * mftarget)
  75 {
  76     freelist (&mftarget->deps);
  77     xfree (mftarget);
  78 }
  79
  80 void
  81 freemakefiletargetlist (List * targets)
  82 {
  83     MakefileTarget * mftarget, * mftarget2;
  84
  85     ForeachNodeSafe (targets, mftarget, mftarget2)
  86         freemakefiletarget (mftarget);
  87
  88     NewList (targets);
  89 }
  90
  91 void
  92 printdirnode (DirNode * node, int level)
  93 {
  94     DirNode * subdir;
  95     int t;
  96
  97     for (t=0; t<level; t++)
  98         printf ("    ");
  99
 100     printf ("%s\n", node->node.name);
 101
 102     level ++;
 103
 104     ForeachNode (&node->subdirs, subdir)
 105         printdirnode (subdir, level);
 106 }
 107
 108 void
 109 printdirnodemftarget (DirNode * node)
 110 {
 111     Makefile * makefile;
 112     MakefileTarget * mftarget;
 113     Node * dep;
 114     DirNode * subdir;
 115
 116     ForeachNode (&node->makefiles, makefile)
 117     {
 118         printf ("%s/%s:\n", buildpath(node), makefile->node.name);
 119         ForeachNode (&makefile->targets, mftarget)
 120         {
 121             printf ("    %s:", mftarget->node.name);
 122             ForeachNode (&mftarget->deps, dep)
 123                 printf (" %s", dep->name);
 124             printf ("\n");
 125         }
 126     }
 127
 128     ForeachNode (&node->subdirs, subdir)
 129         printdirnodemftarget (subdir);
 130 }
 131
 132 void
 133 freedirnode (DirNode * node)
 134 {
 135     DirNode * subnode, * subnode2;
 136
 137     ForeachNodeSafe (&node->subdirs, subnode, subnode2)
 138         freedirnode (subnode);
 139
 140     xfree (node->node.name);
 141     xfree (node);
 142 }
 143
 144 void
 145 freemakefile (Makefile * makefile)
 146 {
 147     freemakefiletargetlist (&makefile->targets);
 148     xfree (makefile->node.name);
 149     xfree (makefile);
 150 }
 151
 152 DirNode *
 153 finddirnode (DirNode * topnode, const char * path)
 154 {
 155     const char * ptr;
 156     char dirname[256];
 157     int len;
 158     DirNode * node = topnode, * subdir;
 159
 160     ptr = path+2;
 161
 162     if (!*ptr)
 163         return node;
 164
 165     subdir = NULL;
 166
 167     while (*ptr)
 168     {
 169         for (len=0; ptr[len] && ptr[len] != '/'; len++);
 170
 171         strncpy (dirname, ptr, len);
 172         dirname[len] = 0;
 173         ptr += len;
 174         while (*ptr == '/')
 175             ptr ++;
 176
 177         subdir = FindNode (&node->subdirs, dirname);
 178
 179         if (!subdir)
 180             break;
 181
 182         node = subdir;
 183     }
 184
 185     return subdir;
 186 }
 187
 188
 189 int
 190 scandirnode (DirNode * node, const char * mfname, List * ignoredirs)
 191 {
 192     struct stat st;
 193     DIR * dirh;
 194     struct dirent * dirent;
 195
 196     int mfnamelen = strlen(mfname), scanned = 0;
 197
 198 debug(printf("MMAKE:dirnode.c->scandirnode('%s')\n", node->node.name));
 199
 200     if (stat(".", &st) != 0)
 201     {
 202                 error("scandirnode(): scanning %s\n",
 203             strlen(node->node.name) == 0
 204                 ? "topdir"
 205                 : node->node.name);
 206
 207         exit(20);
 208     }
 209
 210     if (st.st_mtime > node->time)
 211     {
 212         List newdirs, newmakefiles;
 213         DirNode * subdir = NULL, * subdir2;
 214         Makefile * makefile;
 215
 216 debug(printf("MMAKE:dirnode.c->scandirnode dir->time changed .. scanning\n"));
 217
 218         if (debug)
 219             printf("scandirnode(): scanning %s\n",
 220                    strlen(node->node.name)==0 ? "topdir" : buildpath(node)
 221             );
 222
 223         NewList (&newdirs);
 224         NewList (&newmakefiles);
 225
 226         node->time = st.st_mtime;
 227
 228         dirh = opendir (".");
 229         if (!dirh)
 230         {
 231             error("opendir: could not open current dir");
 232             exit(20);
 233         }
 234
 235         while ((dirent = readdir (dirh)))
 236         {
 237             /* Add makefile if it present or the file with .src is present */
 238             if (strcmp(dirent->d_name, mfname) == 0
 239                 || (strlen(dirent->d_name) == mfnamelen + 4
 240                     && strncmp(dirent->d_name, mfname, mfnamelen) == 0
 241                     && strcmp(dirent->d_name + mfnamelen, ".src") == 0
 242                 )
 243             )
 244             {
 245                 /* Don't add makefile twice */
 246 debug(printf("MMAKE:dirnode.c->scandirnode: %s found ('%s')\n", mfname, dirent->d_name));
 247
 248                 makefile = FindNode (&newmakefiles, mfname);
 249                 if (makefile == NULL)
 250                 {
 251 debug(printf("MMAKE:dirnode.c->scandirnode: Creating New Makefile node\n"));
 252                     makefile = FindNode (&node->makefiles, mfname);
 253                     if (makefile != NULL)
 254                     {
 255                         Remove (makefile);
 256                     }
 257                     else
 258                     {
 259                         makefile = newnodesize (mfname, sizeof (Makefile));
 260                         makefile->dir = node;
 261 debug(printf("MMAKE:dirnode.c->scandirnode: Makefile node dir '%s'\n", node->node.name));
 262                         makefile->time = (time_t)0;
 263                         NewList (&makefile->targets);
 264                     }
 265                     AddTail (&newmakefiles, makefile);
 266                 }
 267                 if (strcmp(dirent->d_name + mfnamelen, ".src") == 0)
 268                         makefile->generated = 1;
 269             }
 270             else
 271             {
 272                 /* If the file is already in the makefiles from the current dirnode
 273                  * and it is still present in the directory copy it to the new makefiles
 274                  * list
 275                  */
 276                 if (strlen (dirent->d_name) > 4
 277                     && strcmp (dirent->d_name + strlen(dirent->d_name) - 4, ".src") == 0
 278                 )
 279                 {
 280                     dirent->d_name[strlen(dirent->d_name) - 4] = 0;
 281                     makefile = FindNode (&node->makefiles, dirent->d_name);
 282                     dirent->d_name[strlen(dirent->d_name)] = '.';
 283                 }
 284                 else
 285                     makefile = FindNode (&node->makefiles, dirent->d_name);
 286
 287                 if (makefile != NULL)
 288                 {
 289                     Remove (makefile);
 290                     AddTail (&newmakefiles, makefile);
 291                 }
 292
 293
 294                 /* Add file to newsubdirs if it is a directory and it has not to be ignored
 295                  */
 296                 if (lstat (dirent->d_name, &st) == -1)
 297                 {
 298                     error ("scandirnode: stat(%s)", dirent->d_name);
 299                     exit(20);
 300                 }
 301
 302                 /* TODO: Add support to MetaMake for going through links
 303                  * If this feature is to be supported one also has to implement
 304                  * checks to avoid MetaMake going into infinite loop when circular
 305                  * linking is present
 306                  */
 307                 if (S_ISDIR (st.st_mode)
 308                     && strcmp (dirent->d_name, ".") != 0
 309                     && strcmp (dirent->d_name, "..") != 0
 310                     && !S_ISLNK (st.st_mode)
 311                     && !FindNode (ignoredirs, dirent->d_name)
 312                 )
 313                 {
 314                     subdir = FindNode (&node->subdirs, dirent->d_name);
 315
 316                     if (subdir != NULL)
 317                     {
 318                         Remove (subdir);
 319                     }
 320                     else
 321                     {
 322                         subdir = newnodesize (dirent->d_name, sizeof(DirNode));
 323 debug(printf("MMAKE:dirnode.c->scandirnode: New SubDir Node '%s' @ %p\n", dirent->d_name, subdir));
 324                         subdir->parent = node;
 325                         subdir->time = (time_t)0;
 326                         NewList (&subdir->subdirs);
 327                         NewList (&subdir->makefiles);
 328                     }
 329                     AddTail (&newdirs, subdir);
 330                 }
 331             }
 332         }
 333
 334         closedir (dirh);
 335
 336         ForeachNodeSafe (&node->subdirs, subdir, subdir2)
 337             freedirnode  (subdir);
 338         AssignList (&node->subdirs, &newdirs);
 339
 340         /* Clear the makefiles that have disappeared */
 341         ForeachNode (&node->makefiles, makefile)
 342         {
 343             MakefileTarget * mftarget;
 344
 345             ForeachNode (&makefile->targets, mftarget)
 346                 freelist (&mftarget->deps);
 347
 348             freelist (&makefile->targets);
 349         }
 350
 351         freelist (&node->makefiles);
 352
 353         AssignList (&node->makefiles, &newmakefiles);
 354
 355         scanned = 1;
 356     }
 357
 358 debug(printf("MMAKE:dirnode.c->scandirnode: Finished scanning dir '%s'\n", node->node.name));
 359         if (debug)
 360         {
 361                 printf ("scandirnode()\n");
 362                 printdirnode (node, 1);
 363         }
 364
 365     return scanned;
 366 }
 367
 368
 369 int
 370 scanmakefiles (DirNode * node, List * vars)
 371 {
 372     Makefile * makefile;
 373     struct stat st;
 374     static char * line = NULL;
 375     static int linelen = 512;
 376     int reread = 0;
 377     FILE * fh;
 378
 379 debug(printf("MMAKE:dirnode.c->scanmakefiles('%s')\n", node->node.name));
 380
 381     assert (node);
 382
 383     if (line == NULL)
 384         line = xmalloc(linelen);
 385
 386     ForeachNode (&node->makefiles, makefile)
 387     {
 388 debug(printf("MMAKE:dirnode.c->scanmakefiles: %d '%s'\n", makefile->generated, makefile->node.name));
 389
 390         if (makefile->generated == 0)
 391         {
 392                 if (chdir(mm_srcdir) < 0)
 393                 {
 394                         error("Could not change to dir '%s'", mm_srcdir);
 395                         exit (20);
 396                 }
 397         }
 398         else
 399         {
 400                 if (chdir(mm_builddir) < 0)
 401                 {
 402                         error("Could not change to dir '%s'", mm_builddir);
 403                         exit (20);
 404                 }
 405         }
 406
 407     if ((strlen(makefile->dir->node.name) != 0) && (strcmp(makefile->dir->node.name, mm_srcdir) != 0))
 408     {
 409         if (chdir(buildpath(makefile->dir)) < 0)
 410         {
 411                 error("Could not change to dir '%s'", makefile->dir->node.name);
 412                 exit (20);
 413         }
 414     }
 415
 416         if (stat(makefile->node.name, &st) != 0)
 417         {
 418             error("Could not stat %s", makefile->node.name);
 419             exit(20);
 420         }
 421
 422         if (st.st_mtime > makefile->time)
 423         {
 424             int flags = 0;
 425             int lineno = 0;
 426             MakefileTarget * mftarget = NULL;
 427
 428             if (debug)
 429                 printf("scanmakefiles(): scanning makefile in %s/%s\n",
 430                        strlen(node->node.name)==0 ? "topdir" : buildpath(node),
 431                        makefile->node.name
 432                 );
 433
 434 #if 0
 435 printf ("Opening %s\n", makefile->name);
 436 #endif
 437
 438             fh = fopen (makefile->node.name, "r");
 439             if (!fh)
 440             {
 441                 error ("buildtargetlist:fopen(): Opening %s for reading",
 442                        makefile->node.name
 443                 );
 444             }
 445
 446             /* Free old metatargets when the file is reread */
 447             freemakefiletargetlist (&makefile->targets);
 448             NewList (&makefile->targets);
 449
 450             while (fgets (line, linelen, fh))
 451             {
 452                 lineno ++;
 453
 454                 while (line[strlen(line)-1] != '\n' && !feof(fh))
 455                 {
 456                     char * ptr;
 457
 458                     linelen += 512;
 459                     ptr = xmalloc (linelen);
 460                     strcpy (ptr, line);
 461                     xfree (line);
 462                     line = ptr;
 463                     fgets (line+strlen(line), linelen-strlen(line), fh);
 464                 }
 465
 466                 if (line[strlen(line)-1] == '\n')
 467                 {
 468                     line[strlen(line)-1] = 0;
 469                 }
 470
 471                 if (strncmp (line, "#MM", 3) == 0)
 472                 {
 473                     char * ptr;
 474                     int count, t;
 475
 476 #if 0
 477 printf ("found #MM in %s\n", makefile->name);
 478 #endif
 479
 480                     /* Read in next lines if there is continuation */
 481                     while (line[strlen(line)-1] == '\\')
 482                     {
 483                         ptr = line + strlen(line) - 1;
 484
 485                         if (!fgets (ptr, linelen-strlen(line)+1, fh))
 486                         {
 487                             error("%s/%s:unexpected end of makefile",
 488                                   getcwd(NULL, 0),
 489                                   makefile->node.name
 490                             );
 491                             exit(20);
 492                         }
 493
 494                         lineno ++;
 495
 496                         while (line[strlen(line)-1] != '\n' && !feof(fh))
 497                         {
 498                             int pos = ptr - line;
 499                             linelen += 512;
 500                             ptr = xmalloc (linelen);
 501                             strcpy (ptr, line);
 502                             xfree (line);
 503                             line = ptr;
 504                             fgets (line+strlen(line), linelen-strlen(line), fh);
 505                             ptr = line + pos;
 506                         }
 507
 508                         if (line[strlen(line)-1] == '\n')
 509                         {
 510                             line[strlen(line)-1] = 0;
 511                         }
 512
 513                         if (strncmp (ptr, "##MM", 3) == 0)
 514                         {
 515                             *ptr = line[strlen(line)-1];
 516                             ptr[1] = 0;
 517                             continue;
 518                         }
 519
 520                         if (strncmp (ptr, "#MM", 3) != 0)
 521                         {
 522                             errno = 0;
 523                             error("%s/%s:%d:continuation line has to start with #MM",
 524                                   getcwd (NULL, 0),
 525                                   makefile->node.name,
 526                                   lineno
 527                             );
 528                             exit(20);
 529                         }
 530
 531                         memmove (ptr, ptr+4, strlen(ptr)-4+1);
 532                     }
 533
 534                     ptr = line+3;
 535
 536                     if (*ptr == '-')
 537                     {
 538                         flags |= FLAG_VIRTUAL;
 539                         ptr ++;
 540                     }
 541                     else
 542                         flags &= ~FLAG_VIRTUAL;
 543
 544                     while (isspace (*ptr))
 545                         ptr ++;
 546
 547                     if (!*ptr)
 548                     {
 549                         /* Line with only #MM, metatarget is on next line */
 550                         char ** targets;
 551                         fgets (line, linelen, fh);
 552                         lineno ++;
 553
 554                         ptr = line;
 555                         while (*ptr != ':' && *ptr)
 556                             ptr ++;
 557
 558                         *ptr = 0;
 559
 560                         targets = getargs (line, &count, NULL);
 561
 562                         if (count != 0)
 563                         {
 564                             mftarget = FindNode (&makefile->targets, targets[0]);
 565
 566                             if (mftarget == NULL)
 567                             {
 568                                 mftarget = newmakefiletarget (targets[0], 0);
 569                                 AddTail (&makefile->targets, mftarget);
 570                             }
 571                             else
 572                                 mftarget->virtualtarget = 0;
 573                         }
 574                         else
 575                             printf ("Warning: Can't find metatarget in %s:%d (%s)\n", makefile->node.name, lineno, buildpath(node));
 576                     }
 577                     else
 578                     {
 579                         List newtargets;
 580                         char * ptr2 = ptr, ** tptr;
 581                         MakefileTarget * mftarget2, * mftarget3;
 582
 583                         NewList (&newtargets);
 584
 585                         while (*ptr2 != ':' && *ptr2)
 586                             ptr2 ++;
 587                         if (*ptr2)
 588                             *ptr2 ++ = 0;
 589
 590                         tptr = getargs (ptr, &count, NULL);
 591
 592                         for (t = 0; t < count; t++)
 593                         {
 594                             mftarget = newmakefiletarget (tptr[t], (flags & FLAG_VIRTUAL) != 0);
 595                             AddTail (&newtargets, mftarget);
 596                         }
 597
 598                         tptr = getargs (ptr2, &count, NULL);
 599                         for (t = 0; t < count; t++)
 600                         {
 601                             ForeachNode (&newtargets, mftarget)
 602                                 addnodeonce (&mftarget->deps, tptr[t]);
 603                         }
 604
 605                         ForeachNodeSafe (&newtargets, mftarget, mftarget2)
 606                         {
 607                             mftarget3 = FindNode (&makefile->targets, mftarget->node.name);
 608
 609                             /* mftarget doesn't exists yet add it to targets */
 610                             if (mftarget3 == NULL)
 611                             {
 612                                 Remove (mftarget);
 613                                 AddTail (&makefile->targets, mftarget);
 614                             }
 615                             else
 616                             {
 617                                 /* Merge data in mftarget into mftarget3 */
 618                                 Node * node;
 619
 620                                 mftarget3->virtualtarget =  mftarget3->virtualtarget && mftarget->virtualtarget;
 621
 622                                 ForeachNode (&mftarget->deps, node)
 623                                     addnodeonce (&mftarget3->deps, node->name);
 624                             }
 625                             /* Free the targets from which the data was merged in other targets */
 626                             freemakefiletargetlist (&newtargets);
 627                         }
 628                     }
 629                 } /* If this is a MetaMake line in the makefile */
 630             } /* For all lines in a makefile */
 631
 632             reread ++;
 633             makefile->time = st.st_mtime;
 634 #if 0
 635 printf ("Read %d lines\n", lineno);
 636 #endif
 637
 638             fclose (fh);
 639         } /* If the makefile needed to be scanned */
 640     } /* For all makefiles in the project */
 641
 642     return reread;
 643 }
 644
 645
 646 Makefile *
 647 addmakefile (DirNode * node, const char * filename)
 648 {
 649     static char curdir[PATH_MAX];
 650     const char * ptr = filename;
 651     char * name;
 652     int len = 0;
 653     DirNode * subnode;
 654     Makefile * makefile = NULL;
 655
 656     getcwd(curdir, PATH_MAX);
 657
 658     while (ptr != NULL)
 659     {
 660         len = 0;
 661         while (ptr[len] != '/' && ptr[len] != 0)
 662             len++;
 663
 664         name = xmalloc (len+4+1); /* Make room for possibly adding .src at the end */
 665         strncpy (name, ptr, len);
 666         name[len] = 0;
 667
 668         if (ptr[len] == '/')
 669         {
 670             subnode = FindNode (&node->subdirs, name);
 671             if (subnode == NULL)
 672             {
 673                 xfree(name);
 674                 chdir (curdir);
 675                 return NULL;
 676             }
 677             chdir (name);
 678             node = subnode;
 679             ptr = ptr + len + 1;
 680         }
 681         else
 682         {
 683             if (len >= 4 && strcmp (name+len-4, ".src") == 0)
 684                 name[len-4] = 0;
 685
 686             makefile = FindNode (&node->makefiles, name);
 687
 688             if (makefile == NULL)
 689             {
 690                 struct stat st;
 691
 692                 printf ("Trying to stat %s\n", name);
 693
 694                 if (stat(name, &st) != 0)
 695                 {
 696                     len = strlen(name);
 697                     strcat (name, ".src");
 698                     if (stat (name, &st) != 0)
 699                     {
 700                         xfree (name);
 701                         chdir (curdir);
 702                         return NULL;
 703                     }
 704                     name[len]=0;
 705                 }
 706
 707                 makefile = newnodesize (name, sizeof (Makefile));
 708                 makefile->dir = node;
 709                 makefile->time = (time_t)0;
 710                 NewList (&makefile->targets);
 711                 AddTail (&node->makefiles, makefile);
 712             }
 713
 714             ptr = NULL;
 715         }
 716
 717         xfree (name);
 718     }
 719
 720     chdir (curdir);
 721
 722     return makefile;
 723 }
 724
 725
 726 Makefile *
 727 findmakefile (DirNode * node, const char *filename)
 728 {
 729     const char * ptr = filename;
 730     char * name;
 731     int len;
 732     DirNode * subnode;
 733     Makefile * makefile = NULL;
 734
 735     while (ptr != NULL)
 736     {
 737         len = 0;
 738         while (ptr[len] != '/' && ptr[len] != 0)
 739             len++;
 740
 741         name = xstrndup (ptr, len);
 742         name[len] = 0;
 743
 744         if (ptr[len] == '/')
 745         {
 746             subnode = FindNode (&node->subdirs, name);
 747
 748             if (subnode == NULL)
 749             {
 750                 xfree(name);
 751                 return NULL;
 752             }
 753             node = subnode;
 754             ptr = ptr + len + 1;
 755         }
 756         else
 757         {
 758             if (len >= 4 && strcmp (name+len-4, ".src") == 0)
 759                 name[len-4] = 0;
 760
 761             makefile = FindNode (&node->makefiles, name);
 762             ptr = NULL;
 763         }
 764
 765         xfree (name);
 766     }
 767
 768     return makefile;
 769 }
 770
 771 typedef struct {
 772     Node node;
 773     DirNode * dirnode;
 774 }
 775 DirNodeRef;
 776
 777
 778 const char *
 779 buildpath (DirNode * node)
 780 {
 781     static char path[PATH_MAX];
 782     List tree;
 783     DirNodeRef * ref = NULL;
 784
 785     NewList (&tree);
 786
 787     do
 788     {
 789         if ((strlen (node->node.name) > 0) && (strcmp(node->node.name, mm_srcdir) != 0))
 790         {
 791             ref = newnodesize ("", sizeof (DirNodeRef));
 792             ref->dirnode = node;
 793             AddHead (&tree, ref);
 794         }
 795         node = node->parent;
 796     } while (node != NULL);
 797
 798     strcpy (path, "");
 799     ForeachNode (&tree, ref)
 800     {
 801         if (path[0] != 0)
 802             strcat (path, "/");
 803         strcat (path, ref->dirnode->node.name);
 804     }
 805
 806     freelist (&tree);
 807
 808     return path;
 809 }
 810
 811 Makefile *
 812 readmakefile (FILE * fh)
 813 {
 814     Makefile * makefile;
 815     MakefileTarget * mftarget;
 816     Node * n;
 817     uint32_t intt;
 818     char * s;
 819
 820     if (!readstring(fh, &s))
 821     {
 822         error ("readmakefile:readstring():%d", __LINE__);
 823         exit (20);
 824     }
 825
 826     if (s == NULL)
 827         return NULL;
 828
 829     makefile = newnodesize(s, sizeof(Makefile));
 830     xfree(s);
 831     NewList(&makefile->targets);
 832
 833     if (!readuint32 (fh, &intt))
 834     {
 835         error ("readmakefile:fread():%d", __LINE__);
 836         exit (20);
 837     }
 838     makefile->time = intt;
 839
 840     for (;;)
 841     {
 842         int32_t in;
 843
 844         if (!readstring(fh, &s))
 845         {
 846             error ("readmakefile:readstring():%d", __LINE__);
 847             exit (20);
 848         }
 849
 850         if (s == NULL)
 851             break;
 852
 853         mftarget = newnodesize(s, sizeof(MakefileTarget));
 854         xfree(s);
 855         AddTail (&makefile->targets, mftarget);
 856         NewList (&mftarget->deps);
 857
 858         if (!readint32 (fh, &in))
 859         {
 860             error ("readmakefile:fread():%d", __LINE__);
 861             exit (20);
 862         }
 863         mftarget->virtualtarget = in;
 864
 865         for (;;)
 866         {
 867             if (!readstring(fh, &s))
 868             {
 869                 error ("readmakefile:readstring():%d", __LINE__);
 870                 exit (20);
 871             }
 872
 873             if (s == NULL)
 874                 break;
 875
 876             n = newnode(s);
 877             xfree(s);
 878             AddTail (&mftarget->deps, n);
 879         }
 880     }
 881
 882     return makefile;
 883 }
 884
 885
 886 int
 887 writemakefile (FILE * fh, Makefile * makefile)
 888 {
 889     MakefileTarget * mftarget;
 890     Node * n;
 891
 892     if (makefile == NULL)
 893     {
 894         if (!writestring (fh, NULL))
 895         {
 896             error ("writemakefile/writestring():%d", __LINE__);
 897             return 0;
 898         }
 899
 900         return 1;
 901     }
 902
 903     if (!writestring (fh, makefile->node.name))
 904     {
 905         error ("writemakefile/writestring():%d", __LINE__);
 906         return 0;
 907     }
 908
 909     if (!writeuint32 (fh, makefile->time))
 910     {
 911         error ("writemakefile/fwrite():%d", __LINE__);
 912         return 0;
 913     }
 914
 915     ForeachNode (&makefile->targets, mftarget)
 916     {
 917         if (!writestring (fh, mftarget->node.name))
 918         {
 919             error ("writemakefile/writestring():%d", __LINE__);
 920             return 0;
 921         }
 922
 923         if (!writeint32 (fh, mftarget->virtualtarget))
 924         {
 925             error ("writemakefile/fwrite():%d", __LINE__);
 926             return 0;
 927         }
 928
 929         ForeachNode (&mftarget->deps, n)
 930         {
 931             if (!writestring (fh, n->name))
 932             {
 933                 error ("writemakefile/writestring():%d", __LINE__);
 934                 return 0;
 935             }
 936         }
 937
 938         if (!writestring (fh, NULL))
 939         {
 940             error ("writemakefile/writestring():%d", __LINE__);
 941             return 0;
 942         }
 943     }
 944
 945     if (!writestring(fh, NULL))
 946     {
 947         error ("writemakefile/writestring():%d", __LINE__);
 948         return 0;
 949     }
 950
 951     return 1;
 952 }
 953
 954
 955 DirNode *
 956 readcachedir (FILE * fh)
 957 {
 958     DirNode * node, * subnode;
 959     Makefile * makefile;
 960     uint32_t intt;
 961     char * s;
 962
 963     if (!readstring(fh, &s))
 964     {
 965         error ("readcachedir:readstring():%d", __LINE__);
 966         return NULL;
 967     }
 968
 969     if (s == NULL)
 970         return NULL;
 971
 972     node = newnodesize(s, sizeof(DirNode));
 973     xfree (s);
 974     NewList(&node->makefiles);
 975     NewList(&node->subdirs);
 976
 977     if (!readuint32 (fh, &intt))
 978     {
 979         error ("readcachedir:fread():%d", __LINE__);
 980         free (node);
 981         return NULL;
 982     }
 983     node->time = intt;
 984
 985     while ((makefile = readmakefile (fh)))
 986     {
 987         makefile->dir = node;
 988         AddTail (&node->makefiles, makefile);
 989     }
 990
 991     while ((subnode = readcachedir (fh)))
 992     {
 993         subnode->parent = node;
 994         AddTail (&node->subdirs, subnode);
 995     }
 996
 997     return node;
 998 }
 999
1000 int
1001 writecachedir (FILE * fh, DirNode * node)
1002 {
1003     int out;
1004     DirNode * subnode;
1005     Makefile * makefile;
1006
1007     if (node == NULL)
1008     {
1009         if (!writestring(fh, NULL))
1010         {
1011             error ("writecachedir/writestring():%d", __LINE__);
1012             return 0;
1013         }
1014
1015         return 1;
1016     }
1017
1018     if (!writestring(fh, node->node.name))
1019     {
1020         error ("writecachedir/writestring():%d", __LINE__);
1021         return 0;
1022     }
1023
1024     if (!writeuint32 (fh, node->time))
1025     {
1026         error ("writecachedir/fwrite():%d", __LINE__);
1027         return 0;
1028     }
1029
1030     ForeachNode (&node->makefiles, makefile)
1031         writemakefile (fh, makefile);
1032
1033     if (!writemakefile (fh, NULL))
1034         return 0;
1035
1036     ForeachNode (&node->subdirs, subnode)
1037     {
1038         if (!writecachedir (fh, subnode))
1039             return 0;
1040     }
1041
1042     return writecachedir (fh, NULL);
1043 }