[Boost-commit] svn:boost r77491 - trunk/tools/build/v2/engine

Subject: [Boost-commit] svn:boost r77491 - trunk/tools/build/v2/engine
From: steven_at_[hidden]
Date: 2012-03-22 19:26:50

Author: steven_watanabe
Date: 2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
New Revision: 77491
URL: http://svn.boost.org/trac/boost/changeset/77491

Log:
Optimize variable lookup to bypass hash for constant variable names.
Text files modified: 
   trunk/tools/build/v2/engine/builtins.c  |     3                                         
   trunk/tools/build/v2/engine/class.c     |     5                                         
   trunk/tools/build/v2/engine/compile.c   |    36 +                                       
   trunk/tools/build/v2/engine/constants.c |     6                                         
   trunk/tools/build/v2/engine/constants.h |     2                                         
   trunk/tools/build/v2/engine/function.c  |   575 ++++++++++++++++++++++++++++++++++++++- 
   trunk/tools/build/v2/engine/function.h  |     3                                         
   trunk/tools/build/v2/engine/modules.c   |   130 +++++++++                               
   trunk/tools/build/v2/engine/modules.h   |    17 +                                       
   trunk/tools/build/v2/engine/rules.c     |    18 +                                       
   trunk/tools/build/v2/engine/rules.h     |     1                                         
   trunk/tools/build/v2/engine/variable.c  |    53 ++                                      
   12 files changed, 801 insertions(+), 48 deletions(-)

Modified: trunk/tools/build/v2/engine/builtins.c
==============================================================================
--- trunk/tools/build/v2/engine/builtins.c	(original)
+++ trunk/tools/build/v2/engine/builtins.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -1127,7 +1127,7 @@
 
         imported = import_rule( r, target_module, list_item( target_iter ) );
         if ( !list_empty( localize ) )
-            imported->module = target_module;
+            rule_localize( imported, target_module );
         /* This rule is really part of some other module. Just refer to it here,
          * but do not let it out.
          */
@@ -1459,6 +1459,7 @@
     module_t * const instance     = bindmodule( list_front( arg1 ) );
     module_t * const class_module = bindmodule( list_front( arg2 ) );
     instance->class_module = class_module;
+    module_set_fixed_variables( instance, class_module->num_fixed_variables );
     return L0;
 }
 

Modified: trunk/tools/build/v2/engine/class.c
==============================================================================
--- trunk/tools/build/v2/engine/class.c	(original)
+++ trunk/tools/build/v2/engine/class.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -80,7 +80,10 @@
     /* If we are importing a class method, localize it. */
     if ( ( r->module == d->base_module ) || ( r->module->class_module &&
         ( r->module->class_module == d->base_module ) ) )
-        ir1->module = ir2->module = d->class_module;
+    {
+        rule_localize( ir1, d->class_module );
+        rule_localize( ir2, d->class_module );
+    }
 
     string_free( qualified_name );
 }

Modified: trunk/tools/build/v2/engine/compile.c
==============================================================================
--- trunk/tools/build/v2/engine/compile.c	(original)
+++ trunk/tools/build/v2/engine/compile.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -115,7 +115,7 @@
 }
 
 
