latest from svn
[boost:build.git] / v2 / engine / src / jam.c
1 /*
2  * /+\
3  * +\   Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.
4  * \+/
5  *
6  * This file is part of jam.
7  *
8  * License is hereby granted to use this software and distribute it
9  * freely, as long as this copyright notice is retained and modifications
10  * are clearly marked.
11  *
12  * ALL WARRANTIES ARE HEREBY DISCLAIMED.
13  */
14
15 /*  This file is ALSO:
16  *  Copyright 2001-2004 David Abrahams.
17  *  Distributed under the Boost Software License, Version 1.0.
18  *  (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
19  */
20
21 /*
22  * jam.c - make redux
23  *
24  * See Jam.html for usage information.
25  *
26  * These comments document the code.
27  *
28  * The top half of the code is structured such:
29  *
30  *                       jam
31  *                      / | \
32  *                 +---+  |  \
33  *                /       |   \
34  *         jamgram     option  \
35  *        /  |   \              \
36  *       /   |    \              \
37  *      /    |     \             |
38  *  scan     |     compile      make
39  *   |       |    /  | \       / |  \
40  *   |       |   /   |  \     /  |   \
41  *   |       |  /    |   \   /   |    \
42  * jambase parse     |   rules  search make1
43  *                   |           |      |   \
44  *                   |           |      |    \
45  *                   |           |      |     \
46  *               builtins    timestamp command execute
47  *                               |
48  *                               |
49  *                               |
50  *                             filesys
51  *
52  *
53  * The support routines are called by all of the above, but themselves
54  * are layered thus:
55  *
56  *                     variable|expand
57  *                      /  |   |   |
58  *                     /   |   |   |
59  *                    /    |   |   |
60  *                 lists   |   |   pathsys
61  *                    \    |   |
62  *                     \   |   |
63  *                      \  |   |
64  *                     newstr  |
65  *                        \    |
66  *                         \   |
67  *                          \  |
68  *                          hash
69  *
70  * Roughly, the modules are:
71  *
72  *  builtins.c - jam's built-in rules
73  *  command.c - maintain lists of commands
74  *  compile.c - compile parsed jam statements
75  *  execunix.c - execute a shell script on UNIX
76  *  execvms.c - execute a shell script, ala VMS
77  *  expand.c - expand a buffer, given variable values
78  *  file*.c - scan directories and archives on *
79  *  hash.c - simple in-memory hashing routines
80  *  hdrmacro.c - handle header file parsing for filename macro definitions
81  *  headers.c - handle #includes in source files
82  *  jambase.c - compilable copy of Jambase
83  *  jamgram.y - jam grammar
84  *  lists.c - maintain lists of strings
85  *  make.c - bring a target up to date, once rules are in place
86  *  make1.c - execute command to bring targets up to date
87  *  newstr.c - string manipulation routines
88  *  option.c - command line option processing
89  *  parse.c - make and destroy parse trees as driven by the parser
90  *  path*.c - manipulate file names on *
91  *  hash.c - simple in-memory hashing routines
92  *  regexp.c - Henry Spencer's regexp
93  *  rules.c - access to RULEs, TARGETs, and ACTIONs
94  *  scan.c - the jam yacc scanner
95  *  search.c - find a target along $(SEARCH) or $(LOCATE)
96  *  timestamp.c - get the timestamp of a file or archive member
97  *  variable.c - handle jam multi-element variables
98  *
99  * 05/04/94 (seiwald) - async multiprocess (-j) support
100  * 02/08/95 (seiwald) - -n implies -d2.
101  * 02/22/95 (seiwald) - -v for version info.
102  * 09/11/00 (seiwald) - PATCHLEVEL folded into VERSION.
103  * 01/10/01 (seiwald) - pathsys.h split from filesys.h
104  */
105
106
107 #include "jam.h"
108 #include "option.h"
109 #include "patchlevel.h"
110
111 /* These get various function declarations. */
112 #include "lists.h"
113 #include "parse.h"
114 #include "variable.h"
115 #include "compile.h"
116 #include "builtins.h"
117 #include "rules.h"
118 #include "newstr.h"
119 #include "scan.h"
120 #include "timestamp.h"
121 #include "make.h"
122 #include "strings.h"
123 #include "expand.h"
124 #include "filesys.h"
125 #include "output.h"
126
127 /* Macintosh is "special" */
128 #ifdef OS_MAC
129     #include <QuickDraw.h>
130 #endif
131
132 /* And UNIX for this. */
133 #ifdef unix
134     #include <sys/utsname.h>
135     #include <signal.h>
136 #endif
137
138 struct globs globs =
139 {
140     0,          /* noexec */
141     1,          /* jobs */
142     0,          /* quitquick */
143     0,          /* newestfirst */
144     0,          /* pipes action stdout and stderr merged to action output */
145 #ifdef OS_MAC
146     { 0, 0 },   /* debug - suppress tracing output */
147 #else
148     { 0, 1 },   /* debug ... */
149 #endif
150     0,          /* output commands, not run them */
151     0           /* action timeout */
152 };
153
154 /* Symbols to be defined as true for use in Jambase. */
155 static char * othersyms[] = { OSMAJOR, OSMINOR, OSPLAT, JAMVERSYM, 0 };
156
157
158 /* Known for sure:
159  *  mac needs arg_enviro
160  *  OS2 needs extern environ
161  */
162
163 #ifdef OS_MAC
164     #define use_environ arg_environ
165     #ifdef MPW
166         QDGlobals qd;
167     #endif
168 #endif
169
170 /* on Win32-LCC */
171 #if defined( OS_NT ) && defined( __LCC__ )
172     #define use_environ _environ
173 #endif
174
175 # if defined( __MWERKS__)
176     #define use_environ _environ
177     extern char * * _environ;
178 #endif
179
180 #ifndef use_environ
181     #define use_environ environ
182     #if !defined( __WATCOM__ ) && !defined( OS_OS2 ) && !defined( OS_NT )
183         extern char **environ;
184     #endif
185 #endif
186
187 #if YYDEBUG != 0
188     extern int yydebug;
189 #endif
190
191 #ifndef NDEBUG
192 static void run_unit_tests()
193 {
194 #if defined( USE_EXECNT )
195     extern void execnt_unit_test();
196     execnt_unit_test();
197 #endif
198     string_unit_test();
199     var_expand_unit_test();
200 }
201 #endif
202
203 int anyhow = 0;
204
205 #ifdef HAVE_PYTHON
206     extern PyObject * bjam_call         ( PyObject * self, PyObject * args );
207     extern PyObject * bjam_import_rule  ( PyObject * self, PyObject * args );
208     extern PyObject * bjam_define_action( PyObject * self, PyObject * args );
209     extern PyObject * bjam_variable     ( PyObject * self, PyObject * args );
210     extern PyObject * bjam_backtrace    ( PyObject * self, PyObject * args );
211     extern PyObject * bjam_caller       ( PyObject * self, PyObject * args );
212 #endif
213
214 char *saved_argv0;
215
216 int main( int argc, char * * argv, char * * arg_environ )
217 {
218     int                     n;
219     char                  * s;
220     struct option           optv[N_OPTS];
221     char            const * all = "all";
222     int                     status;
223     int                     arg_c = argc;
224     char          *       * arg_v = argv;
225     char            const * progname = argv[0];
226
227     saved_argv0 = argv[0];
228
229     BJAM_MEM_INIT();
230
231 # ifdef OS_MAC
232     InitGraf(&qd.thePort);
233 # endif
234
235     --argc;
236     ++argv;
237
238     if ( getoptions( argc, argv, "-:l:d:j:p:f:gs:t:ano:qv", optv ) < 0 )
239     {
240         printf( "\nusage: %s [ options ] targets...\n\n", progname );
241
242         printf( "-a      Build all targets, even if they are current.\n" );
243         printf( "-dx     Set the debug level to x (0-9).\n" );
244         printf( "-fx     Read x instead of Jambase.\n" );
245         /* printf( "-g      Build from newest sources first.\n" ); */
246         printf( "-jx     Run up to x shell commands concurrently.\n" );
247         printf( "-lx     Limit actions to x number of seconds after which they are stopped.\n" );
248         printf( "-n      Don't actually execute the updating actions.\n" );
249         printf( "-ox     Write the updating actions to file x.\n" );
250         printf( "-px     x=0, pipes action stdout and stderr merged into action output.\n" );
251         printf( "-q      Quit quickly as soon as a target fails.\n" );
252         printf( "-sx=y   Set variable x=y, overriding environment.\n" );
253         printf( "-tx     Rebuild x, even if it is up-to-date.\n" );
254         printf( "-v      Print the version of jam and exit.\n" );
255         printf( "--x     Option is ignored.\n\n" );
256
257         exit( EXITBAD );
258     }
259
260     /* Version info. */
261     if ( ( s = getoptval( optv, 'v', 0 ) ) )
262     {
263         printf( "Boost.Jam  " );
264         printf( "Version %s. %s.\n", VERSION, OSMINOR );
265         printf( "   Copyright 1993-2002 Christopher Seiwald and Perforce Software, Inc.  \n" );
266         printf( "   Copyright 2001 David Turner.\n" );
267         printf( "   Copyright 2001-2004 David Abrahams.\n" );
268         printf( "   Copyright 2002-2008 Rene Rivera.\n" );
269         printf( "   Copyright 2003-2008 Vladimir Prus.\n" );
270
271         return EXITOK;
272     }
273
274     /* Pick up interesting options. */
275     if ( ( s = getoptval( optv, 'n', 0 ) ) )
276         globs.noexec++, globs.debug[2] = 1;
277
278     if ( ( s = getoptval( optv, 'p', 0 ) ) )
279     {
280         /* Undocumented -p3 (acts like both -p1 -p2) means separate pipe action
281          * stdout and stderr.
282          */
283         globs.pipe_action = atoi( s );
284         if ( ( 3 < globs.pipe_action ) || ( globs.pipe_action < 0 ) )
285         {
286             printf(
287                 "Invalid pipe descriptor '%d', valid values are -p[0..3].\n",
288                 globs.pipe_action );
289             exit( EXITBAD );
290         }
291     }
292
293     if ( ( s = getoptval( optv, 'q', 0 ) ) )
294         globs.quitquick = 1;
295
296     if ( ( s = getoptval( optv, 'a', 0 ) ) )
297         anyhow++;
298
299     if ( ( s = getoptval( optv, 'j', 0 ) ) )
300         globs.jobs = atoi( s );
301
302     if ( ( s = getoptval( optv, 'g', 0 ) ) )
303         globs.newestfirst = 1;
304
305     if ( ( s = getoptval( optv, 'l', 0 ) ) )
306         globs.timeout = atoi( s );
307
308     /* Turn on/off debugging */
309     for ( n = 0; ( s = getoptval( optv, 'd', n ) ); ++n )
310     {
311         int i;
312
313         /* First -d, turn off defaults. */
314         if ( !n )
315             for ( i = 0; i < DEBUG_MAX; ++i )
316                 globs.debug[i] = 0;
317
318         i = atoi( s );
319
320         if ( ( i < 0 ) || ( i >= DEBUG_MAX ) )
321         {
322             printf( "Invalid debug level '%s'.\n", s );
323             continue;
324         }
325
326         /* n turns on levels 1-n. */
327         /* +n turns on level n. */
328         if ( *s == '+' )
329             globs.debug[i] = 1;
330         else while ( i )
331             globs.debug[i--] = 1;
332     }
333
334     {
335         PROFILE_ENTER( MAIN );
336
337 #ifdef HAVE_PYTHON
338         {
339             PROFILE_ENTER( MAIN_PYTHON );
340             Py_Initialize();
341             {
342                 static PyMethodDef BjamMethods[] = {
343                     {"call", bjam_call, METH_VARARGS,
344                      "Call the specified bjam rule."},
345                     {"import_rule", bjam_import_rule, METH_VARARGS,
346                      "Imports Python callable to bjam."},
347                     {"define_action", bjam_define_action, METH_VARARGS,
348                      "Defines a command line action."},
349                     {"variable", bjam_variable, METH_VARARGS,
350                      "Obtains a variable from bjam's global module."},
351                     {"backtrace", bjam_backtrace, METH_VARARGS,
352                      "Returns bjam backtrace from the last call into Python."},
353                     {"caller", bjam_caller, METH_VARARGS,
354                      "Returns the module from which the last call into Python is made."},
355                     {NULL, NULL, 0, NULL}
356                 };
357
358                 Py_InitModule( "bjam", BjamMethods );
359             }
360             PROFILE_EXIT( MAIN_PYTHON );
361         }
362 #endif
363
364 #ifndef NDEBUG
365         run_unit_tests();
366 #endif
367 #if YYDEBUG != 0
368         if ( DEBUG_PARSE )
369             yydebug = 1;
370 #endif
371
372         /* Set JAMDATE. */
373         var_set( "JAMDATE", list_new( L0, outf_time(time(0)) ), VAR_SET );
374
375         /* Set JAM_VERSION. */
376         var_set( "JAM_VERSION",
377                  list_new( list_new( list_new( L0,
378                    newstr( VERSION_MAJOR_SYM ) ),
379                    newstr( VERSION_MINOR_SYM ) ),
380                    newstr( VERSION_PATCH_SYM ) ),
381                    VAR_SET );
382
383         /* Set JAMUNAME. */
384 #ifdef unix
385         {
386             struct utsname u;
387
388             if ( uname( &u ) >= 0 )
389             {
390                 var_set( "JAMUNAME",
391                          list_new(
392                              list_new(
393                                  list_new(
394                                      list_new(
395                                          list_new( L0,
396                                             newstr( u.sysname ) ),
397                                          newstr( u.nodename ) ),
398                                      newstr( u.release ) ),
399                                  newstr( u.version ) ),
400                              newstr( u.machine ) ), VAR_SET );
401             }
402         }
403 #endif /* unix */
404
405         /* Load up environment variables. */
406
407         /* First into the global module, with splitting, for backward
408          * compatibility.
409          */
410         var_defines( use_environ, 1 );
411
412         /* Then into .ENVIRON, without splitting. */
413         enter_module( bindmodule(".ENVIRON") );
414         var_defines( use_environ, 0 );
415         exit_module( bindmodule(".ENVIRON") );
416
417         /*
418          * Jam defined variables OS & OSPLAT. We load them after environment, so
419          * that setting OS in environment does not change Jam's notion of the
420          * current platform.
421          */
422         var_defines( othersyms, 1 );
423
424         /* Load up variables set on command line. */
425         for ( n = 0; ( s = getoptval( optv, 's', n ) ); ++n )
426         {
427             char *symv[2];
428             symv[ 0 ] = s;
429             symv[ 1 ] = 0;
430             var_defines( symv, 1 );
431             enter_module( bindmodule(".ENVIRON") );
432             var_defines( symv, 0 );
433             exit_module( bindmodule(".ENVIRON") );
434         }
435
436         /* Set the ARGV to reflect the complete list of arguments of invocation.
437          */
438         for ( n = 0; n < arg_c; ++n )
439             var_set( "ARGV", list_new( L0, newstr( arg_v[n] ) ), VAR_APPEND );
440
441         /* Initialize built-in rules. */
442         load_builtins();
443
444         /* Add the targets in the command line to the update list. */
445         for ( n = 1; n < arg_c; ++n )
446         {
447             if ( arg_v[ n ][ 0 ] == '-' )
448             {
449                 char * f = "-:l:d:j:f:gs:t:ano:qv";
450                 for ( ; *f; ++f ) if ( *f == arg_v[ n ][ 1 ] ) break;
451                 if ( ( f[ 1 ] == ':' ) && ( arg_v[ n ][ 2 ] == '\0' ) ) ++n;
452             }
453             else
454             {
455                 mark_target_for_updating( arg_v[ n ] );
456             }
457         }
458
459         if (!targets_to_update())
460             mark_target_for_updating("all");
461
462         /* Parse ruleset. */
463         {
464             FRAME frame[ 1 ];
465             frame_init( frame );
466             for ( n = 0; ( s = getoptval( optv, 'f', n ) ); ++n )
467                 parse_file( s, frame );
468
469             if ( !n )
470                 parse_file( "+", frame );
471         }
472
473         status = yyanyerrors();
474
475         /* Manually touch -t targets. */
476         for ( n = 0; ( s = getoptval( optv, 't', n ) ); ++n )
477             touch_target( s );
478
479         /* If an output file is specified, set globs.cmdout to that. */
480         if ( ( s = getoptval( optv, 'o', 0 ) ) )
481         {
482             if ( !( globs.cmdout = fopen( s, "w" ) ) )
483             {
484                 printf( "Failed to write to '%s'\n", s );
485                 exit( EXITBAD );
486             }
487             ++globs.noexec;
488         }
489
490         /* The build system may set the PARALLELISM variable to override -j
491            options.  */
492         {
493             LIST *p = L0;
494             p = var_get ("PARALLELISM");
495             if (p)
496             {
497                 int j = atoi (p->string);
498                 if (j == -1)
499                 {
500                     printf( "Invalid value of PARALLELISM: %s\n", p->string);
501                 }
502                 else
503                 {
504                     globs.jobs = j;
505                 }
506             }
507         }
508
509         /* KEEP_GOING overrides -q option. */
510         {
511             LIST *p = L0;
512             p = var_get ("KEEP_GOING");
513             if (p)
514             {
515                 int v = atoi (p->string);
516                 if (v == 0)
517                     globs.quitquick = 1;
518                 else
519                     globs.quitquick = 0;
520             }
521         }
522
523         /* Now make target. */
524         {
525             PROFILE_ENTER( MAIN_MAKE );
526
527             LIST * targets = targets_to_update();
528             if (targets)
529             {
530                 int targets_count = list_length( targets );
531                 const char * * targets2 = (const char * *)
532                     BJAM_MALLOC( targets_count * sizeof( char * ) );
533                 int n = 0;
534                 for ( ; targets; targets = list_next( targets ) )
535                     targets2[ n++ ] = targets->string;
536                 status |= make( targets_count, targets2, anyhow );
537                 free( targets );
538             }
539             else
540             {
541                 status = last_update_now_status;
542             }
543
544             PROFILE_EXIT( MAIN_MAKE );
545         }
546
547         PROFILE_EXIT( MAIN );
548     }
549
550     if ( DEBUG_PROFILE )
551         profile_dump();
552
553     /* Widely scattered cleanup. */
554     var_done();
555     file_done();
556     rules_done();
557     stamps_done();
558     str_done();
559
560     /* Close cmdout. */
561     if ( globs.cmdout )
562         fclose( globs.cmdout );
563
564 #ifdef HAVE_PYTHON
565     Py_Finalize();
566 #endif
567
568     BJAM_MEM_CLOSE();
569
570     return status ? EXITBAD : EXITOK;
571 }
572
573 #if defined(_WIN32)
574 #include <windows.h>
575 char *executable_path(char *argv0) {
576     char buf[1024];
577     DWORD ret = GetModuleFileName(NULL, buf, sizeof(buf));
578     if (ret == 0 || ret == sizeof(buf)) return NULL;
579     return strdup (buf);
580 }
581 #elif defined(__APPLE__)  /* Not tested */
582 #include <mach-o/dyld.h>
583 char *executable_path(char *argv0) {
584     char buf[1024];
585     uint32_t size = sizeof(buf);
586     int ret = _NSGetExecutablePath(buf, &size);
587     if (ret != 0) return NULL;
588     return strdup(buf);
589 }
590 #elif defined(sun) || defined(__sun) /* Not tested */
591 #include <stdlib.h>
592
593 char *executable_path(char *argv0) {
594     return strdup(getexecname());
595 }
596 #elif defined(__FreeBSD__)
597 #include <sys/sysctl.h>
598 char *executable_path(char *argv0) {
599     int mib[4];
600     mib[0] = CTL_KERN;
601     mib[1] = KERN_PROC;
602     mib[2] = KERN_PROC_PATHNAME;
603     mib[3] = -1;
604     char buf[1024];
605     size_t size = sizeof(buf);
606     sysctl(mib, 4, buf, &size, NULL, 0);
607     if (size == 0 || size == sizeof(buf)) return NULL;
608     return strndup(buf, size);
609 }
610 #elif defined(__linux__)
611 #include <unistd.h>
612 char *executable_path(char *argv0) {
613     char buf[1024];
614     ssize_t ret = readlink("/proc/self/exe", buf, sizeof(buf));
615     if (ret == 0 || ret == sizeof(buf)) return NULL;
616     return strndup(buf, ret);
617 }
618 #else
619 char *executable_path(char *argv0) {
620     /* If argv0 is absolute path, assume it's the right absolute path. */
621     if (argv0[0] == "/")
622         return strdup(argv0);
623     return NULL;
624 }
625 #endif