tools/MetaMake/project.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_PROJECT
  22
  23 #include "config.h"
  24
  25 #include <unistd.h>
  26 #include <stdlib.h>
  27 #include <assert.h>
  28 #ifdef HAVE_STRING_H
  29 #   include <string.h>
  30 #else
  31 #   include <strings.h>
  32 #endif
  33
  34 #include "project.h"
  35 #include "var.h"
  36 #include "mem.h"
  37 #include "dep.h"
  38 #include "mmake.h"
  39
  40 #if defined(DEBUG_PROJECT)
  41 #define debug(a) a
  42 #else
  43 #define debug(v)
  44 #endif
  45
  46 struct List projects;
  47 static struct Project * defaultprj = NULL;
  48
  49 static void
  50 readvars (struct Project * prj)
  51 {
  52     struct List deps;
  53     struct Node * node, * next;
  54     struct Dep * dep;
  55
  56     debug(printf("MMAKE:project.c->readvars(Project @ 0x%p)\n", prj));
  57
  58     if (!prj->readvars)
  59         return;
  60
  61     prj->readvars = 0;
  62
  63     printf ("Read vars...\n");
  64
  65     setvar (&prj->vars, "TOP", prj->buildtop);
  66     setvar (&prj->vars, "SRCDIR", prj->srctop);
  67     setvar (&prj->vars, "CURDIR", "");
  68
  69     ForeachNode(&prj->globalvarfiles, node)
  70     {
  71         char * fn;
  72         FILE * fh;
  73         char line[256];
  74         char * name, * value, * ptr;
  75
  76         fn = xstrdup (substvars (&prj->vars, node->name));
  77         fh = fopen (fn, "r");
  78
  79         /* if the file doesn't exist execute prj->genglobalvarfile */
  80         if (!fh && prj->genglobalvarfile)
  81         {
  82             char * gen = xstrdup (substvars (&prj->vars, prj->genglobalvarfile));
  83
  84             printf ("Generating %s...\n", fn);
  85
  86             if (!execute (prj, gen, "-", "-", ""))
  87             {
  88                 error ("Error while creating \"%s\" with \"%s\"", fn, gen);
  89                 exit (10);
  90             }
  91             else
  92                 fh = fopen (fn, "r");
  93
  94             xfree (gen);
  95         }
  96
  97         if (!fh)
  98         {
  99             error ("readvars():fopen(): Opening \"%s\" for reading", fn);
 100             return;
 101         }
 102
 103         xfree (fn);
 104
 105         while (fgets (line, sizeof(line), fh))
 106         {
 107             if (*line == '\n' || *line == '#') continue;
 108             line[strlen(line)-1] = 0;
 109
 110             ptr = line;
 111             while (isspace (*ptr)) ptr++;
 112             name = ptr;
 113             while (*ptr && !isspace(*ptr) && *ptr != ':' && *ptr != '=')
 114                 ptr ++;
 115
 116             if (*ptr)
 117                 *ptr++ = 0;
 118
 119             while (isspace(*ptr) || *ptr == ':' || *ptr == '=')
 120                 ptr ++;
 121
 122             value = ptr;
 123
 124             while (*ptr && *ptr != '#')
 125                 ptr ++;
 126
 127             *ptr = 0;
 128
 129             if (debug)
 130                 printf ("%s=%s\n", name, substvars (&prj->vars, value));
 131
 132             setvar (&prj->vars, name, substvars (&prj->vars, value));
 133         }
 134
 135         fclose (fh);
 136     }
 137
 138     /* handle prj->genmakefiledeps */
 139     NewList(&deps);
 140     /* algorithm has changed from:
 141      * copying nodes to deps list and then generating dep nodes
 142      * which will be put back to genmakefiledeps list
 143      * to:
 144      * generating new dep nodes and putting them into the deps list,
 145      * then copy them back into genmakefiledeps list
 146      * reason for change:
 147      * in recent versions of gcc (>= 4.6) the first loop over all
 148      * genmakefiledeps list nodes was optimized away, so deps list
 149      * was always empty and the second loop never did anything */
 150     ForeachNodeSafe (&prj->genmakefiledeps, node, next)
 151     {
 152         Remove (node);
 153         dep = newdepnode (substvars (&prj->vars, node->name));
 154         AddTail (&deps, dep);
 155         xfree (node->name);
 156         xfree (node);
 157     }
 158
 159     ForeachNodeSafe (&deps, node, next)
 160     {
 161         Remove (node);
 162         AddTail (&prj->genmakefiledeps, node);
 163     }
 164
 165     if (debug)
 166     {
 167         printf ("project %s.genmfdeps=\n", prj->node.name);
 168         printlist (&prj->genmakefiledeps);
 169     }
 170
 171     if (debug)
 172     {
 173         printf ("project %s.vars=", prj->node.name);
 174         printvarlist (&prj->vars);
 175     }
 176 }
 177
 178 static struct Project *
 179 initproject (char * name)
 180 {
 181     struct Project * prj = new (struct Project);
 182
 183     memset (prj, 0, sizeof(struct Project));
 184
 185     debug(printf("MMAKE:project.c->initproject('%s')\n", name));
 186     debug(printf("MMAKE:project.c->initproject: Project node @ 0x%p\n", prj));
 187
 188     if (!defaultprj)
 189     {
 190         prj->maketool = xstrdup ("make \"TOP=$(TOP)\" \"SRCDIR=$(SRCDIR)\" \"CURDIR=$(CURDIR)\"");
 191         prj->defaultmakefilename = xstrdup ("Makefile");
 192         prj->srctop = mm_srcdir;
 193         prj->buildtop = mm_builddir;
 194         prj->defaulttarget = xstrdup ("all");
 195         prj->genmakefilescript = NULL;
 196         prj->genglobalvarfile = NULL;
 197     }
 198     else
 199     {
 200         prj->maketool = xstrdup (defaultprj->maketool);
 201         prj->defaultmakefilename = xstrdup (defaultprj->defaultmakefilename);
 202         prj->srctop = xstrdup (defaultprj->srctop);
 203         prj->buildtop = xstrdup (defaultprj->buildtop);
 204         prj->defaulttarget = xstrdup (defaultprj->defaulttarget);
 205         SETSTR (prj->genmakefilescript, defaultprj->genmakefilescript);
 206         SETSTR (prj->genglobalvarfile, defaultprj->genglobalvarfile);
 207     }
 208
 209     prj->node.name = xstrdup (name);
 210
 211     prj->readvars = 1;
 212
 213     NewList(&prj->globalvarfiles);
 214     NewList(&prj->genmakefiledeps);
 215     NewList(&prj->ignoredirs);
 216     NewList(&prj->vars);
 217     NewList(&prj->extramakefiles);
 218
 219     return prj;
 220 }
 221
 222 static void
 223 freeproject (struct Project * prj)
 224 {
 225     assert (prj);
 226
 227     cfree (prj->node.name);
 228     cfree (prj->maketool);
 229     cfree (prj->defaultmakefilename);
 230     if (prj->srctop != mm_srcdir)
 231         cfree (prj->srctop);
 232     if (prj->buildtop != mm_builddir)
 233         cfree (prj->buildtop);
 234     cfree (prj->defaulttarget);
 235     cfree (prj->genmakefilescript);
 236     cfree (prj->genglobalvarfile);
 237
 238     if (prj->cache)
 239         closecache (prj->cache);
 240
 241     freelist(&prj->globalvarfiles);
 242     freelist (&prj->genmakefiledeps);
 243     freelist (&prj->ignoredirs);
 244     freevarlist (&prj->vars);
 245     freelist (&prj->extramakefiles);
 246
 247     xfree (prj);
 248 }
 249
 250 static void
 251 callmake (struct Project * prj, const char * tname, struct Makefile * makefile)
 252 {
 253     static char buffer[4096];
 254     const char * path = buildpath (makefile->dir);
 255     int t;
 256
 257     debug(printf("MMAKE:project.c->callmake()\n"));
 258
 259     if (makefile->generated)
 260         chdir (prj->buildtop);
 261     else
 262         chdir (prj->srctop);
 263     chdir (path);
 264
 265     setvar (&prj->vars, "CURDIR", path);
 266     setvar (&prj->vars, "TARGET", tname);
 267
 268     buffer[0] = '\0';
 269
 270     for (t=0; t<mflagc; t++)
 271     {
 272         strcat (buffer, mflags[t]);
 273         strcat (buffer, " ");
 274     }
 275
 276     if (strcmp (makefile->node.name, "Makefile")!=0 && strcmp (makefile->node.name, "makefile")!=0);
 277     {
 278         strcat (buffer, "--file=");
 279         strcat (buffer, makefile->node.name);
 280         strcat (buffer, " ");
 281     }
 282
 283     strcat (buffer, tname);
 284
 285     if (!quiet)
 286         printf ("Making %s in %s\n", tname, path);
 287
 288     if (!execute (prj, prj->maketool, "-", "-", buffer))
 289     {
 290         error ("Error while running make in %s", path);
 291         exit (10);
 292     }
 293 }
 294
 295
 296 void
 297 initprojects (void)
 298 {
 299     char * optionfile;
 300     char * home;
 301     char line[256];
 302     FILE * optfh = NULL;
 303     struct Project * project;
 304
 305     debug(printf("MMAKE:project.c->initprojects()\n"));
 306
 307     NewList(&projects);
 308     defaultprj = project = initproject ("default");
 309     AddTail(&projects, project);
 310
 311
 312     /* Try "$MMAKE_CONFIG" */
 313     if ((optionfile = getenv ("MMAKE_CONFIG")))
 314         optfh = fopen (optionfile, "r");
 315
 316     /* Try "$HOME/.mmake.config" */
 317     if (!optfh)
 318     {
 319         if ((home = getenv("HOME")))
 320         {
 321             optionfile = xmalloc (strlen(home) + sizeof("/.mmake.config") + 1);
 322             sprintf (optionfile, "%s/.mmake.config", home);
 323             optfh = fopen (optionfile, "r");
 324             free (optionfile);
 325         }
 326     }
 327
 328     /* Try with $CWD/.mmake.config" */
 329     if (!optfh)
 330         optfh = fopen (".mmake.config", "r");
 331
 332     /* Try with "$CWD/mmake.config */
 333     if (!optfh)
 334         optfh = fopen ("mmake.config", "r");
 335
 336     /* Give up */
 337     if (!optfh)
 338     {
 339         fprintf (stderr,
 340                 "Please set the HOME or MMAKE_CONFIG env var (with setenv or export)\n"
 341                 );
 342         error ("Opening mmake.config for reading");
 343         exit (10);
 344     }
 345
 346     while (fgets (line, sizeof(line), optfh))
 347     {
 348         if (*line == '\n' || *line == '#') continue;
 349         line[strlen(line)-1] = 0;
 350
 351         if (*line == '[') /* look for project name */
 352         {
 353             char * name, * ptr;
 354
 355             name = ptr = line+1;
 356             while (*ptr && *ptr != ']')
 357                 ptr ++;
 358
 359             *ptr = 0;
 360
 361             debug(printf("MMAKE:project.c->initprojects: Adding '%s' from MMAKE_CONFIG\n", name));
 362
 363             project = initproject (name);
 364
 365             AddTail(&projects,project);
 366         }
 367         else
 368         {
 369             char * cmd, * args, * ptr;
 370
 371             cmd = line;
 372             while (isspace (*cmd))
 373                 cmd ++;
 374
 375             args = cmd;
 376             while (*args && !isspace(*args))
 377             {
 378                 *args = tolower (*args);
 379                 args ++;
 380             }
 381             if (*args)
 382                 *args++ = 0;
 383             while (isspace (*args))
 384                 args ++;
 385
 386             ptr = args;
 387
 388             while (*ptr && *ptr != '\n')
 389                 ptr ++;
 390
 391             *ptr = 0;
 392
 393             if (!strcmp (cmd, "add"))
 394             {
 395                 struct Node * n;
 396                 n = newnode(args);
 397                 AddTail(&project->extramakefiles, n);
 398             }
 399             else if (!strcmp (cmd, "ignoredir"))
 400             {
 401                 struct Node * n;
 402                 n = newnode(args);
 403                 AddTail(&project->ignoredirs, n);
 404             }
 405             else if (!strcmp (cmd, "defaultmakefilename"))
 406             {
 407                 SETSTR(project->defaultmakefilename,args);
 408             }
 409             else if (!strcmp (cmd, "top"))
 410             {
 411                 SETSTR(project->srctop,args);
 412             }
 413             else if (!strcmp (cmd, "defaulttarget"))
 414             {
 415                 SETSTR(project->defaulttarget,args);
 416             }
 417             else if (!strcmp (cmd, "genmakefilescript"))
 418             {
 419                 SETSTR(project->genmakefilescript,args);
 420             }
 421             else if (!strcmp (cmd, "genmakefiledeps"))
 422             {
 423                 struct Node * dep;
 424                 int depc, t;
 425                 char ** deps = getargs (args, &depc, NULL);
 426
 427                 debug(printf("MMAKE/project.c: genmakefiledeps depc=%d\n", depc));
 428
 429                 for (t=0; t<depc; t++)
 430                 {
 431                     dep = addnodeonce (&project->genmakefiledeps, deps[t]);
 432                 }
 433             }
 434             else if (!strcmp (cmd, "globalvarfile"))
 435             {
 436                 struct Node *n = newnode(args);
 437
 438                 if (n)
 439                     AddTail(&project->globalvarfiles, n);
 440             }
 441             else if (!strcmp (cmd, "genglobalvarfile"))
 442             {
 443                 SETSTR(project->genglobalvarfile,args);
 444             }
 445             else if (!strcmp (cmd, "maketool"))
 446             {
 447                 SETSTR(project->maketool,args);
 448             }
 449             else
 450             {
 451                 setvar(&project->vars, cmd, args);
 452             }
 453         }
 454     }
 455
 456     fclose (optfh);
 457
 458     /* Clean up memory from getargs */
 459     getargs (NULL, NULL, NULL);
 460
 461     if (debug)
 462     {
 463         printf ("known projects: ");
 464         printlist (&projects);
 465     }
 466 }
 467
 468 void
 469 expungeprojects (void)
 470 {
 471     struct Project *prj, *next;
 472
 473     ForeachNodeSafe (&projects, prj, next)
 474     {
 475         Remove (prj);
 476         freeproject (prj);
 477     }
 478 }
 479
 480 struct Project *
 481 findproject (const char * pname)
 482 {
 483     return FindNode (&projects, pname);
 484 }
 485
 486 struct Project *
 487 getfirstproject (void)
 488 {
 489     struct Project * prj = GetHead (&projects);
 490
 491     if (prj && prj == defaultprj)
 492         prj = GetNext (prj);
 493
 494     return prj;
 495 }
 496
 497 int
 498 execute (struct Project * prj, const char * cmd, const char * in,
 499         const char * out, const char * args)
 500 {
 501     char buffer[4096];
 502     char * cmdstr;
 503     int rc;
 504
 505     debug(printf("MMAKE:project.c->execute(cmd '%s')\n", cmd));
 506
 507     strcpy (buffer, cmd);
 508     strcat (buffer, " ");
 509
 510     if (strcmp (in, "-"))
 511     {
 512         strcat (buffer, "<");
 513         strcat (buffer, in);
 514         strcat (buffer, " ");
 515     }
 516
 517     if (strcmp (out, "-"))
 518     {
 519         strcat (buffer, ">");
 520         strcat (buffer, out);
 521         strcat (buffer, " ");
 522     }
 523
 524     strcat (buffer, args);
 525
 526     cmdstr = substvars (&prj->vars, buffer);
 527
 528     debug(printf("MMAKE:project.c->execute: parsed cmd '%s'\n", buffer));
 529
 530     if (verbose)
 531         printf ("Executing %s...\n", cmdstr);
 532
 533     rc = system (cmdstr);
 534
 535     if (rc)
 536     {
 537         printf ("%s failed: %d\n", cmdstr, rc);
 538     }
 539
 540     return !rc;
 541 }
 542
 543 void
 544 maketarget (struct Project * prj, char * tname)
 545 {
 546     struct Target * target, * subtarget;
 547     struct Node * node;
 548     struct MakefileRef * mfref;
 549     struct MakefileTarget * mftarget;
 550     struct List deps;
 551
 552     if (!quiet)
 553         printf ("Building %s.%s\n", prj->node.name, tname);
 554
 555     NewList (&deps);
 556
 557     chdir (prj->srctop);
 558
 559     readvars (prj);
 560
 561     if (!prj->cache)
 562         prj->cache = activatecache (prj);
 563
 564     if (!*tname)
 565         tname = prj->defaulttarget;
 566
 567     target = FindNode (&prj->cache->targets, tname);
 568
 569     if (!target)
 570     {
 571         if (!quiet)
 572             printf ("Nothing known about target %s in project %s\n", tname, prj->node.name);
 573         return;
 574     }
 575
 576     target->updated = 1;
 577
 578     ForeachNode (&target->makefiles, mfref)
 579     {
 580         mftarget = FindNode (&mfref->makefile->targets, tname);
 581
 582         ForeachNode (&mftarget->deps, node)
 583             addnodeonce (&deps, node->name);
 584     }
 585
 586     ForeachNode (&deps, node)
 587     {
 588         subtarget = FindNode (&prj->cache->targets, node->name);
 589
 590         if (!subtarget)
 591         {
 592             if (!quiet)
 593                 printf ("Nothing known about target %s in project %s\n", node->name, prj->node.name);
 594         }
 595         else if (!subtarget->updated)
 596         {
 597             maketarget (prj, node->name);
 598         }
 599     }
 600
 601     freelist (&deps);
 602
 603     ForeachNode (&target->makefiles, mfref)
 604     {
 605         if (!mfref->virtualtarget)
 606         {
 607             callmake (prj, tname, mfref->makefile);
 608         }
 609     }
 610
 611     freelist (&deps);
 612 }