-static void argument_error( const char * message, RULE * rule, FRAME * frame, OBJECT * arg )
+void argument_error( const char * message, RULE * rule, FRAME * frame, OBJECT * arg )
 {
     LOL * actual = frame->args;
     assert( rule->procedure != 0 );
@@ -144,7 +144,7 @@
  * specification.
  */
 
-static int is_type_name( const char * s )
+int is_type_name( const char * s )
 {
     return ( s[ 0 ] == TYPE_OPEN_DELIM ) &&
         ( s[ strlen( s ) - 1 ] == TYPE_CLOSE_DELIM );
@@ -183,20 +183,20 @@
  *                 checked
  */
 
-static void type_check
+void type_check_range
 (
     OBJECT  * type_name,
-    LIST    * values,
+    LISTITER  iter,
+    LISTITER  end,
     FRAME   * caller,
     RULE    * called,
     OBJECT  * arg_name
 )
 {
     static module_t * typecheck = 0;
-    LISTITER iter, end;
 
     /* If nothing to check, bail now. */
-    if ( !values || !type_name )
+    if ( iter == end || !type_name )
         return;
 
     if ( !typecheck )
@@ -208,7 +208,7 @@
     if ( !typecheck->rules || !hash_find( typecheck->rules, type_name ) )
         return;
 
-    for ( iter = list_begin( values ), end = list_end( values ); iter != end; iter = list_next( iter ) )
+    for ( ; iter != end; iter = list_next( iter ) )
     {
         LIST *error;
         FRAME frame[1];
@@ -228,6 +228,19 @@
     }
 }
 
+void type_check
+(
+    OBJECT  * type_name,
+    LIST    * values,
+    FRAME   * caller,
+    RULE    * called,
+    OBJECT  * arg_name
+)
+{
+    type_check_range( type_name, list_begin( values ), list_end( values ), caller, called, arg_name );
+}
+
+
 /*
  * collect_arguments() - local argument checking and collection
  */
@@ -485,6 +498,7 @@
 
 #endif
 
+LIST * function_run_with_args( FUNCTION * function_, FRAME * frame, STACK * s, RULE * rule );
 
 /*
  * evaluate_rule() - execute a rule invocation.
@@ -637,16 +651,10 @@
      */
     if ( rule->procedure )
     {
-        SETTINGS * local_args = collect_arguments( rule, frame );
         FUNCTION * function = rule->procedure;
 
         function_refer( function );
-
-        pushsettings( frame->module, local_args );
-        result = function_run( function, frame, stack_global() );
-        popsettings( frame->module, local_args );
-        freesettings( local_args );
-
+        result = function_run_with_args( function, frame, stack_global(), rule );
         function_free( function );
     }
 

Modified: trunk/tools/build/v2/engine/constants.c
==============================================================================
--- trunk/tools/build/v2/engine/constants.c	(original)
+++ trunk/tools/build/v2/engine/constants.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -23,6 +23,8 @@
     constant_dot                = object_new( "." );
     constant_percent            = object_new( "%" );
     constant_plus               = object_new( "+" );
+    constant_star               = object_new( "*" );
+    constant_question_mark      = object_new( "?" );
     constant_ok                 = object_new( "ok" );
     constant_true               = object_new( "true" );
     constant_name               = object_new( "__name__" );
@@ -77,6 +79,8 @@
     object_free( constant_dot );
     object_free( constant_percent );
     object_free( constant_plus );
+    object_free( constant_star );
+    object_free( constant_question_mark );
     object_free( constant_ok );
     object_free( constant_true );
     object_free( constant_name );
@@ -129,6 +133,8 @@
 OBJECT * constant_dot;
 OBJECT * constant_percent;
 OBJECT * constant_plus;
+OBJECT * constant_star;
+OBJECT * constant_question_mark;
 OBJECT * constant_ok;
 OBJECT * constant_true;
 OBJECT * constant_name;

Modified: trunk/tools/build/v2/engine/constants.h
==============================================================================
--- trunk/tools/build/v2/engine/constants.h	(original)
+++ trunk/tools/build/v2/engine/constants.h	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -20,6 +20,8 @@
 extern OBJECT * constant_dot;               /* "." */
 extern OBJECT * constant_percent;           /* "%" */
 extern OBJECT * constant_plus;              /* "+" */
+extern OBJECT * constant_star;              /* "*" */
+extern OBJECT * constant_question_mark;     /* "?" */
 extern OBJECT * constant_ok;                /* "ok" */
 extern OBJECT * constant_true;              /* "true" */
 extern OBJECT * constant_name;              /* "__name__" */

Modified: trunk/tools/build/v2/engine/function.c
==============================================================================
--- trunk/tools/build/v2/engine/function.c	(original)
+++ trunk/tools/build/v2/engine/function.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -36,6 +36,7 @@
 #define INSTR_PUSH_CONSTANT                 1
 #define INSTR_PUSH_ARG                      2
 #define INSTR_PUSH_VAR                      3
+#define INSTR_PUSH_VAR_FIXED                57
 #define INSTR_PUSH_GROUP                    4
 #define INSTR_PUSH_RESULT                   5
 #define INSTR_PUSH_APPEND                   6
@@ -69,6 +70,12 @@
 #define INSTR_APPEND                        27
 #define INSTR_DEFAULT                       28
 
+#define INSTR_PUSH_LOCAL_FIXED              58
+#define INSTR_POP_LOCAL_FIXED               59
+#define INSTR_SET_FIXED                     60
+#define INSTR_APPEND_FIXED                  61
+#define INSTR_DEFAULT_FIXED                 62
+
 #define INSTR_PUSH_LOCAL_GROUP              29
 #define INSTR_POP_LOCAL_GROUP               30
 #define INSTR_SET_GROUP                     31
@@ -97,6 +104,7 @@
 #define INSTR_PUSH_MODULE                   50
 #define INSTR_POP_MODULE                    51
 #define INSTR_CLASS                         52
+#define INSTR_BIND_MODULE_VARIABLES         63
 
 #define INSTR_APPEND_STRINGS                53
 #define INSTR_WRITE_FILE                    54
@@ -131,6 +139,8 @@
     int type;
     int reference_count;
     OBJECT * rulename;
+    struct arg_list * formal_arguments;
+    int num_formal_arguments;
 };
 
 typedef struct _builtin_function
@@ -143,6 +153,7 @@
 typedef struct _jam_function
 {
     FUNCTION base;
+    int code_size;
     instruction * code;
     int num_constants;
     OBJECT * * constants;
@@ -150,6 +161,7 @@
     SUBFUNCTION * functions;
     int num_subactions;
     SUBACTION * actions;
+    FUNCTION * generic;
     OBJECT * file;
     int line;
 } JAM_FUNCTION;
@@ -1192,9 +1204,12 @@
     int i;
     result->base.type = FUNCTION_JAM;
     result->base.reference_count = 1;
+    result->base.formal_arguments = 0;
+    result->base.num_formal_arguments = 0;
 
     result->base.rulename = 0;
 
+    result->code_size = c->code->size;
     result->code = BJAM_MALLOC( c->code->size * sizeof(instruction) );
     memcpy( result->code, c->code->data, c->code->size * sizeof(instruction) );
 
@@ -1217,6 +1232,8 @@
     memcpy( result->actions, c->actions->data, c->actions->size * sizeof(SUBACTION) );
     result->num_subactions = c->actions->size;
 
+    result->generic = 0;
+
     result->file = 0;
     result->line = -1;
 
@@ -2242,6 +2259,7 @@
     {
         compile_parse( parse->left, c, RESULT_STACK );
         compile_emit( c, INSTR_INCLUDE, 0 );
+        compile_emit( c, INSTR_BIND_MODULE_VARIABLES, 0 );
         adjust_result( c, RESULT_NONE, result_location );
     }
     else if ( parse->type == PARSE_MODULE )
@@ -2268,6 +2286,7 @@
         }
         compile_emit( c, INSTR_CLASS, 0 );
         compile_parse( parse->right, c, RESULT_NONE );
