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