tools/MetaMake/project.c

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