+        compile_emit( c, INSTR_BIND_MODULE_VARIABLES, 0 );
         compile_emit( c, INSTR_POP_MODULE, 0 );
 
         adjust_result( c, RESULT_NONE, result_location );
@@ -2533,6 +2552,8 @@
     result->base.type = FUNCTION_BUILTIN;
     result->base.reference_count = 1;
     result->base.rulename = 0;
+    result->base.formal_arguments = 0;
+    result->base.num_formal_arguments = 0;
     result->func = func;
     result->flags = flags;
     return (FUNCTION *)result;
@@ -2571,6 +2592,429 @@
     return (FUNCTION *)result;
 }
 
+void argument_error( const char * message, RULE * rule, FRAME * frame, OBJECT * arg );
+int is_type_name( const char * s );
+
+void type_check_range
+(
+    OBJECT  * type_name,
+    LISTITER  iter,
+    LISTITER  end,
+    FRAME   * caller,
+    RULE    * called,
+    OBJECT  * arg_name
+);
+
+void type_check
+(
+    OBJECT  * type_name,
+    LIST    * values,
+    FRAME   * caller,
+    RULE    * called,
+    OBJECT  * arg_name
+);
+
+struct argument {
+    int flags;
+#define ARG_ONE 0
+#define ARG_OPTIONAL 1
+#define ARG_PLUS 2
+#define ARG_STAR 3
+#define ARG_VARIADIC 4
+    OBJECT * type_name;
+    OBJECT * arg_name;
+    int index;
+};
+
+struct arg_list {
+    int size;
+    struct argument * args;
+};
+
+void argument_list_check( struct arg_list * formal, int formal_count, RULE * rule, FRAME * frame )
+{
+    LOL * all_actual = frame->args;
+    int i, j;
+
+    for ( i = 0; i < formal_count; ++i )
+    {
+        LIST *actual = lol_get( all_actual, i );
+        LISTITER actual_iter = list_begin( actual ), actual_end = list_end( actual );
+        for ( j = 0; j < formal[i].size; ++j )
+        {
+            struct argument * formal_arg = &formal[i].args[j];
+            LIST * value;
+
+            switch ( formal_arg->flags )
+            {
+            case ARG_ONE:
+                if ( actual_iter == actual_end )
+                    argument_error( "missing argument", rule, frame, formal_arg->arg_name );
+                type_check_range( formal_arg->type_name, actual_iter, list_next( actual_iter ), frame, rule, formal_arg->arg_name );
+                actual_iter = list_next( actual_iter );
+                break;
+            case ARG_OPTIONAL:
+                if ( actual_iter == actual_end )
+                    value = L0;
+                else
+                {
+                    type_check_range( formal_arg->type_name, actual_iter, list_next( actual_iter ), frame, rule, formal_arg->arg_name );
+                    actual_iter = list_next( actual_iter );
+                }
+                break;
+            case ARG_PLUS:
+                if ( actual_iter == actual_end )
+                    argument_error( "missing argument", rule, frame, formal_arg->arg_name );
+                /* fallthrough */
+            case ARG_STAR:
+                 type_check_range( formal_arg->type_name, actual_iter, actual_end, frame, rule, formal_arg->arg_name );
+                actual_iter = actual_end;
+            case ARG_VARIADIC:
+                return;
+            }
+        }
+
+        if ( actual_iter != actual_end )
+        {
+            argument_error( "extra argument", rule, frame, list_item( actual_iter ) );
+        }
+    }
+
+    for ( ; i < all_actual->count; ++i )
+    {
+        LIST * actual = lol_get( all_actual, i );
+        if ( !list_empty( actual ) )
+        {
+            argument_error( "extra argument", rule, frame, list_front( actual ) );
+        }
+    }
+}
+
+void argument_list_push( struct arg_list * formal, int formal_count, RULE * rule, FRAME * frame, STACK * s )
+{
+    LOL * all_actual = frame->args;
+    int i, j;
+
+    for ( i = 0; i < formal_count; ++i )
+    {
+        LIST *actual = lol_get( all_actual, i );
+        LISTITER actual_iter = list_begin( actual ), actual_end = list_end( actual );
+        for ( j = 0; j < formal[i].size; ++j )
+        {
+            struct argument * formal_arg = &formal[i].args[j];
+            LIST * value;
+
+            switch ( formal_arg->flags )
+            {
+            case ARG_ONE:
+                if ( actual_iter == actual_end )
+                    argument_error( "missing argument", rule, frame, formal_arg->arg_name );
+                value = list_new( L0, object_copy( list_item( actual_iter ) ) );
+                actual_iter = list_next( actual_iter );
+                break;
+            case ARG_OPTIONAL:
+                if ( actual_iter == actual_end )
+                    value = L0;
+                else
+                {
+                    value = list_new( L0, object_copy( list_item( actual_iter ) ) );
+                    actual_iter = list_next( actual_iter );
+                }
+                break;
+            case ARG_PLUS:
+                if ( actual_iter == actual_end )
+                    argument_error( "missing argument", rule, frame, formal_arg->arg_name );
+                /* fallthrough */
+            case ARG_STAR:
+                value = list_copy_range( actual, actual_iter, actual_end );
+                actual_iter = actual_end;
+                break;
+            case ARG_VARIADIC:
+                return;
+            }
+
+            type_check( formal_arg->type_name, value, frame, rule, formal_arg->arg_name );
+
+            if ( formal_arg->index != -1 )
+            {
+                LIST * * old = &frame->module->fixed_variables[ formal_arg->index ];
+                stack_push( s, *old );
+                *old = value;
+            }
+            else
+            {
+                stack_push( s, var_swap( frame->module, formal_arg->arg_name, value ) );
+            }
+        }
+
+        if ( actual_iter != actual_end )
+        {
+            argument_error( "extra argument", rule, frame, list_item( actual_iter ) );
+        }
+    }
+
+    for ( ; i < all_actual->count; ++i )
+    {
+        LIST * actual = lol_get( all_actual, i );
+        if ( !list_empty( actual ) )
+        {
+            argument_error( "extra argument", rule, frame, list_front( actual ) );
+        }
+    }
+}
+
+void argument_list_pop( struct arg_list * formal, int formal_count, FRAME * frame, STACK * s )
+{
+    int i, j;
+
+    for ( i = formal_count - 1; i >= 0; --i )
+    {
+        for ( j = formal[i].size - 1; j >= 0 ; --j )
+        {
+            struct argument * formal_arg = &formal[i].args[j];
+
+            if ( formal_arg->flags == ARG_VARIADIC )
+            {
+                continue;
+            }
+            else if ( formal_arg->index != -1 )
+            {
+                LIST * old = stack_pop( s );
+                LIST * * pos = &frame->module->fixed_variables[ formal_arg->index ];
+                list_free( *pos );
+                *pos = old;
+            }
+            else
+            {
+                var_set( frame->module, formal_arg->arg_name, stack_pop( s ), VAR_SET );
+            }
+        }
+    }
+}
+
+
+struct arg_list * argument_list_compile( LOL * all_formal, RULE * rule )
+{
+    struct arg_list * result = (struct arg_list *)BJAM_MALLOC( sizeof( struct arg_list ) * all_formal->count );
+
+    int n;
+    struct dynamic_array args[1];
+    dynamic_array_init( args );
+    for ( n = 0; n < all_formal->count ; ++n )
+    {
+        LIST *formal;
+        LISTITER formal_iter, formal_end;
+        for ( formal = lol_get( all_formal, n ),
+            formal_iter = list_begin( formal ), formal_end = list_end( formal );
+            formal_iter != formal_end; )
+        {
+            struct argument arg;
+            arg.type_name = 0;
+            arg.arg_name = list_item( formal_iter );
+            arg.index = -1;
+
+            if ( is_type_name( object_str( arg.arg_name ) ) )
+            {
+
+                formal_iter = list_next( formal_iter );
+
+                if ( formal_iter == formal_end )
+                    argument_error( "missing argument name after type name:", rule, 0, arg.arg_name );
+
+                arg.type_name = arg.arg_name;
+                arg.arg_name = list_item( formal_iter );
+
+                if ( is_type_name( object_str( arg.arg_name ) ) )
+                    argument_error( "missing argument name before type name:", rule, 0, arg.arg_name );
+            }
+
+            formal_iter = list_next( formal_iter );
+
+            if ( object_equal( arg.arg_name, constant_star ) )
+            {
+                arg.flags = ARG_VARIADIC;
+            }
+            else if ( formal_iter != formal_end )
+            {
+                if ( object_equal( list_item( formal_iter ), constant_question_mark ) )
+                {
+                    arg.flags = ARG_OPTIONAL;
+                    formal_iter = list_next( formal_iter );
+                }
+                else if ( object_equal( list_item( formal_iter ), constant_plus ) )
+                {
+                    arg.flags = ARG_PLUS;
+                    formal_iter = list_next( formal_iter );
+                }
+                else if ( object_equal( list_item( formal_iter ), constant_star ) )
+                {
+                    arg.flags = ARG_STAR;
+                    formal_iter = list_next( formal_iter );
+                }
+                else
+                    arg.flags = ARG_ONE;
+            }
+            else
+            {
+                arg.flags = ARG_ONE;
+            }
+
+            dynamic_array_push( args, arg );
+        }
+
+        result[ n ].args = BJAM_MALLOC( args[ 0 ].size * sizeof( struct argument ) );
+        result[ n ].size = args[ 0 ].size;
+        memcpy( result[n].args, args[ 0 ].data, args[ 0 ].size * sizeof( struct argument ) );
+        args[ 0 ].size = 0;
+    }
+    dynamic_array_free( args );
+
+    return result;
+}
+
+
+struct arg_list * argument_list_bind_variables( struct arg_list * formal, int formal_count, module_t * module, int * counter )
+{
+    if ( formal )
+    {
+        struct arg_list * result = (struct arg_list *)BJAM_MALLOC( sizeof( struct arg_list ) * formal_count );
+        int i, j;
+
+        for ( i = 0; i < formal_count; ++i )
+        {
+            struct argument * args = (struct argument *)BJAM_MALLOC( sizeof( struct argument ) * formal[ i ].size );
+            for ( j = 0; j < formal[ i ].size; ++j )
+            {
+                args[ j ] = formal[ i ].args[ j ];
+                if ( args[ j ].flags != ARG_VARIADIC )
+                {
+                    args[ j ].index = module_add_fixed_var( module, args[ j ].arg_name, counter );
+                }
+            }
+            result[ i ].args = args;
+            result[ i ].size = formal[ i ].size;
+        }
+    
+        return result;
+    }
+    else
+    {
+        return 0;
+    }
+}
+
+
+void argument_list_free( struct arg_list * args, int args_count )
+{
+    int i;
+    for ( i = 0; i < args_count; ++i )
+    {
+        BJAM_FREE( args[ i ].args );
+    }
+    BJAM_FREE( args );
+}
+
+
+void function_set_argument_list( FUNCTION * f, LOL * formal, RULE * rule )
+{
+    if ( !f->formal_arguments && formal )
+    {
+        f->formal_arguments = argument_list_compile( formal, rule );
+        f->num_formal_arguments = formal->count;
+    }
+}
+
+
+FUNCTION * function_unbind_variables( FUNCTION * f )
+{
+    if ( f->type == FUNCTION_JAM )
+    {
+        JAM_FUNCTION * func = (JAM_FUNCTION *)f;
+        if ( func->generic )
+            return func->generic;
+        else
+            return (FUNCTION *)func;
+    }
+    else
+    {
+        return f;
+    }
+}
+
+FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * counter )
+{
+    if ( f->type == FUNCTION_BUILTIN )
+    {
+        return f;
+    }
+    else
+    {
+        JAM_FUNCTION * func = (JAM_FUNCTION *)f;
+        JAM_FUNCTION * new_func = BJAM_MALLOC( sizeof( JAM_FUNCTION ) );
+        instruction * code;
+        int i;
+        memcpy( new_func, func, sizeof( JAM_FUNCTION ) );
+        new_func->base.reference_count = 1;
+        new_func->base.formal_arguments = argument_list_bind_variables( f->formal_arguments, f->num_formal_arguments, module, counter );
+        new_func->code = BJAM_MALLOC( func->code_size * sizeof( instruction ) );
+        memcpy( new_func->code, func->code, func->code_size * sizeof( instruction ) );
+        new_func->generic = (FUNCTION *)func;
+        func = new_func;
+        for ( i = 0; ; ++i )
+        {
+            OBJECT * key;
+            int op_code;
+            code = func->code + i;
+            switch ( code->op_code )
+            {
+            case INSTR_PUSH_VAR: op_code = INSTR_PUSH_VAR_FIXED; break;
+            case INSTR_PUSH_LOCAL: op_code = INSTR_PUSH_LOCAL_FIXED; break;
+            case INSTR_POP_LOCAL: op_code = INSTR_POP_LOCAL_FIXED; break;
+            case INSTR_SET: op_code = INSTR_SET_FIXED; break;
+            case INSTR_APPEND: op_code = INSTR_APPEND_FIXED; break;
+            case INSTR_DEFAULT: op_code = INSTR_DEFAULT_FIXED; break;
+            case INSTR_RETURN: return (FUNCTION *)new_func;
+            case INSTR_CALL_RULE: ++i; continue;
+            case INSTR_PUSH_MODULE:
+                {
+                    int depth = 1;
+                    ++i;
+                    while ( depth > 0 )
+                    {
+                        code = func->code + i;
+                        switch ( code->op_code )
+                        {
+                        case INSTR_PUSH_MODULE:
+                        case INSTR_CLASS:
+                            ++depth;
+                            break;
+                        case INSTR_POP_MODULE:
+                            --depth;
+                            break;
+                        case INSTR_CALL_RULE:
+                            ++i;
+                            break;
+                        }
+                        ++i;
+                    }
+                    --i;
+                }
+            default: continue;
+            }
+            key = func->constants[ code->arg ];
+            if ( !( object_equal( key, constant_TMPDIR ) ||
+                    object_equal( key, constant_TMPNAME ) ||
+                    object_equal( key, constant_TMPFILE ) ||
+                    object_equal( key, constant_STDOUT ) ||
+                    object_equal( key, constant_STDERR ) ) )
+            {
+                code->op_code = op_code;
+                code->arg = module_add_fixed_var( module, key, counter );
+            }
+        }
+    }
+}
+
 void function_refer( FUNCTION * func )
 {
     ++func->reference_count;
@@ -2581,35 +3025,47 @@
     int i;
 
     if ( --function_->reference_count != 0 ) return;
-
-    if ( function_->rulename ) object_free( function_->rulename );
+    
+    if ( function_->formal_arguments ) argument_list_free( function_->formal_arguments, function_->num_formal_arguments );
 
     if ( function_->type == FUNCTION_JAM )
     {
         JAM_FUNCTION * func = (JAM_FUNCTION *)function_;
 
         BJAM_FREE( func->code );
-        for ( i = 0; i < func->num_constants; ++i )
-        {
-            object_free( func->constants[i] );
-        }
-        BJAM_FREE( func->constants );
 
-        for ( i = 0; i < func->num_subfunctions; ++i )
+        if ( func->generic )
+            function_free( func->generic );
+        else
         {
-            object_free( func->functions[i].name );
-            function_free( func->functions[i].code );
-        }
-        BJAM_FREE( func->functions );
+            if ( function_->rulename ) object_free( function_->rulename );
 
-        for ( i = 0; i < func->num_subactions; ++i )
-        {
-            object_free( func->actions[i].name );
-            function_free( func->actions[i].command );
-        }
-        BJAM_FREE( func->actions );
+            for ( i = 0; i < func->num_constants; ++i )
+            {
+                object_free( func->constants[i] );
+            }
+            BJAM_FREE( func->constants );
 
-        object_free( func->file );
+            for ( i = 0; i < func->num_subfunctions; ++i )
+            {
+                object_free( func->functions[i].name );
+                function_free( func->functions[i].code );
+            }
+            BJAM_FREE( func->functions );
+
+            for ( i = 0; i < func->num_subactions; ++i )
+            {
+                object_free( func->actions[i].name );
+                function_free( func->actions[i].command );
+            }
+            BJAM_FREE( func->actions );
+
+            object_free( func->file );
+        }
+    }
+    else
+    {
+        if ( function_->rulename ) object_free( function_->rulename );
     }
 
     BJAM_FREE( function_ );
