tools/MetaMake/dirnode.c

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