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