@@ -2643,6 +3099,28 @@
     stack_deallocate( s, sizeof( string * ) );
 }
 
+LIST * function_run_with_args( FUNCTION * function_, FRAME * frame, STACK * s, RULE * rule )
+{
+    LIST * result;
+    if ( function_->type == FUNCTION_BUILTIN )
+    {
+        BUILTIN_FUNCTION * f = (BUILTIN_FUNCTION *)function_;
+        if ( function_->formal_arguments )
+            argument_list_check( function_->formal_arguments, function_->num_formal_arguments, rule, frame );
+        return f->func( frame, f->flags );
+    }
+    
+    if ( function_->formal_arguments )
+        argument_list_push( function_->formal_arguments, function_->num_formal_arguments, rule, frame, s );
+    
+    result = function_run( function_, frame, s );
+
+    if ( function_->formal_arguments )
+        argument_list_pop( function_->formal_arguments, function_->num_formal_arguments, frame, s );
+
+    return result;
+}
+
 /*
  * WARNING: The instruction set is tuned for Jam and
  * is not really generic.  Be especially careful about
@@ -2700,6 +3178,12 @@
             break;
         }
 
+        case INSTR_PUSH_VAR_FIXED:
+        {
+            stack_push( s, list_copy( L0, frame->module->fixed_variables[ code->arg ] ) );
+            break;
+        }
+
         case INSTR_PUSH_GROUP:
         {
             LIST * value = L0;
@@ -2952,6 +3436,26 @@
             break;
         }
 
+        case INSTR_PUSH_LOCAL_FIXED:
+        {
+            LIST * value = stack_pop( s );
+            LIST * * ptr = &frame->module->fixed_variables[ code->arg ];
+            assert( code->arg < frame->module->num_fixed_variables );
+            stack_push( s, *ptr );
+            *ptr = value;
+            break;
+        }
+
+        case INSTR_POP_LOCAL_FIXED:
+        {
+            LIST * value = stack_pop( s );
+            LIST * * ptr = &frame->module->fixed_variables[ code->arg ];
+            assert( code->arg < frame->module->num_fixed_variables );
+            list_free( *ptr );
+            *ptr = value;
+            break;
+        }
+
         case INSTR_PUSH_LOCAL_GROUP:
         {
             LIST * value = stack_pop( s );
@@ -3101,12 +3605,39 @@
             function_append_variable( function, frame, code->arg, list_copy( L0, stack_top( s ) ) );
             break;
         }
+
         case INSTR_DEFAULT:
         {
             function_default_variable( function, frame, code->arg, list_copy( L0, stack_top( s ) ) );
             break;
         }
 
+        case INSTR_SET_FIXED:
+        {
+            LIST * * ptr = &frame->module->fixed_variables[ code->arg ];
+            assert( code->arg < frame->module->num_fixed_variables );
+            list_free( *ptr );
+            *ptr = list_copy( L0, stack_top( s ) );
+            break;
+        }
+
+        case INSTR_APPEND_FIXED:
+        {
+            LIST * * ptr = &frame->module->fixed_variables[ code->arg ];
+            assert( code->arg < frame->module->num_fixed_variables );
+            *ptr = list_append( *ptr, list_copy( L0, stack_top( s ) ) );
+            break;
+        }
+
+        case INSTR_DEFAULT_FIXED:
+        {
+            LIST * * ptr = &frame->module->fixed_variables[ code->arg ];
+            assert( code->arg < frame->module->num_fixed_variables );
+            if ( list_empty( *ptr ) )
+                *ptr = list_copy( L0, stack_top( s ) );
+            break;
+        }
+
         case INSTR_SET_GROUP:
         {
             LIST * value = stack_pop( s );
@@ -3374,6 +3905,12 @@
 
             break;
         }
+
+        case INSTR_BIND_MODULE_VARIABLES:
+        {
+            module_bind_variables( frame->module );
+            break;
+        }
         
         case INSTR_APPEND_STRINGS:
         {

Modified: trunk/tools/build/v2/engine/function.h
==============================================================================
--- trunk/tools/build/v2/engine/function.h	(original)
+++ trunk/tools/build/v2/engine/function.h	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -32,6 +32,9 @@
 FUNCTION * function_compile_actions( const char * actions, OBJECT * file, int line );
 void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s, string * out );
 
+FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * counter );
+FUNCTION * function_unbind_variables( FUNCTION * f );
+
 void function_done( void );
 
 #endif

Modified: trunk/tools/build/v2/engine/modules.c
==============================================================================
--- trunk/tools/build/v2/engine/modules.c	(original)
+++ trunk/tools/build/v2/engine/modules.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -42,6 +42,9 @@
         {
             m->name = object_copy( name );
             m->variables = 0;
+            m->variable_indices = 0;
+            m->num_fixed_variables = 0;
+            m->fixed_variables = 0;
             m->rules = 0;
             m->imported_modules = 0;
             m->class_module = 0;
@@ -116,6 +119,19 @@
         m->variables = 0;
     }
 
+    if ( m->fixed_variables )
+    {
+        int i;
+        for ( i = 0; i < m->num_fixed_variables; ++i )
+        {
+            list_free( m->fixed_variables[ i ] );
+        }
+        BJAM_FREE( m->fixed_variables );
+        m->fixed_variables = 0;
+        hashdone( m->variable_indices );
+        m->variable_indices = 0;
+    }
+
     if ( m->imported_modules )
     {
         hashenumerate( m->imported_modules, delete_imported_modules, (void *)0 );
@@ -190,3 +206,117 @@
         hashenumerate( module->imported_modules, add_module_name, &result );
     return result;
 }
+
+
+FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * counter );
+FUNCTION * function_unbind_variables( FUNCTION * f );
+
+struct fixed_variable
+{
+    OBJECT * key;
+    int n;
+};
+
+struct bind_vars_t
+{
+    module_t * module;
+    int counter;
+};
+
+static void bind_variables_for_rule( void * xrule, void * xdata )
+{
+    RULE * rule = (RULE *)xrule;
+    struct bind_vars_t * data = (struct bind_vars_t *)xdata;
+    if ( rule->procedure && rule->module == data->module )
+        rule->procedure = function_bind_variables( rule->procedure, data->module, &data->counter );
+}
+
+void module_bind_variables( struct module_t * m )
+{
+    if ( m != root_module() && m->rules )
+    {
+        struct bind_vars_t data = { m, m->num_fixed_variables };
+        hashenumerate( m->rules, &bind_variables_for_rule, &data );
+        module_set_fixed_variables( m, data.counter );
+    }
+}
+
+int module_add_fixed_var( struct module_t * m, OBJECT * name, int * counter )
+{
+    struct fixed_variable * v;
+    int found;
+
+    assert( !m->class_module );
+
+    if ( !m->variable_indices )
+        m->variable_indices = hashinit( sizeof( struct fixed_variable ), "variable index table" );
+
+    v = (struct fixed_variable *)hash_insert( m->variable_indices, name, &found );
+    if ( !found )
+    {
+        v->key = object_copy( name );
+        v->n = (*counter)++;
+    }
+
+    return v->n;
+}
+
+LIST * var_get_and_clear_raw( module_t * m, OBJECT * name );
+
+static void load_fixed_variable( void * xvar, void * data )
+{
+    struct fixed_variable * var = (struct fixed_variable *)xvar;
+    struct module_t * m = (struct module_t *)data;
+    if ( var->n >= m->num_fixed_variables )
+    {
+        m->fixed_variables[ var->n ] = var_get_and_clear_raw( m, var->key );
+    }
+}
+
+void module_set_fixed_variables( struct module_t * m, int n_variables )
+{
+    /* Reallocate */
+    struct hash * variable_indices;
+    LIST * * fixed_variables = BJAM_MALLOC( n_variables * sizeof( LIST * ) );
+    if ( m->fixed_variables )
+    {
+        memcpy( fixed_variables, m->fixed_variables, n_variables * sizeof( LIST * ) );
+        BJAM_FREE( m->fixed_variables );
+    }
+    m->fixed_variables = fixed_variables;
+    if ( m->class_module )
+    {
+        variable_indices = m->class_module->variable_indices;
+    }
+    else
+    {
+        variable_indices = m->variable_indices;
+    }
+    if ( variable_indices )
+        hashenumerate( variable_indices, &load_fixed_variable, m );
+    m->num_fixed_variables = n_variables;
+}
+
+int module_get_fixed_var( struct module_t * m_, OBJECT * name )
+{
+    struct fixed_variable * v;
+    struct module_t * m = m_;
+
+    if ( m->class_module )
+    {
+        m = m->class_module;
+    }
+
+    if ( !m->variable_indices )
+        return -1;
+
+    v = (struct fixed_variable *)hash_find( m->variable_indices, name );
+    if ( v && v->n < m_->num_fixed_variables )
+    {
+        return v->n;
+    }
+    else
+    {
+        return -1;
+    }
+}

