tools/MetaMake/project.c

   1 /* MetaMake - A Make extension
   2    Copyright © 1995-2011, 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     ForeachNodeSafe (&prj->genmakefiledeps, node, next)
 141     {
 142         Remove (node);
 143         AddTail (&deps, node);
 144     }
 145
 146     ForeachNodeSafe (&deps, node, next)
 147     {
 148         Remove (node);
 149         dep = newdepnode (substvars (&prj->vars, node->name));
 150         AddTail (&prj->genmakefiledeps, dep);
 151         xfree (node->name);
 152         xfree (node);
 153     }
 154
 155     if (debug)
 156     {
 157         printf ("project %s.genmfdeps=\n", prj->node.name);
 158         printlist (&prj->genmakefiledeps);
 159     }
 160
 161     if (debug)
 162     {
 163         printf ("project %s.vars=", prj->node.name);
 164         printvarlist (&prj->vars);
 165     }
 166 }
 167
 168 static struct Project *
 169 initproject (char * name)
 170 {
 171     struct Project * prj = new (struct Project);
 172
 173     memset (prj, 0, sizeof(struct Project));
 174
 175     debug(printf("MMAKE:project.c->initproject('%s')\n", name));
 176     debug(printf("MMAKE:project.c->initproject: Project node @ 0x%p\n", prj));
 177
 178     if (!defaultprj)
 179     {
 180         prj->maketool = xstrdup ("make \"TOP=$(TOP)\" \"SRCDIR=$(SRCDIR)\" \"CURDIR=$(CURDIR)\"");
 181         prj->defaultmakefilename = xstrdup ("Makefile");
 182         prj->srctop = mm_srcdir;
 183         prj->buildtop = mm_builddir;
 184         prj->defaulttarget = xstrdup ("all");
 185         prj->genmakefilescript = NULL;
 186         prj->genglobalvarfile = NULL;
 187     }
 188     else
 189     {
 190         prj->maketool = xstrdup (defaultprj->maketool);
 191         prj->defaultmakefilename = xstrdup (defaultprj->defaultmakefilename);
 192         prj->srctop = xstrdup (defaultprj->srctop);
 193         prj->buildtop = xstrdup (defaultprj->buildtop);
 194         prj->defaulttarget = xstrdup (defaultprj->defaulttarget);
 195         SETSTR (prj->genmakefilescript, defaultprj->genmakefilescript);
 196         SETSTR (prj->genglobalvarfile, defaultprj->genglobalvarfile);
 197     }
 198
 199     prj->node.name = xstrdup (name);
 200
 201     prj->readvars = 1;
 202
 203     NewList(&prj->globalvarfiles);
 204     NewList(&prj->genmakefiledeps);
 205     NewList(&prj->ignoredirs);
 206     NewList(&prj->vars);
 207     NewList(&prj->extramakefiles);
 208
 209     return prj;
 210 }
 211
 212 static void
 213 freeproject (struct Project * prj)
 214 {
 215     assert (prj);
 216
 217     cfree (prj->node.name);
 218     cfree (prj->maketool);
 219     cfree (prj->defaultmakefilename);
 220     if (prj->srctop != mm_srcdir)
 221         cfree (prj->srctop);
 222     if (prj->buildtop != mm_builddir)
 223         cfree (prj->buildtop);
 224     cfree (prj->defaulttarget);
 225     cfree (prj->genmakefilescript);
 226     cfree (prj->genglobalvarfile);
 227
 228     if (prj->cache)
 229         closecache (prj->cache);
 230
 231     freelist(&prj->globalvarfiles);
 232     freelist (&prj->genmakefiledeps);
 233     freelist (&prj->ignoredirs);
 234     freevarlist (&prj->vars);
 235     freelist (&prj->extramakefiles);
 236
 237     xfree (prj);
 238 }
 239
 240 static void
 241 callmake (struct Project * prj, const char * tname, struct Makefile * makefile)
 242 {
 243     static char buffer[4096];
 244     const char * path = buildpath (makefile->dir);
 245     int t;
 246
 247     debug(printf("MMAKE:project.c->callmake()\n"));
 248
 249     if (makefile->generated)
 250         chdir (prj->buildtop);
 251     else
 252         chdir (prj->srctop);
 253     chdir (path);
 254
 255     setvar (&prj->vars, "CURDIR", path);
 256     setvar (&prj->vars, "TARGET", tname);
 257
 258     buffer[0] = '\0';
 259
 260     for (t=0; t<mflagc; t++)
 261     {
 262         strcat (buffer, mflags[t]);
 263         strcat (buffer, " ");
 264     }
 265
 266     if (strcmp (makefile->node.name, "Makefile")!=0 && strcmp (makefile->node.name, "makefile")!=0);
 267     {
 268         strcat (buffer, "--file=");
 269         strcat (buffer, makefile->node.name);
 270         strcat (buffer, " ");
 271     }
 272
 273     strcat (buffer, tname);
 274
 275     if (!quiet)
 276         printf ("Making %s in %s\n", tname, path);
 277
 278     if (!execute (prj, prj->maketool, "-", "-", buffer))
 279     {
 280         error ("Error while running make in %s", path);
 281         exit (10);
 282     }
 283 }
 284
 285
 286 void
 287 initprojects (void)
 288 {
 289     char * optionfile;
 290     char * home;
 291     char line[256];
 292     FILE * optfh = NULL;
 293     struct Project * project;
 294
 295     debug(printf("MMAKE:project.c->initprojects()\n"));
 296
 297     NewList(&projects);
 298     defaultprj = project = initproject ("default");
 299     AddTail(&projects, project);
 300
 301
 302     /* Try "$MMAKE_CONFIG" */
 303     if ((optionfile = getenv ("MMAKE_CONFIG")))
 304         optfh = fopen (optionfile, "r");
 305
 306     /* Try "$HOME/.mmake.config" */
 307     if (!optfh)
 308     {
 309         if ((home = getenv("HOME")))
 310         {
 311             optionfile = xmalloc (strlen(home) + sizeof("/.mmake.config") + 1);
 312             sprintf (optionfile, "%s/.mmake.config", home);
 313             optfh = fopen (optionfile, "r");
 314             free (optionfile);
 315         }
 316     }
 317
 318     /* Try with $CWD/.mmake.config" */
 319     if (!optfh)
 320         optfh = fopen (".mmake.config", "r");
 321
 322     /* Try with "$CWD/mmake.config */
 323     if (!optfh)
 324         optfh = fopen ("mmake.config", "r");
 325
 326     /* Give up */
 327     if (!optfh)
 328     {
 329         fprintf (stderr,
 330                 "Please set the HOME or MMAKE_CONFIG env var (with setenv or export)\n"
 331                 );
 332         error ("Opening mmake.config for reading");
 333         exit (10);
 334     }
 335
 336     while (fgets (line, sizeof(line), optfh))
 337     {
 338         if (*line == '\n' || *line == '#') continue;
 339         line[strlen(line)-1] = 0;
 340
 341         if (*line == '[') /* look for project name */
 342         {
 343             char * name, * ptr;
 344
 345             name = ptr = line+1;
 346             while (*ptr && *ptr != ']')
 347                 ptr ++;
 348
 349             *ptr = 0;
 350
 351             debug(printf("MMAKE:project.c->initprojects: Adding '%s' from MMAKE_CONFIG\n", name));
 352
 353             project = initproject (name);
 354
 355             AddTail(&projects,project);
 356         }
 357         else
 358         {
 359             char * cmd, * args, * ptr;
 360
 361             cmd = line;
 362             while (isspace (*cmd))
 363                 cmd ++;
 364
 365             args = cmd;
 366             while (*args && !isspace(*args))
 367             {
 368                 *args = tolower (*args);
 369                 args ++;
 370             }
 371             if (*args)
 372                 *args++ = 0;
 373             while (isspace (*args))
 374                 args ++;
 375
 376             ptr = args;
 377
 378             while (*ptr && *ptr != '\n')
 379                 ptr ++;
 380
 381             *ptr = 0;
 382
 383             if (!strcmp (cmd, "add"))
 384             {
 385                 struct Node * n;
 386                 n = newnode(args);
 387                 AddTail(&project->extramakefiles, n);
 388             }
 389             else if (!strcmp (cmd, "ignoredir"))
 390             {
 391                 struct Node * n;
 392                 n = newnode(args);
 393                 AddTail(&project->ignoredirs, n);
 394             }
 395             else if (!strcmp (cmd, "defaultmakefilename"))
 396             {
 397                 SETSTR(project->defaultmakefilename,args);
 398             }
 399             else if (!strcmp (cmd, "top"))
 400             {
 401                 SETSTR(project->srctop,args);
 402             }
 403             else if (!strcmp (cmd, "defaulttarget"))
 404             {
 405                 SETSTR(project->defaulttarget,args);
 406             }
 407             else if (!strcmp (cmd, "genmakefilescript"))
 408             {
 409                 SETSTR(project->genmakefilescript,args);
 410             }
 411             else if (!strcmp (cmd, "genmakefiledeps"))
 412             {
 413                 struct Node * dep;
 414                 int depc, t;
 415                 char ** deps = getargs (args, &depc, NULL);
 416
 417                 for (t=0; t<depc; t++)
 418                 {
 419                     dep = addnodeonce (&project->genmakefiledeps, deps[t]);
 420                 }
 421             }
 422             else if (!strcmp (cmd, "globalvarfile"))
 423             {
 424                 struct Node *n = newnode(args);
 425
 426                 if (n)
 427                         AddTail(&project->globalvarfiles, n);
 428             }
 429             else if (!strcmp (cmd, "genglobalvarfile"))
 430             {
 431                 SETSTR(project->genglobalvarfile,args);
 432             }
 433             else if (!strcmp (cmd, "maketool"))
 434             {
 435                 SETSTR(project->maketool,args);
 436             }
 437             else
 438             {
 439                 setvar(&project->vars, cmd, args);
 440             }
 441         }
 442     }
 443
 444     fclose (optfh);
 445
 446     /* Clean up memory from getargs */
 447     getargs (NULL, NULL, NULL);
 448
 449     if (debug)
 450     {
 451         printf ("known projects: ");
 452         printlist (&projects);
 453     }
 454 }
 455
 456 void
 457 expungeprojects (void)
 458 {
 459     struct Project *prj, *next;
 460
 461     ForeachNodeSafe (&projects, prj, next)
 462     {
 463         Remove (prj);
 464         freeproject (prj);
 465     }
 466 }
 467
 468 struct Project *
 469 findproject (const char * pname)
 470 {
 471     return FindNode (&projects, pname);
 472 }
 473
 474 struct Project *
 475 getfirstproject (void)
 476 {
 477     struct Project * prj = GetHead (&projects);
 478
 479     if (prj && prj == defaultprj)
 480         prj = GetNext (prj);
 481
 482     return prj;
 483 }
 484
 485 int
 486 execute (struct Project * prj, const char * cmd, const char * in,
 487         const char * out, const char * args)
 488 {
 489     char buffer[4096];
 490     char * cmdstr;
 491     int rc;
 492
 493     debug(printf("MMAKE:project.c->execute(cmd '%s')\n", cmd));
 494
 495     strcpy (buffer, cmd);
 496     strcat (buffer, " ");
 497
 498     if (strcmp (in, "-"))
 499     {
 500         strcat (buffer, "<");
 501         strcat (buffer, in);
 502         strcat (buffer, " ");
 503     }
 504
 505     if (strcmp (out, "-"))
 506     {
 507         strcat (buffer, ">");
 508         strcat (buffer, out);
 509         strcat (buffer, " ");
 510     }
 511
 512     strcat (buffer, args);
 513
 514     cmdstr = substvars (&prj->vars, buffer);
 515
 516     debug(printf("MMAKE:project.c->execute: parsed cmd '%s'\n", buffer));
 517
 518     if (verbose)
 519         printf ("Executing %s...\n", cmdstr);
 520
 521     rc = system (cmdstr);
 522
 523     if (rc)
 524     {
 525         printf ("%s failed: %d\n", cmdstr, rc);
 526     }
 527
 528     return !rc;
 529 }
 530
 531 void
 532 maketarget (struct Project * prj, char * tname)
 533 {
 534     struct Target * target, * subtarget;
 535     struct Node * node;
 536     struct MakefileRef * mfref;
 537     struct MakefileTarget * mftarget;
 538     struct List deps;
 539
 540     if (!quiet)
 541         printf ("Building %s.%s\n", prj->node.name, tname);
 542
 543     NewList (&deps);
 544
 545     chdir (prj->srctop);
 546
 547     readvars (prj);
 548
 549     if (!prj->cache)
 550         prj->cache = activatecache (prj);
 551
 552     if (!*tname)
 553         tname = prj->defaulttarget;
 554
 555     target = FindNode (&prj->cache->targets, tname);
 556
 557     if (!target)
 558     {
 559         if (!quiet)
 560             printf ("Nothing known about target %s in project %s\n", tname, prj->node.name);
 561         return;
 562     }
 563
 564     target->updated = 1;
 565
 566     ForeachNode (&target->makefiles, mfref)
 567     {
 568         mftarget = FindNode (&mfref->makefile->targets, tname);
 569
 570         ForeachNode (&mftarget->deps, node)
 571             addnodeonce (&deps, node->name);
 572     }
 573
 574     ForeachNode (&deps, node)
 575     {
 576         subtarget = FindNode (&prj->cache->targets, node->name);
 577
 578         if (!subtarget)
 579         {
 580             if (!quiet)
 581                 printf ("Nothing known about target %s in project %s\n", node->name, prj->node.name);
 582         }
 583         else if (!subtarget->updated)
 584         {
 585             maketarget (prj, node->name);
 586         }
 587     }
 588
 589     freelist (&deps);
 590
 591     ForeachNode (&target->makefiles, mfref)
 592     {
 593         if (!mfref->virtualtarget)
 594         {
 595             callmake (prj, tname, mfref->makefile);
 596         }
 597     }
 598
 599     freelist (&deps);
 600 }