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 ("[MMAKE] 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 ("[MMAKE] 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 ("[MMAKE] %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 ("[MMAKE] project %s.genmfdeps=\n", prj->node.name);
 168         printlist (&prj->genmakefiledeps);
 169     }
 170
 171     if (debug)
 172     {
 173         printf ("[MMAKE] 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         ASSERT(chdir (prj->buildtop) == 0);
 261     else
 262         ASSERT(chdir (prj->srctop) == 0);
 263     if (path[0] != 0)
 264         ASSERT(chdir (path) == 0);
 265
 266     setvar (&prj->vars, "CURDIR", path);
 267     setvar (&prj->vars, "TARGET", tname);
 268
 269     buffer[0] = '\0';
 270
 271     for (t=0; t<mflagc; t++)
 272     {
 273         strcat (buffer, mflags[t]);
 274         strcat (buffer, " ");
 275     }
 276
 277     if (strcmp (makefile->node.name, "Makefile")!=0 && strcmp (makefile->node.name, "makefile")!=0)
 278     {
 279         strcat (buffer, "--file=");
 280         strcat (buffer, makefile->node.name);
 281         strcat (buffer, " ");
 282     }
 283
 284     strcat (buffer, tname);
 285
 286     if (!quiet)
 287         printf ("[MMAKE] Making %s in %s\n", tname, path);
 288
 289     if (!execute (prj, prj->maketool, "-", "-", buffer))
 290     {
 291         error ("Error while running make in %s", path);
 292         exit (10);
 293     }
 294 }
 295
 296
 297 void
 298 initprojects (void)
 299 {
 300     char * optionfile;
 301     char * home;
 302     char line[256];
 303     FILE * optfh = NULL;
 304     struct Project * project;
 305
 306     debug(printf("MMAKE:project.c->initprojects()\n"));
 307
 308     NewList(&projects);
 309     defaultprj = project = initproject ("default");
 310     AddTail(&projects, project);
 311
 312
 313     /* Try "$MMAKE_CONFIG" */
 314     if ((optionfile = getenv ("MMAKE_CONFIG")))
 315         optfh = fopen (optionfile, "r");
 316
 317     /* Try "$HOME/.mmake.config" */
 318     if (!optfh)
 319     {
 320         if ((home = getenv("HOME")))
 321         {
 322             optionfile = xmalloc (strlen(home) + sizeof("/.mmake.config") + 1);
 323             sprintf (optionfile, "%s/.mmake.config", home);
 324             optfh = fopen (optionfile, "r");
 325             free (optionfile);
 326         }
 327     }
 328
 329     /* Try with $CWD/.mmake.config" */
 330     if (!optfh)
 331         optfh = fopen (".mmake.config", "r");
 332
 333     /* Try with "$CWD/mmake.config */
 334     if (!optfh)
 335         optfh = fopen ("mmake.config", "r");
 336
 337     /* Give up */
 338     if (!optfh)
 339     {
 340         fprintf (stderr,
 341                 "[MMAKE] Please set the HOME or MMAKE_CONFIG env var (with setenv or export)\n"
 342                 );
 343         error ("Opening mmake.config for reading");
 344         exit (10);
 345     }
 346
 347     while (fgets (line, sizeof(line), optfh))
 348     {
 349         if (*line == '\n' || *line == '#') continue;
 350         line[strlen(line)-1] = 0;
 351
 352         if (*line == '[') /* look for project name */
 353         {
 354             char * name, * ptr;
 355
 356             name = ptr = line+1;
 357             while (*ptr && *ptr != ']')
 358                 ptr ++;
 359
 360             *ptr = 0;
 361
 362             debug(printf("MMAKE:project.c->initprojects: Adding '%s' from MMAKE_CONFIG\n", name));
 363
 364             project = initproject (name);
 365
 366             AddTail(&projects,project);
 367         }
 368         else
 369         {
 370             char * cmd, * args, * ptr;
 371
 372             cmd = line;
 373             while (isspace (*cmd))
 374                 cmd ++;
 375
 376             args = cmd;
 377             while (*args && !isspace(*args))
 378             {
 379                 *args = tolower (*args);
 380                 args ++;
 381             }
 382             if (*args)
 383                 *args++ = 0;
 384             while (isspace (*args))
 385                 args ++;
 386
 387             ptr = args;
 388
 389             while (*ptr && *ptr != '\n')
 390                 ptr ++;
 391
 392             *ptr = 0;
 393
 394             if (!strcmp (cmd, "add"))
 395             {
 396                 struct Node * n;
 397                 n = newnode(args);
 398                 AddTail(&project->extramakefiles, n);
 399             }
 400             else if (!strcmp (cmd, "ignoredir"))
 401             {
 402                 struct Node * n;
 403                 n = newnode(args);
 404                 AddTail(&project->ignoredirs, n);
 405             }
 406             else if (!strcmp (cmd, "defaultmakefilename"))
 407             {
 408                 SETSTR(project->defaultmakefilename,args);
 409             }
 410             else if (!strcmp (cmd, "top"))
 411             {
 412                 SETSTR(project->srctop,args);
 413             }
 414             else if (!strcmp (cmd, "defaulttarget"))
 415             {
 416                 SETSTR(project->defaulttarget,args);
 417             }
 418             else if (!strcmp (cmd, "genmakefilescript"))
 419             {
 420                 SETSTR(project->genmakefilescript,args);
 421             }
 422             else if (!strcmp (cmd, "genmakefiledeps"))
 423             {
 424                 struct Node * dep;
 425                 int depc, t;
 426                 char ** deps = getargs (args, &depc, NULL);
 427
 428                 debug(printf("MMAKE/project.c: genmakefiledeps depc=%d\n", depc));
 429
 430                 for (t=0; t<depc; t++)
 431                 {
 432                     dep = addnodeonce (&project->genmakefiledeps, deps[t]);
 433                 }
 434             }
 435             else if (!strcmp (cmd, "globalvarfile"))
 436             {
 437                 struct Node *n = newnode(args);
 438
 439                 if (n)
 440                     AddTail(&project->globalvarfiles, n);
 441             }
 442             else if (!strcmp (cmd, "genglobalvarfile"))
 443             {
 444                 SETSTR(project->genglobalvarfile,args);
 445             }
 446             else if (!strcmp (cmd, "maketool"))
 447             {
 448                 SETSTR(project->maketool,args);
 449             }
 450             else
 451             {
 452                 setvar(&project->vars, cmd, args);
 453             }
 454         }
 455     }
 456
 457     fclose (optfh);
 458
 459     /* Clean up memory from getargs */
 460     getargs (NULL, NULL, NULL);
 461
 462     if (debug)
 463     {
 464         printf ("[MMAKE] known projects: ");
 465         printlist (&projects);
 466     }
 467 }
 468
 469 void
 470 expungeprojects (void)
 471 {
 472     struct Project *prj, *next;
 473
 474     ForeachNodeSafe (&projects, prj, next)
 475     {
 476         Remove (prj);
 477         freeproject (prj);
 478     }
 479 }
 480
 481 struct Project *
 482 findproject (const char * pname)
 483 {
 484     return FindNode (&projects, pname);
 485 }
 486
 487 struct Project *
 488 getfirstproject (void)
 489 {
 490     struct Project * prj = GetHead (&projects);
 491
 492     if (prj && prj == defaultprj)
 493         prj = GetNext (prj);
 494
 495     return prj;
 496 }
 497
 498 int
 499 execute (struct Project * prj, const char * cmd, const char * in,
 500         const char * out, const char * args)
 501 {
 502     char buffer[4096];
 503     char * cmdstr;
 504     int rc;
 505
 506     debug(printf("MMAKE:project.c->execute(cmd '%s')\n", cmd));
 507
 508     strcpy (buffer, cmd);
 509     strcat (buffer, " ");
 510
 511     if (strcmp (in, "-"))
 512     {
 513         strcat (buffer, "<");
 514         strcat (buffer, in);
 515         strcat (buffer, " ");
 516     }
 517
 518     if (strcmp (out, "-"))
 519     {
 520         strcat (buffer, ">");
 521         strcat (buffer, out);
 522         strcat (buffer, " ");
 523     }
 524
 525     strcat (buffer, args);
 526
 527     cmdstr = substvars (&prj->vars, buffer);
 528
 529     debug(printf("MMAKE:project.c->execute: parsed cmd '%s'\n", buffer));
 530
 531     if (verbose)
 532         printf ("[MMAKE] Executing %s...\n", cmdstr);
 533
 534     rc = system (cmdstr);
 535
 536     if (rc)
 537     {
 538         printf ("[MMAKE] %s failed: %d\n", cmdstr, rc);
 539     }
 540
 541     return !rc;
 542 }
 543
 544 void
 545 maketarget (struct Project * prj, char * tname)
 546 {
 547     struct Target * target, * subtarget;
 548     struct Node * node;
 549     struct MakefileRef * mfref;
 550     struct MakefileTarget * mftarget;
 551     struct List deps;
 552
 553     if (!quiet)
 554         printf ("[MMAKE] Building %s.%s\n", prj->node.name, tname);
 555
 556     NewList (&deps);
 557
 558     ASSERT(chdir (prj->srctop) == 0);
 559
 560     readvars (prj);
 561
 562     if (!prj->cache)
 563         prj->cache = activatecache (prj);
 564
 565     if (!*tname)
 566         tname = prj->defaulttarget;
 567
 568     target = FindNode (&prj->cache->targets, tname);
 569
 570     if (!target)
 571     {
 572         if (!quiet)
 573             printf ("[MMAKE] Nothing known about target %s in project %s\n", tname, prj->node.name);
 574         return;
 575     }
 576
 577     target->updated = 1;
 578
 579     ForeachNode (&target->makefiles, mfref)
 580     {
 581         mftarget = FindNode (&mfref->makefile->targets, tname);
 582
 583         ForeachNode (&mftarget->deps, node)
 584             addnodeonce (&deps, node->name);
 585     }
 586
 587     ForeachNode (&deps, node)
 588     {
 589         subtarget = FindNode (&prj->cache->targets, node->name);
 590
 591         if (!subtarget)
 592         {
 593             if (!quiet)
 594                 printf ("[MMAKE] Nothing known about target %s in project %s\n", node->name, prj->node.name);
 595         }
 596         else if (!subtarget->updated)
 597         {
 598             maketarget (prj, node->name);
 599         }
 600     }
 601
 602     freelist (&deps);
 603
 604     ForeachNode (&target->makefiles, mfref)
 605     {
 606         if (!mfref->virtualtarget)
 607         {
 608             callmake (prj, tname, mfref->makefile);
 609         }
 610     }
 611
 612     freelist (&deps);
 613 }