Modified: trunk/tools/build/v2/engine/modules.h
==============================================================================
--- trunk/tools/build/v2/engine/modules.h	(original)
+++ trunk/tools/build/v2/engine/modules.h	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -13,6 +13,9 @@
     OBJECT * name;
     struct hash * rules;
     struct hash * variables;
+    struct hash * variable_indices;
+    int num_fixed_variables;
+    LIST * * fixed_variables;
     struct hash * imported_modules;
     struct module_t * class_module;
     struct hash * native_rules;
@@ -30,6 +33,20 @@
 
 struct hash * demand_rules( module_t * );
 
+void module_bind_variables( struct module_t * m );
+
+/*
+ * After calling module_add_fixed_var, module_set_fixed_variables
+ * must be called before accessing any variables in the module.
+ */
+int module_add_fixed_var( struct module_t * m, OBJECT * name, int * n );
+void module_set_fixed_variables( struct module_t * m, int n );
+
+/*
+ * Returns the index of the variable or -1 if none exists.
+ */
+int module_get_fixed_var( struct module_t * m, OBJECT * name );
+
 void modules_done();
 
 #endif

Modified: trunk/tools/build/v2/engine/rules.c
==============================================================================
--- trunk/tools/build/v2/engine/rules.c	(original)
+++ trunk/tools/build/v2/engine/rules.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -556,6 +556,7 @@
     }
 }
 
