summaryrefslogtreecommitdiff
path: root/jam-files/engine/compile.c
diff options
context:
space:
mode:
authorPatrick Simianer <simianer@cl.uni-heidelberg.de>2012-05-13 03:35:30 +0200
committerPatrick Simianer <simianer@cl.uni-heidelberg.de>2012-05-13 03:35:30 +0200
commit670a8f984fc6d8342180c59ae9e96b0b76f34d3d (patch)
tree9f2ce7eec1a77e56b3bb1ad0ad40f212d7a996b0 /jam-files/engine/compile.c
parenteb3ee28dc0eb1d3e5ed01ba0df843be329ae450d (diff)
parent2f64af3e06a518b93f7ca2c30a9d0aeb2c947031 (diff)
Merge remote-tracking branch 'upstream/master'
Diffstat (limited to 'jam-files/engine/compile.c')
-rw-r--r--jam-files/engine/compile.c1424
1 files changed, 1424 insertions, 0 deletions
diff --git a/jam-files/engine/compile.c b/jam-files/engine/compile.c
new file mode 100644
index 00000000..2c049aae
--- /dev/null
+++ b/jam-files/engine/compile.c
@@ -0,0 +1,1424 @@
+/*
+ * Copyright 1993, 2000 Christopher Seiwald.
+ *
+ * This file is part of Jam - see jam.c for Copyright information.
+ */
+
+/* This file is ALSO:
+ * Copyright 2001-2004 David Abrahams.
+ * Distributed under the Boost Software License, Version 1.0.
+ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt)
+ */
+
+# include "jam.h"
+
+# include "lists.h"
+# include "parse.h"
+# include "compile.h"
+# include "variable.h"
+# include "expand.h"
+# include "rules.h"
+# include "newstr.h"
+# include "make.h"
+# include "search.h"
+# include "hdrmacro.h"
+# include "hash.h"
+# include "modules.h"
+# include "strings.h"
+# include "builtins.h"
+# include "class.h"
+
+# include <assert.h>
+# include <string.h>
+# include <stdarg.h>
+
+/*
+ * compile.c - compile parsed jam statements
+ *
+ * External routines:
+ *
+ * compile_append() - append list results of two statements
+ * compile_eval() - evaluate if to determine which leg to compile
+ * compile_foreach() - compile the "for x in y" statement
+ * compile_if() - compile 'if' rule
+ * compile_while() - compile 'while' rule
+ * compile_include() - support for 'include' - call include() on file
+ * compile_list() - expand and return a list
+ * compile_local() - declare (and set) local variables
+ * compile_null() - do nothing -- a stub for parsing
+ * compile_on() - run rule under influence of on-target variables
+ * compile_rule() - compile a single user defined rule
+ * compile_rules() - compile a chain of rules
+ * compile_set() - compile the "set variable" statement
+ * compile_setcomp() - support for `rule` - save parse tree
+ * compile_setexec() - support for `actions` - save execution string
+ * compile_settings() - compile the "on =" (set variable on exec) statement
+ * compile_switch() - compile 'switch' rule
+ *
+ * Internal routines:
+ *
+ * debug_compile() - printf with indent to show rule expansion.
+ * evaluate_rule() - execute a rule invocation
+ *
+ * builtin_depends() - DEPENDS/INCLUDES rule
+ * builtin_echo() - ECHO rule
+ * builtin_exit() - EXIT rule
+ * builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule
+ *
+ * 02/03/94 (seiwald) - Changed trace output to read "setting" instead of
+ * the awkward sounding "settings".
+ * 04/12/94 (seiwald) - Combined build_depends() with build_includes().
+ * 04/12/94 (seiwald) - actionlist() now just appends a single action.
+ * 04/13/94 (seiwald) - added shorthand L0 for null list pointer
+ * 05/13/94 (seiwald) - include files are now bound as targets, and thus
+ * can make use of $(SEARCH)
+ * 06/01/94 (seiwald) - new 'actions existing' does existing sources
+ * 08/23/94 (seiwald) - Support for '+=' (append to variable)
+ * 12/20/94 (seiwald) - NOTIME renamed NOTFILE.
+ * 01/22/95 (seiwald) - Exit rule.
+ * 02/02/95 (seiwald) - Always rule; LEAVES rule.
+ * 02/14/95 (seiwald) - NoUpdate rule.
+ * 09/11/00 (seiwald) - new evaluate_rule() for headers().
+ * 09/11/00 (seiwald) - compile_xxx() now return LIST *.
+ * New compile_append() and compile_list() in
+ * support of building lists here, rather than
+ * in jamgram.yy.
+ * 01/10/00 (seiwald) - built-ins split out to builtin.c.
+ */
+
+static void debug_compile( int which, char *s, FRAME* frame );
+int glob( char *s, char *c );
+/* Internal functions from builtins.c */
+void backtrace( FRAME *frame );
+void backtrace_line( FRAME *frame );
+void print_source_line( PARSE* p );
+
+struct frame * frame_before_python_call;
+
+void frame_init( FRAME* frame )
+{
+ frame->prev = 0;
+ frame->prev_user = 0;
+ lol_init(frame->args);
+ frame->module = root_module();
+ frame->rulename = "module scope";
+ frame->procedure = 0;
+}
+
+
+void frame_free( FRAME* frame )
+{
+ lol_free( frame->args );
+}
+
+
+/*
+ * compile_append() - append list results of two statements
+ *
+ * parse->left more compile_append() by left-recursion
+ * parse->right single rule
+ */
+
+LIST * compile_append( PARSE * parse, FRAME * frame )
+{
+ /* Append right to left. */
+ return list_append(
+ parse_evaluate( parse->left, frame ),
+ parse_evaluate( parse->right, frame ) );
+}
+
+
+/*
+ * compile_eval() - evaluate if to determine which leg to compile
+ *
+ * Returns:
+ * list if expression true - compile 'then' clause
+ * L0 if expression false - compile 'else' clause
+ */
+
+static int lcmp( LIST * t, LIST * s )
+{
+ int status = 0;
+
+ while ( !status && ( t || s ) )
+ {
+ char *st = t ? t->string : "";
+ char *ss = s ? s->string : "";
+
+ status = strcmp( st, ss );
+
+ t = t ? list_next( t ) : t;
+ s = s ? list_next( s ) : s;
+ }
+
+ return status;
+}
+
+LIST * compile_eval( PARSE * parse, FRAME * frame )
+{
+ LIST * ll;
+ LIST * lr;
+ LIST * s;
+ LIST * t;
+ int status = 0;
+
+ /* Short circuit lr eval for &&, ||, and 'in'. */
+
+ ll = parse_evaluate( parse->left, frame );
+ lr = 0;
+
+ switch ( parse->num )
+ {
+ case EXPR_AND:
+ case EXPR_IN : if ( ll ) goto eval; break;
+ case EXPR_OR : if ( !ll ) goto eval; break;
+ default: eval: lr = parse_evaluate( parse->right, frame );
+ }
+
+ /* Now eval. */
+ switch ( parse->num )
+ {
+ case EXPR_NOT: if ( !ll ) status = 1; break;
+ case EXPR_AND: if ( ll && lr ) status = 1; break;
+ case EXPR_OR : if ( ll || lr ) status = 1; break;
+
+ case EXPR_IN:
+ /* "a in b": make sure each of ll is equal to something in lr. */
+ for ( t = ll; t; t = list_next( t ) )
+ {
+ for ( s = lr; s; s = list_next( s ) )
+ if ( !strcmp( t->string, s->string ) )
+ break;
+ if ( !s ) break;
+ }
+ /* No more ll? Success. */
+ if ( !t ) status = 1;
+ break;
+
+ case EXPR_EXISTS: if ( lcmp( ll, L0 ) != 0 ) status = 1; break;
+ case EXPR_EQUALS: if ( lcmp( ll, lr ) == 0 ) status = 1; break;
+ case EXPR_NOTEQ : if ( lcmp( ll, lr ) != 0 ) status = 1; break;
+ case EXPR_LESS : if ( lcmp( ll, lr ) < 0 ) status = 1; break;
+ case EXPR_LESSEQ: if ( lcmp( ll, lr ) <= 0 ) status = 1; break;
+ case EXPR_MORE : if ( lcmp( ll, lr ) > 0 ) status = 1; break;
+ case EXPR_MOREEQ: if ( lcmp( ll, lr ) >= 0 ) status = 1; break;
+ }
+
+ if ( DEBUG_IF )
+ {
+ debug_compile( 0, "if", frame );
+ list_print( ll );
+ printf( "(%d) ", status );
+ list_print( lr );
+ printf( "\n" );
+ }
+
+ /* Find something to return. */
+ /* In odd circumstances (like "" = "") */
+ /* we'll have to return a new string. */
+
+ if ( !status ) t = 0;
+ else if ( ll ) t = ll, ll = 0;
+ else if ( lr ) t = lr, lr = 0;
+ else t = list_new( L0, newstr( "1" ) );
+
+ if ( ll ) list_free( ll );
+ if ( lr ) list_free( lr );
+ return t;
+}
+
+
+/*
+ * compile_foreach() - compile the "for x in y" statement
+ *
+ * Compile_foreach() resets the given variable name to each specified
+ * value, executing the commands enclosed in braces for each iteration.
+ *
+ * parse->string index variable
+ * parse->left variable values
+ * parse->right rule to compile
+ */
+
+LIST * compile_foreach( PARSE * parse, FRAME * frame )
+{
+ LIST * nv = parse_evaluate( parse->left, frame );
+ LIST * l;
+ SETTINGS * s = 0;
+
+ if ( parse->num )
+ {
+ s = addsettings( s, VAR_SET, parse->string, L0 );
+ pushsettings( s );
+ }
+
+ /* Call var_set to reset $(parse->string) for each val. */
+
+ for ( l = nv; l; l = list_next( l ) )
+ {
+ LIST * val = list_new( L0, copystr( l->string ) );
+ var_set( parse->string, val, VAR_SET );
+ list_free( parse_evaluate( parse->right, frame ) );
+ }
+
+ if ( parse->num )
+ {
+ popsettings( s );
+ freesettings( s );
+ }
+
+ list_free( nv );
+
+ return L0;
+}
+
+/*
+ * compile_if() - compile 'if' rule
+ *
+ * parse->left condition tree
+ * parse->right then tree
+ * parse->third else tree
+ */
+
+LIST * compile_if( PARSE * p, FRAME * frame )
+{
+ LIST * l = parse_evaluate( p->left, frame );
+ if ( l )
+ {
+ list_free( l );
+ return parse_evaluate( p->right, frame );
+ }
+ return parse_evaluate( p->third, frame );
+}
+
+
+LIST * compile_while( PARSE * p, FRAME * frame )
+{
+ LIST * r = 0;
+ LIST * l;
+ while ( ( l = parse_evaluate( p->left, frame ) ) )
+ {
+ list_free( l );
+ if ( r ) list_free( r );
+ r = parse_evaluate( p->right, frame );
+ }
+ return r;
+}
+
+
+/*
+ * compile_include() - support for 'include' - call include() on file
+ *
+ * parse->left list of files to include (can only do 1)
+ */
+
+LIST * compile_include( PARSE * parse, FRAME * frame )
+{
+ LIST * nt = parse_evaluate( parse->left, frame );
+
+ if ( DEBUG_COMPILE )
+ {
+ debug_compile( 0, "include", frame);
+ list_print( nt );
+ printf( "\n" );
+ }
+
+ if ( nt )
+ {
+ TARGET * t = bindtarget( nt->string );
+
+ /* DWA 2001/10/22 - Perforce Jam cleared the arguments here, which
+ * prevents an included file from being treated as part of the body of a
+ * rule. I did not see any reason to do that, so I lifted the
+ * restriction.
+ */
+
+ /* Bind the include file under the influence of */
+ /* "on-target" variables. Though they are targets, */
+ /* include files are not built with make(). */
+
+ pushsettings( t->settings );
+ /* We don't expect that file to be included is generated by some
+ action. Therefore, pass 0 as third argument.
+ If the name resolves to directory, let it error out. */
+ t->boundname = search( t->name, &t->time, 0, 0 );
+ popsettings( t->settings );
+
+ parse_file( t->boundname, frame );
+ }
+
+ list_free( nt );
+
+ return L0;
+}
+
+static LIST* evaluate_in_module ( char* module_name, PARSE * p, FRAME* frame)
+{
+ LIST* result;
+
+ module_t* outer_module = frame->module;
+ frame->module = module_name ? bindmodule( module_name ) : root_module();
+
+ if ( outer_module != frame->module )
+ {
+ exit_module( outer_module );
+ enter_module( frame->module );
+ }
+
+ result = parse_evaluate( p, frame );
+
+ if ( outer_module != frame->module )
+ {
+ exit_module( frame->module );
+ enter_module( outer_module );
+ frame->module = outer_module;
+ }
+
+ return result;
+}
+
+
+LIST * compile_module( PARSE * p, FRAME * frame )
+{
+ /* Here we are entering a module declaration block. */
+ LIST * module_name = parse_evaluate( p->left, frame );
+ LIST * result = evaluate_in_module( module_name ? module_name->string : 0,
+ p->right, frame );
+ list_free( module_name );
+ return result;
+}
+
+
+LIST * compile_class( PARSE * p, FRAME * frame )
+{
+ /** Todo: check for empty class name.
+ Check for class redeclaration. */
+
+ char * class_module = 0;
+
+ LIST * name = parse_evaluate( p->left->right, frame );
+ LIST * bases = 0;
+
+ if ( p->left->left )
+ bases = parse_evaluate( p->left->left->right, frame );
+
+ class_module = make_class_module( name, bases, frame );
+ evaluate_in_module( class_module, p->right, frame );
+
+ return L0;
+}
+
+
+/*
+ * compile_list() - expand and return a list.
+ *
+ * parse->string - character string to expand.
+ */
+
+LIST * compile_list( PARSE * parse, FRAME * frame )
+{
+ /* s is a copyable string */
+ char * s = parse->string;
+ return var_expand( L0, s, s + strlen( s ), frame->args, 1 );
+}
+
+
+/*
+ * compile_local() - declare (and set) local variables.
+ *
+ * parse->left list of variables
+ * parse->right list of values
+ * parse->third rules to execute
+ */
+
+LIST * compile_local( PARSE * parse, FRAME * frame )
+{
+ LIST * l;
+ SETTINGS * s = 0;
+ LIST * nt = parse_evaluate( parse->left, frame );
+ LIST * ns = parse_evaluate( parse->right, frame );
+ LIST * result;
+
+ if ( DEBUG_COMPILE )
+ {
+ debug_compile( 0, "local", frame );
+ list_print( nt );
+ printf( " = " );
+ list_print( ns );
+ printf( "\n" );
+ }
+
+ /* Initial value is ns. */
+ for ( l = nt; l; l = list_next( l ) )
+ s = addsettings( s, VAR_SET, l->string, list_copy( (LIST *)0, ns ) );
+
+ list_free( ns );
+ list_free( nt );
+
+ /* Note that callees of the current context get this "local" variable,
+ * making it not so much local as layered.
+ */
+
+ pushsettings( s );
+ result = parse_evaluate( parse->third, frame );
+ popsettings( s );
+
+ freesettings( s );
+
+ return result;
+}
+
+
+/*
+ * compile_null() - do nothing -- a stub for parsing.
+ */
+
+LIST * compile_null( PARSE * parse, FRAME * frame )
+{
+ return L0;
+}
+
+
+/*
+ * compile_on() - run rule under influence of on-target variables
+ *
+ * parse->left list of files to include (can only do 1).
+ * parse->right rule to run.
+ *
+ * EXPERIMENTAL!
+ */
+
+LIST * compile_on( PARSE * parse, FRAME * frame )
+{
+ LIST * nt = parse_evaluate( parse->left, frame );
+ LIST * result = 0;
+
+ if ( DEBUG_COMPILE )
+ {
+ debug_compile( 0, "on", frame );
+ list_print( nt );
+ printf( "\n" );
+ }
+
+ if ( nt )
+ {
+ TARGET * t = bindtarget( nt->string );
+ pushsettings( t->settings );
+ result = parse_evaluate( parse->right, frame );
+ popsettings( t->settings );
+ }
+
+ list_free( nt );
+
+ return result;
+}
+
+
+/*
+ * compile_rule() - compile a single user defined rule.
+ *
+ * parse->string name of user defined rule.
+ * parse->left parameters (list of lists) to rule, recursing left.
+ *
+ * Wrapped around evaluate_rule() so that headers() can share it.
+ */
+
+LIST * compile_rule( PARSE * parse, FRAME * frame )
+{
+ FRAME inner[ 1 ];
+ LIST * result;
+ PARSE * p;
+
+ /* Build up the list of arg lists. */
+ frame_init( inner );
+ inner->prev = frame;
+ inner->prev_user = frame->module->user_module ? frame : frame->prev_user;
+ inner->module = frame->module; /* This gets fixed up in evaluate_rule(), below. */
+ inner->procedure = parse;
+ /* Special-case LOL of length 1 where the first list is totally empty.
+ This is created when calling functions with no parameters, due to
+ the way jam grammar is written. This is OK when one jam function
+ calls another, but really not good when Jam function calls Python. */
+ if ( parse->left->left == NULL && parse->left->right->func == compile_null)
+ ;
+ else
+ for ( p = parse->left; p; p = p->left )
+ lol_add( inner->args, parse_evaluate( p->right, frame ) );
+
+ /* And invoke the rule. */
+ result = evaluate_rule( parse->string, inner );
+ frame_free( inner );
+ return result;
+}
+
+
+static void argument_error( char * message, RULE * rule, FRAME * frame, LIST* arg )
+{
+ LOL * actual = frame->args;
+ assert( frame->procedure != 0 );
+ backtrace_line( frame->prev );
+ printf( "*** argument error\n* rule %s ( ", frame->rulename );
+ lol_print( rule->arguments->data );
+ printf( " )\n* called with: ( " );
+ lol_print( actual );
+ printf( " )\n* %s %s\n", message, arg ? arg->string : "" );
+ print_source_line( rule->procedure );
+ printf( "see definition of rule '%s' being called\n", rule->name );
+ backtrace( frame->prev );
+ exit( 1 );
+}
+
+
+/* Define delimiters for type check elements in argument lists (and return type
+ * specifications, eventually).
+ */
+# define TYPE_OPEN_DELIM '['
+# define TYPE_CLOSE_DELIM ']'
+
+/*
+ * is_type_name() - true iff the given string represents a type check
+ * specification.
+ */
+
+static int is_type_name( char * s )
+{
+ return ( s[ 0 ] == TYPE_OPEN_DELIM ) &&
+ ( s[ strlen( s ) - 1 ] == TYPE_CLOSE_DELIM );
+}
+
+
+/*
+ * arg_modifier - if the next element of formal is a single character, return
+ * that; return 0 otherwise. Used to extract "*+?" modifiers * from argument
+ * lists.
+ */
+
+static char arg_modifier( LIST * formal )
+{
+ if ( formal->next )
+ {
+ char * next = formal->next->string;
+ if ( next && ( next[ 0 ] != 0 ) && ( next[ 1 ] == 0 ) )
+ return next[ 0 ];
+ }
+ return 0;
+}
+
+
+/*
+ * type_check() - checks that each element of values satisfies the requirements
+ * of type_name.
+ *
+ * caller - the frame of the rule calling the rule whose arguments are
+ * being checked
+ *
+ * called - the rule being called
+ *
+ * arg_name - a list element containing the name of the argument being
+ * checked
+ */
+
+static void type_check
+(
+ char * type_name,
+ LIST * values,
+ FRAME * caller,
+ RULE * called,
+ LIST * arg_name
+)
+{
+ static module_t * typecheck = 0;
+
+ /* If nothing to check, bail now. */
+ if ( !values || !type_name )
+ return;
+
+ if ( !typecheck )
+ typecheck = bindmodule( ".typecheck" );
+
+ /* If the checking rule can not be found, also bail. */
+ {
+ RULE checker_, *checker = &checker_;
+
+ checker->name = type_name;
+ if ( !typecheck->rules || !hashcheck( typecheck->rules, (HASHDATA * *)&checker ) )
+ return;
+ }
+
+ exit_module( caller->module );
+
+ while ( values != 0 )
+ {
+ LIST *error;
+ FRAME frame[1];
+ frame_init( frame );
+ frame->module = typecheck;
+ frame->prev = caller;
+ frame->prev_user = caller->module->user_module ? caller : caller->prev_user;
+
+ enter_module( typecheck );
+ /* Prepare the argument list */
+ lol_add( frame->args, list_new( L0, values->string ) );
+ error = evaluate_rule( type_name, frame );
+
+ exit_module( typecheck );
+
+ if ( error )
+ argument_error( error->string, called, caller, arg_name );
+
+ frame_free( frame );
+ values = values->next;
+ }
+
+ enter_module( caller->module );
+}
+
+/*
+ * collect_arguments() - local argument checking and collection
+ */
+static SETTINGS *
+collect_arguments( RULE* rule, FRAME* frame )
+{
+ SETTINGS *locals = 0;
+
+ LOL * all_actual = frame->args;
+ LOL * all_formal = rule->arguments ? rule->arguments->data : 0;
+ if ( all_formal ) /* Nothing to set; nothing to check */
+ {
+ int max = all_formal->count > all_actual->count
+ ? all_formal->count
+ : all_actual->count;
+
+ int n;
+ for ( n = 0; n < max ; ++n )
+ {
+ LIST *actual = lol_get( all_actual, n );
+ char *type_name = 0;
+
+ LIST *formal;
+ for ( formal = lol_get( all_formal, n ); formal; formal = formal->next )
+ {
+ char* name = formal->string;
+
+ if ( is_type_name(name) )
+ {
+ if ( type_name )
+ argument_error( "missing argument name before type name:", rule, frame, formal );
+
+ if ( !formal->next )
+ argument_error( "missing argument name after type name:", rule, frame, formal );
+
+ type_name = formal->string;
+ }
+ else
+ {
+ LIST* value = 0;
+ char modifier;
+ LIST* arg_name = formal; /* hold the argument name for type checking */
+ int multiple = 0;
+
+ /* Stop now if a variable number of arguments are specified */
+ if ( name[0] == '*' && name[1] == 0 )
+ return locals;
+
+ modifier = arg_modifier( formal );
+
+ if ( !actual && modifier != '?' && modifier != '*' )
+ argument_error( "missing argument", rule, frame, formal );
+
+ switch ( modifier )
+ {
+ case '+':
+ case '*':
+ value = list_copy( 0, actual );
+ multiple = 1;
+ actual = 0;
+ /* skip an extra element for the modifier */
+ formal = formal->next;
+ break;
+ case '?':
+ /* skip an extra element for the modifier */
+ formal = formal->next;
+ /* fall through */
+ default:
+ if ( actual ) /* in case actual is missing */
+ {
+ value = list_new( 0, actual->string );
+ actual = actual->next;
+ }
+ }
+
+ locals = addsettings(locals, VAR_SET, name, value);
+ locals->multiple = multiple;
+ type_check( type_name, value, frame, rule, arg_name );
+ type_name = 0;
+ }
+ }
+
+ if ( actual )
+ {
+ argument_error( "extra argument", rule, frame, actual );
+ }
+ }
+ }
+ return locals;
+}
+
+RULE *
+enter_rule( char *rulename, module_t *target_module );
+
+#ifdef HAVE_PYTHON
+
+static int python_instance_number = 0;
+
+
+/* Given a Python object, return a string to use in Jam
+ code instead of said object.
+ If the object is string, use the string value
+ If the object implemenets __jam_repr__ method, use that.
+ Otherwise return 0.
+
+ The result value is newstr-ed. */
+char *python_to_string(PyObject* value)
+{
+ if (PyString_Check(value))
+ {
+ return newstr(PyString_AsString(value));
+ }
+ else
+ {
+ /* See if this is an instance that defines special __jam_repr__
+ method. */
+ if (PyInstance_Check(value)
+ && PyObject_HasAttrString(value, "__jam_repr__"))
+ {
+ PyObject* repr = PyObject_GetAttrString(value, "__jam_repr__");
+ if (repr)
+ {
+ PyObject* arguments2 = PyTuple_New(0);
+ PyObject* value2 = PyObject_Call(repr, arguments2, 0);
+ Py_DECREF(repr);
+ Py_DECREF(arguments2);
+ if (PyString_Check(value2))
+ {
+ return newstr(PyString_AsString(value2));
+ }
+ Py_DECREF(value2);
+ }
+ }
+ return 0;
+ }
+}
+
+static LIST*
+call_python_function(RULE* r, FRAME* frame)
+{
+ LIST * result = 0;
+ PyObject * arguments = 0;
+ PyObject * kw = NULL;
+ int i ;
+ PyObject * py_result;
+
+ if (r->arguments)
+ {
+ SETTINGS * args;
+
+ arguments = PyTuple_New(0);
+ kw = PyDict_New();
+
+ for (args = collect_arguments(r, frame); args; args = args->next)
+ {
+ PyObject *key = PyString_FromString(args->symbol);
+ PyObject *value = 0;
+ if (args->multiple)
+ value = list_to_python(args->value);
+ else {
+ if (args->value)
+ value = PyString_FromString(args->value->string);
+ }
+
+ if (value)
+ PyDict_SetItem(kw, key, value);
+ Py_DECREF(key);
+ Py_XDECREF(value);
+ }
+ }
+ else
+ {
+ arguments = PyTuple_New( frame->args->count );
+ for ( i = 0; i < frame->args->count; ++i )
+ {
+ PyObject * arg = PyList_New(0);
+ LIST* l = lol_get( frame->args, i);
+
+ for ( ; l; l = l->next )
+ {
+ PyObject * v = PyString_FromString(l->string);
+ PyList_Append( arg, v );
+ Py_DECREF(v);
+ }
+ /* Steals reference to 'arg' */
+ PyTuple_SetItem( arguments, i, arg );
+ }
+ }
+
+ frame_before_python_call = frame;
+ py_result = PyObject_Call( r->python_function, arguments, kw );
+ Py_DECREF(arguments);
+ Py_XDECREF(kw);
+ if ( py_result != NULL )
+ {
+ if ( PyList_Check( py_result ) )
+ {
+ int size = PyList_Size( py_result );
+ int i;
+ for ( i = 0; i < size; ++i )
+ {
+ PyObject * item = PyList_GetItem( py_result, i );
+ char *s = python_to_string (item);
+ if (!s) {
+ fprintf( stderr, "Non-string object returned by Python call.\n" );
+ } else {
+ result = list_new (result, s);
+ }
+ }
+ }
+ else if ( py_result == Py_None )
+ {
+ result = L0;
+ }
+ else
+ {
+ char *s = python_to_string(py_result);
+ if (s)
+ result = list_new(0, s);
+ else
+ /* We have tried all we could. Return empty list. There are
+ cases, e.g. feature.feature function that should return
+ value for the benefit of Python code and which also can be
+ called by Jam code, where no sensible value can be
+ returned. We cannot even emit a warning, since there will
+ be a pile of them. */
+ result = L0;
+ }
+
+ Py_DECREF( py_result );
+ }
+ else
+ {
+ PyErr_Print();
+ fprintf(stderr,"Call failed\n");
+ }
+
+ return result;
+}
+
+
+module_t * python_module()
+{
+ static module_t * python = 0;
+ if ( !python )
+ python = bindmodule("__python__");
+ return python;
+}
+
+#endif
+
+
+/*
+ * evaluate_rule() - execute a rule invocation.
+ */
+
+LIST *
+evaluate_rule(
+ char * rulename,
+ FRAME * frame )
+{
+ LIST * result = L0;
+ RULE * rule;
+ profile_frame prof[1];
+ module_t * prev_module = frame->module;
+
+ LIST * l;
+ {
+ LOL arg_context_, * arg_context = &arg_context_;
+ if ( !frame->prev )
+ lol_init(arg_context);
+ else
+ arg_context = frame->prev->args;
+ l = var_expand( L0, rulename, rulename+strlen(rulename), arg_context, 0 );
+ }
+
+ if ( !l )
+ {
+ backtrace_line( frame->prev );
+ printf( "warning: rulename %s expands to empty string\n", rulename );
+ backtrace( frame->prev );
+ return result;
+ }
+
+ rulename = l->string;
+ rule = bindrule( l->string, frame->module );
+
+#ifdef HAVE_PYTHON
+ if ( rule->python_function )
+ {
+ /* The below messing with modules is due to the way modules are
+ * implemented in Jam. Suppose we are in module M1 now. The global
+ * variable map actually holds 'M1' variables, and M1->variables hold
+ * global variables.
+ *
+ * If we call Python right away, Python calls back Jam and then Jam
+ * does 'module M1 { }' then Jam will try to swap the current global
+ * variables with M1->variables. The result will be that global
+ * variables map will hold global variables, and any variable settings
+ * we do will go to the global module, not M1.
+ *
+ * By restoring basic state, where the global variable map holds global
+ * variable, we make sure any future 'module M1' entry will work OK.
+ */
+
+ LIST * result;
+ module_t * m = python_module();
+
+ frame->module = m;
+
+ exit_module( prev_module );
+ enter_module( m );
+
+ result = call_python_function( rule, frame );
+
+ exit_module( m );
+ enter_module ( prev_module );
+
+ return result;
+ }
+#endif
+
+ /* Drop the rule name. */
+ l = list_pop_front( l );
+
+ /* Tack the rest of the expansion onto the front of the first argument. */
+ frame->args->list[0] = list_append( l, lol_get( frame->args, 0 ) );
+
+ if ( DEBUG_COMPILE )
+ {
+ /* Try hard to indicate in which module the rule is going to execute. */
+ if ( rule->module != frame->module
+ && rule->procedure != 0 && strcmp( rulename, rule->procedure->rulename ) )
+ {
+ char buf[256] = "";
+ strncat( buf, rule->module->name, sizeof( buf ) - 1 );
+ strncat( buf, rule->name, sizeof( buf ) - 1 );
+ debug_compile( 1, buf, frame );
+ }
+ else
+ {
+ debug_compile( 1, rulename, frame );
+ }
+
+ lol_print( frame->args );
+ printf( "\n" );
+ }
+
+ if ( rule->procedure && rule->module != prev_module )
+ {
+ /* Propagate current module to nested rule invocations. */
+ frame->module = rule->module;
+
+ /* Swap variables. */
+ exit_module( prev_module );
+ enter_module( rule->module );
+ }
+
+ /* Record current rule name in frame. */
+ if ( rule->procedure )
+ {
+ frame->rulename = rulename;
+ /* And enter record profile info. */
+ if ( DEBUG_PROFILE )
+ profile_enter( rule->procedure->rulename, prof );
+ }
+
+ /* Check traditional targets $(<) and sources $(>). */
+ if ( !rule->actions && !rule->procedure )
+ {
+ backtrace_line( frame->prev );
+ printf( "rule %s unknown in module %s\n", rule->name, frame->module->name );
+ backtrace( frame->prev );
+ exit( 1 );
+ }
+
+ /* If this rule will be executed for updating the targets then construct the
+ * action for make().
+ */
+ if ( rule->actions )
+ {
+ TARGETS * t;
+ ACTION * action;
+
+ /* The action is associated with this instance of this rule. */
+ action = (ACTION *)BJAM_MALLOC( sizeof( ACTION ) );
+ memset( (char *)action, '\0', sizeof( *action ) );
+
+ action->rule = rule;
+ action->targets = targetlist( (TARGETS *)0, lol_get( frame->args, 0 ) );
+ action->sources = targetlist( (TARGETS *)0, lol_get( frame->args, 1 ) );
+
+ /* If we have a group of targets all being built using the same action
+ * then we must not allow any of them to be used as sources unless they
+ * had all already been built in the first place or their joined action
+ * has had a chance to finish its work and build all of them anew.
+ *
+ * Without this it might be possible, in case of a multi-process build,
+ * for their action, triggered by buiding one of the targets, to still
+ * be running when another target in the group reports as done in order
+ * to avoid triggering the same action again and gets used prematurely.
+ *
+ * As a quick-fix to achieve this effect we make all the targets list
+ * each other as 'included targets'. More precisely, we mark the first
+ * listed target as including all the other targets in the list and vice
+ * versa. This makes anyone depending on any of those targets implicitly
+ * depend on all of them, thus making sure none of those targets can be
+ * used as sources until all of them have been built. Note that direct
+ * dependencies could not have been used due to the 'circular
+ * dependency' issue.
+ *
+ * TODO: Although the current implementation solves the problem of one
+ * of the targets getting used before its action completes its work it
+ * also forces the action to run whenever any of the targets in the
+ * group is not up to date even though some of them might not actually
+ * be used by the targets being built. We should see how we can
+ * correctly recognize such cases and use that to avoid running the
+ * action if possible and not rebuild targets not actually depending on
+ * targets that are not up to date.
+ *
+ * TODO: Using the 'include' feature might have side-effects due to
+ * interaction with the actual 'inclusion scanning' system. This should
+ * be checked.
+ */
+ if ( action->targets )
+ {
+ TARGET * t0 = action->targets->target;
+ for ( t = action->targets->next; t; t = t->next )
+ {
+ target_include( t->target, t0 );
+ target_include( t0, t->target );
+ }
+ }
+
+ /* Append this action to the actions of each target. */
+ for ( t = action->targets; t; t = t->next )
+ t->target->actions = actionlist( t->target->actions, action );
+ }
+
+ /* Now recursively compile any parse tree associated with this rule.
+ * parse_refer()/parse_free() call pair added to ensure rule not freed
+ * during use.
+ */
+ if ( rule->procedure )
+ {
+ SETTINGS * local_args = collect_arguments( rule, frame );
+ PARSE * parse = rule->procedure;
+ parse_refer( parse );
+
+ pushsettings( local_args );
+ result = parse_evaluate( parse, frame );
+ popsettings( local_args );
+ freesettings( local_args );
+
+ parse_free( parse );
+ }
+
+ if ( frame->module != prev_module )
+ {
+ exit_module( frame->module );
+ enter_module( prev_module );
+ }
+
+ if ( DEBUG_PROFILE && rule->procedure )
+ profile_exit( prof );
+
+ if ( DEBUG_COMPILE )
+ debug_compile( -1, 0, frame);
+
+ return result;
+}
+
+
+/*
+ * Call the given rule with the specified parameters. The parameters should be
+ * of type LIST* and end with a NULL pointer. This differs from 'evaluate_rule'
+ * in that frame for the called rule is prepared inside 'call_rule'.
+ *
+ * This function is useful when a builtin rule (in C) wants to call another rule
+ * which might be implemented in Jam.
+ */
+
+LIST * call_rule( char * rulename, FRAME * caller_frame, ... )
+{
+ va_list va;
+ LIST * result;
+
+ FRAME inner[1];
+ frame_init( inner );
+ inner->prev = caller_frame;
+ inner->prev_user = caller_frame->module->user_module ?
+ caller_frame : caller_frame->prev_user;
+ inner->module = caller_frame->module;
+ inner->procedure = 0;
+
+ va_start( va, caller_frame );
+ for ( ; ; )
+ {
+ LIST * l = va_arg( va, LIST* );
+ if ( !l )
+ break;
+ lol_add( inner->args, l );
+ }
+ va_end( va );
+
+ result = evaluate_rule( rulename, inner );
+
+ frame_free( inner );
+
+ return result;
+}
+
+
+/*
+ * compile_rules() - compile a chain of rules
+ *
+ * parse->left single rule
+ * parse->right more compile_rules() by right-recursion
+ */
+
+LIST * compile_rules( PARSE * parse, FRAME * frame )
+{
+ /* Ignore result from first statement; return the 2nd. */
+ /* Optimize recursion on the right by looping. */
+ do list_free( parse_evaluate( parse->left, frame ) );
+ while ( ( parse = parse->right )->func == compile_rules );
+ return parse_evaluate( parse, frame );
+}
+
+
+/*
+ * assign_var_mode() - convert ASSIGN_XXX compilation flag into corresponding
+ * VAR_XXX variable set flag.
+ */
+
+static int assign_var_mode( int parsenum, char const * * tracetext )
+{
+ char const * trace;
+ int setflag;
+ switch ( parsenum )
+ {
+ case ASSIGN_SET : setflag = VAR_SET ; trace = "=" ; break;
+ case ASSIGN_APPEND : setflag = VAR_APPEND ; trace = "+="; break;
+ case ASSIGN_DEFAULT: setflag = VAR_DEFAULT; trace = "?="; break;
+ default: setflag = VAR_SET ; trace = "" ; break;
+ }
+ if ( tracetext )
+ *tracetext = trace ;
+ return setflag;
+}
+
+/*
+ * compile_set() - compile the "set variable" statement
+ *
+ * parse->left variable names
+ * parse->right variable values
+ * parse->num ASSIGN_SET/APPEND/DEFAULT
+ */
+
+LIST * compile_set( PARSE * parse, FRAME * frame )
+{
+ LIST * nt = parse_evaluate( parse->left, frame );
+ LIST * ns = parse_evaluate( parse->right, frame );
+ LIST * l;
+ char const * trace;
+ int setflag = assign_var_mode( parse->num, &trace );
+
+ if ( DEBUG_COMPILE )
+ {
+ debug_compile( 0, "set", frame );
+ list_print( nt );
+ printf( " %s ", trace );
+ list_print( ns );
+ printf( "\n" );
+ }
+
+ /* Call var_set to set variable. var_set keeps ns, so need to copy it. */
+ for ( l = nt; l; l = list_next( l ) )
+ var_set( l->string, list_copy( L0, ns ), setflag );
+ list_free( nt );
+ return ns;
+}
+
+
+/*
+ * compile_setcomp() - support for `rule` - save parse tree.
+ *
+ * parse->string rule name
+ * parse->left rules for rule
+ * parse->right optional list-of-lists describing arguments
+ */
+
+LIST * compile_setcomp( PARSE * parse, FRAME * frame )
+{
+ argument_list * arg_list = 0;
+
+ /* Create new LOL describing argument requirements if supplied. */
+ if ( parse->right )
+ {
+ PARSE * p;
+ arg_list = args_new();
+ for ( p = parse->right; p; p = p->left )
+ lol_add( arg_list->data, parse_evaluate( p->right, frame ) );
+ }
+
+ new_rule_body( frame->module, parse->string, arg_list, parse->left, !parse->num );
+ return L0;
+}
+
+
+/*
+ * compile_setexec() - support for `actions` - save execution string.
+ *
+ * parse->string rule name
+ * parse->string1 OS command string
+ * parse->num flags
+ * parse->left `bind` variables
+ *
+ * Note that the parse flags (as defined in compile.h) are transferred directly
+ * to the rule flags (as defined in rules.h).
+ */
+
+LIST * compile_setexec( PARSE * parse, FRAME * frame )
+{
+ LIST * bindlist = parse_evaluate( parse->left, frame );
+ new_rule_actions( frame->module, parse->string, parse->string1, bindlist, parse->num );
+ return L0;
+}
+
+
+/*
+ * compile_settings() - compile the "on =" (set variable on exec) statement.
+ *
+ * parse->left variable names
+ * parse->right target name
+ * parse->third variable value
+ * parse->num ASSIGN_SET/APPEND
+ */
+
+LIST * compile_settings( PARSE * parse, FRAME * frame )
+{
+ LIST * nt = parse_evaluate( parse->left, frame );
+ LIST * ns = parse_evaluate( parse->third, frame );
+ LIST * targets = parse_evaluate( parse->right, frame );
+ LIST * ts;
+ char const * trace;
+ int setflag = assign_var_mode( parse->num, &trace );
+
+ if ( DEBUG_COMPILE )
+ {
+ debug_compile( 0, "set", frame );
+ list_print( nt );
+ printf( " on " );
+ list_print( targets );
+ printf( " %s ", trace );
+ list_print( ns );
+ printf( "\n" );
+ }
+
+ /* Call addsettings() to save variable setting. addsettings() keeps ns, so
+ * need to copy it. Pass append flag to addsettings().
+ */
+ for ( ts = targets; ts; ts = list_next( ts ) )
+ {
+ TARGET * t = bindtarget( ts->string );
+ LIST * l;
+
+ for ( l = nt; l; l = list_next( l ) )
+ t->settings = addsettings( t->settings, setflag, l->string,
+ list_copy( (LIST *)0, ns ) );
+ }
+
+ list_free( nt );
+ list_free( targets );
+ return ns;
+}
+
+
+/*
+ * compile_switch() - compile 'switch' rule.
+ *
+ * parse->left switch value (only 1st used)
+ * parse->right cases
+ *
+ * cases->left 1st case
+ * cases->right next cases
+ *
+ * case->string argument to match
+ * case->left parse tree to execute
+ */
+
+LIST * compile_switch( PARSE * parse, FRAME * frame )
+{
+ LIST * nt = parse_evaluate( parse->left, frame );
+ LIST * result = 0;
+
+ if ( DEBUG_COMPILE )
+ {
+ debug_compile( 0, "switch", frame );
+ list_print( nt );
+ printf( "\n" );
+ }
+
+ /* Step through cases. */
+ for ( parse = parse->right; parse; parse = parse->right )
+ {
+ if ( !glob( parse->left->string, nt ? nt->string : "" ) )
+ {
+ /* Get & exec parse tree for this case. */
+ parse = parse->left->left;
+ result = parse_evaluate( parse, frame );
+ break;
+ }
+ }
+
+ list_free( nt );
+ return result;
+}
+
+
+/*
+ * debug_compile() - printf with indent to show rule expansion.
+ */
+
+static void debug_compile( int which, char * s, FRAME * frame )
+{
+ static int level = 0;
+ static char indent[36] = ">>>>|>>>>|>>>>|>>>>|>>>>|>>>>|>>>>|";
+
+ if ( which >= 0 )
+ {
+ int i;
+
+ print_source_line( frame->procedure );
+
+ i = ( level + 1 ) * 2;
+ while ( i > 35 )
+ {
+ fputs( indent, stdout );
+ i -= 35;
+ }
+
+ printf( "%*.*s ", i, i, indent );
+ }
+
+ if ( s )
+ printf( "%s ", s );
+
+ level += which;
+}