+void function_set_argument_list( FUNCTION * f, LOL * formal, RULE * rule );
 
 /*
  * set_rule_body() - set the argument list and procedure of the given rule.
@@ -569,6 +570,9 @@
         args_free( rule->arguments );
     rule->arguments = args;
 
+    if ( procedure && args )
+        function_set_argument_list( procedure, args->data, rule );
+
     if ( procedure )
         function_refer( procedure );
     if ( rule->procedure )
@@ -762,3 +766,17 @@
     set_rule_actions( dest, source->actions );
     return dest;
 }
+
+
+void rule_localize( RULE * rule, module_t * m )
+{
+    rule->module = m;
+    if ( rule->procedure )
+    {
+        FUNCTION * procedure = function_unbind_variables( rule->procedure );
+        function_refer( procedure );
+        function_free( rule->procedure );
+        rule->procedure = procedure;
+    }
+}
+

Modified: trunk/tools/build/v2/engine/rules.h
==============================================================================
--- trunk/tools/build/v2/engine/rules.h	(original)
+++ trunk/tools/build/v2/engine/rules.h	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -264,6 +264,7 @@
 /* Rule related functions. */
 RULE * bindrule        ( OBJECT * rulename, module_t * );
 RULE * import_rule     ( RULE * source, module_t *, OBJECT * name );
+void   rule_localize   ( RULE * rule, module_t * module );
 RULE * new_rule_body   ( module_t *, OBJECT * rulename, argument_list *, FUNCTION * func, int exprt );
 RULE * new_rule_actions( module_t *, OBJECT * rulename, FUNCTION * command, LIST * bindlist, int flags );
 void   rule_free       ( RULE * );

Modified: trunk/tools/build/v2/engine/variable.c
==============================================================================
--- trunk/tools/build/v2/engine/variable.c	(original)
+++ trunk/tools/build/v2/engine/variable.c	2012-03-22 19:26:48 EDT (Thu, 22 Mar 2012)
@@ -61,7 +61,7 @@
     LIST   * value;
 };
 
-static VARIABLE * var_enter( struct module_t * module, OBJECT * symbol );
+static LIST * * var_enter( struct module_t * module, OBJECT * symbol );
 static void var_dump( OBJECT * symbol, LIST * value, char * what );
 
 
@@ -202,8 +202,15 @@
 #endif
     {
         VARIABLE * v;
+        int n;
 
-        if ( module->variables && ( v = (VARIABLE *)hash_find( module->variables, symbol ) ) )
+        if ( ( n = module_get_fixed_var( module, symbol ) ) != -1 )
+        {
+            if ( DEBUG_VARGET )
+                var_dump( symbol, module->fixed_variables[ n ], "get" );
+            result = module->fixed_variables[ n ];
+        }
+        else if ( module->variables && ( v = (VARIABLE *)hash_find( module->variables, symbol ) ) )
         {
             if ( DEBUG_VARGET )
                 var_dump( v->symbol, v->value, "get" );
@@ -214,6 +221,20 @@
 }
 
 
+LIST * var_get_and_clear_raw( module_t * module, OBJECT * symbol )
+{
+    LIST * result = L0;
+    VARIABLE * v;
+
+    if ( module->variables && ( v = (VARIABLE *)hash_find( module->variables, symbol ) ) )
+    {
+        result = v->value;
+        v->value = L0;
+    }
+
+    return result;
+}
+
 /*
  * var_set() - set a variable in Jam's user defined symbol table.
  *
@@ -226,7 +247,7 @@
 
 void var_set( struct module_t * module, OBJECT * symbol, LIST * value, int flag )
 {
-    VARIABLE * v = var_enter( module, symbol );
+    LIST * * v = var_enter( module, symbol );
 
     if ( DEBUG_VARSET )
         var_dump( symbol, value, "set" );
@@ -235,19 +256,19 @@
     {
     case VAR_SET:
         /* Replace value */
-        list_free( v->value );
-        v->value = value;
+        list_free( *v );
+        *v = value;
         break;
 
     case VAR_APPEND:
         /* Append value */
-        v->value = list_append( v->value, value );
+        *v = list_append( *v, value );
         break;
 
     case VAR_DEFAULT:
         /* Set only if unset */
-        if ( list_empty( v->value ) )
-            v->value = value;
+        if ( list_empty( *v ) )
+            *v = value;
         else
             list_free( value );
         break;
@@ -261,11 +282,11 @@
 
 LIST * var_swap( struct module_t * module, OBJECT * symbol, LIST * value )
 {
-    VARIABLE * v = var_enter( module, symbol );
-    LIST     * oldvalue = v->value;
+    LIST * * v = var_enter( module, symbol );
+    LIST     * oldvalue = *v;
     if ( DEBUG_VARSET )
         var_dump( symbol, value, "set" );
-    v->value = value;
+    *v = value;
     return oldvalue;
 }
 
@@ -274,10 +295,16 @@
  * var_enter() - make new var symbol table entry, returning var ptr.
  */
 
-static VARIABLE * var_enter( struct module_t * module, OBJECT * symbol )
+static LIST * * var_enter( struct module_t * module, OBJECT * symbol )
 {
     int found;
     VARIABLE * v;
+    int n;
+
+    if ( ( n = module_get_fixed_var( module, symbol ) ) != -1 )
+    {
+        return &module->fixed_variables[ n ];
+    }
 
     if ( !module->variables )
         module->variables = hashinit( sizeof( VARIABLE ), "variables" );
@@ -289,7 +316,7 @@
         v->value = L0;
     }
 
-    return v;
+    return &v->value;
 }