diff options
Diffstat (limited to 'jam-files/engine/function.c')
| -rw-r--r-- | jam-files/engine/function.c | 2657 |
1 files changed, 1487 insertions, 1170 deletions
diff --git a/jam-files/engine/function.c b/jam-files/engine/function.c index 1688eba4e..690855e14 100644 --- a/jam-files/engine/function.c +++ b/jam-files/engine/function.c @@ -1,119 +1,128 @@ /* - * Copyright 2011 Steven Watanabe - * 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) + * Copyright 2011 Steven Watanabe + * Distributed under the Boost Software License, Version 1.0. + * (See accompanying file LICENSE_1_0.txt or copy at + * http://www.boost.org/LICENSE_1_0.txt) */ -#include "lists.h" -#include "pathsys.h" -#include "mem.h" -#include "constants.h" #include "jam.h" -#include "frames.h" #include "function.h" -#include "rules.h" -#include "variable.h" -#include "compile.h" -#include "search.h" + #include "class.h" -#include "pathsys.h" +#include "compile.h" +#include "constants.h" #include "filesys.h" -#include <string.h> -#include <stdlib.h> -#include <stdio.h> +#include "frames.h" +#include "lists.h" +#include "mem.h" +#include "pathsys.h" +#include "rules.h" +#include "search.h" +#include "variable.h" + #include <assert.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> -# ifdef OS_CYGWIN -# include <sys/cygwin.h> -# include <windows.h> +#ifdef OS_CYGWIN +# include <cygwin/version.h> +# include <sys/cygwin.h> +# ifdef CYGWIN_VERSION_CYGWIN_CONV +# include <errno.h> # endif +# include <windows.h> +#endif -int glob( const char * s, const char * c ); -void backtrace( FRAME * frame ); -void backtrace_line( FRAME * frame ); - -#define INSTR_PUSH_EMPTY 0 -#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 -#define INSTR_SWAP 7 - -#define INSTR_JUMP_EMPTY 8 -#define INSTR_JUMP_NOT_EMPTY 9 - -#define INSTR_JUMP 10 -#define INSTR_JUMP_LT 11 -#define INSTR_JUMP_LE 12 -#define INSTR_JUMP_GT 13 -#define INSTR_JUMP_GE 14 -#define INSTR_JUMP_EQ 15 -#define INSTR_JUMP_NE 16 -#define INSTR_JUMP_IN 17 -#define INSTR_JUMP_NOT_IN 18 - -#define INSTR_JUMP_NOT_GLOB 19 - -#define INSTR_FOR_INIT 56 -#define INSTR_FOR_LOOP 20 - -#define INSTR_SET_RESULT 21 -#define INSTR_RETURN 22 -#define INSTR_POP 23 - -#define INSTR_PUSH_LOCAL 24 -#define INSTR_POP_LOCAL 25 -#define INSTR_SET 26 -#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 -#define INSTR_APPEND_GROUP 32 -#define INSTR_DEFAULT_GROUP 33 - -#define INSTR_PUSH_ON 34 -#define INSTR_POP_ON 35 -#define INSTR_SET_ON 36 -#define INSTR_APPEND_ON 37 -#define INSTR_DEFAULT_ON 38 - -#define INSTR_CALL_RULE 39 - -#define INSTR_APPLY_MODIFIERS 40 -#define INSTR_APPLY_INDEX 41 -#define INSTR_APPLY_INDEX_MODIFIERS 42 -#define INSTR_APPLY_MODIFIERS_GROUP 43 -#define INSTR_APPLY_INDEX_GROUP 44 -#define INSTR_APPLY_INDEX_MODIFIERS_GROUP 45 -#define INSTR_COMBINE_STRINGS 46 - -#define INSTR_INCLUDE 47 -#define INSTR_RULE 48 -#define INSTR_ACTIONS 49 -#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 -#define INSTR_OUTPUT_STRINGS 55 +int glob( char const * s, char const * c ); +void backtrace( FRAME * ); +void backtrace_line( FRAME * ); + +#define INSTR_PUSH_EMPTY 0 +#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 +#define INSTR_SWAP 7 + +#define INSTR_JUMP_EMPTY 8 +#define INSTR_JUMP_NOT_EMPTY 9 + +#define INSTR_JUMP 10 +#define INSTR_JUMP_LT 11 +#define INSTR_JUMP_LE 12 +#define INSTR_JUMP_GT 13 +#define INSTR_JUMP_GE 14 +#define INSTR_JUMP_EQ 15 +#define INSTR_JUMP_NE 16 +#define INSTR_JUMP_IN 17 +#define INSTR_JUMP_NOT_IN 18 + +#define INSTR_JUMP_NOT_GLOB 19 + +#define INSTR_FOR_INIT 56 +#define INSTR_FOR_LOOP 20 + +#define INSTR_SET_RESULT 21 +#define INSTR_RETURN 22 +#define INSTR_POP 23 + +#define INSTR_PUSH_LOCAL 24 +#define INSTR_POP_LOCAL 25 +#define INSTR_SET 26 +#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 +#define INSTR_APPEND_GROUP 32 +#define INSTR_DEFAULT_GROUP 33 + +#define INSTR_PUSH_ON 34 +#define INSTR_POP_ON 35 +#define INSTR_SET_ON 36 +#define INSTR_APPEND_ON 37 +#define INSTR_DEFAULT_ON 38 +#define INSTR_GET_ON 65 + +#define INSTR_CALL_RULE 39 +#define INSTR_CALL_MEMBER_RULE 66 + +#define INSTR_APPLY_MODIFIERS 40 +#define INSTR_APPLY_INDEX 41 +#define INSTR_APPLY_INDEX_MODIFIERS 42 +#define INSTR_APPLY_MODIFIERS_GROUP 43 +#define INSTR_APPLY_INDEX_GROUP 44 +#define INSTR_APPLY_INDEX_MODIFIERS_GROUP 45 +#define INSTR_COMBINE_STRINGS 46 +#define INSTR_GET_GRIST 64 + +#define INSTR_INCLUDE 47 +#define INSTR_RULE 48 +#define INSTR_ACTIONS 49 +#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 +#define INSTR_OUTPUT_STRINGS 55 typedef struct instruction { unsigned int op_code; - int arg; + int arg; } instruction; typedef struct _subfunction @@ -125,15 +134,16 @@ typedef struct _subfunction typedef struct _subaction { - OBJECT * name; + OBJECT * name; FUNCTION * command; - int flags; + int flags; } SUBACTION; #define FUNCTION_BUILTIN 0 #define FUNCTION_JAM 1 -struct argument { +struct argument +{ int flags; #define ARG_ONE 0 #define ARG_OPTIONAL 1 @@ -145,7 +155,8 @@ struct argument { int index; }; -struct arg_list { +struct arg_list +{ int size; struct argument * args; }; @@ -193,7 +204,7 @@ typedef struct _python_function PyObject * python_function; } PYTHON_FUNCTION; -static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame ); +static LIST * call_python_function( PYTHON_FUNCTION *, FRAME * ); #endif @@ -210,7 +221,7 @@ STACK * stack_global() static STACK result; if ( !stack ) { - int size = 1 << 21; + int const size = 1 << 21; stack = BJAM_MALLOC( size ); result.data = (char *)stack + size; } @@ -219,7 +230,7 @@ STACK * stack_global() static void check_alignment( STACK * s ) { - assert( (unsigned long)s->data % sizeof( LIST * ) == 0 ); + assert( (size_t)s->data % sizeof( LIST * ) == 0 ); } void * stack_allocate( STACK * s, int size ) @@ -244,12 +255,12 @@ void stack_push( STACK * s, LIST * l ) LIST * stack_pop( STACK * s ) { - LIST * result = *(LIST * *)s->data; + LIST * const result = *(LIST * *)s->data; stack_deallocate( s, sizeof( LIST * ) ); return result; } -LIST * stack_top(STACK * s) +LIST * stack_top( STACK * s ) { check_alignment( s ); return *(LIST * *)s->data; @@ -258,7 +269,7 @@ LIST * stack_top(STACK * s) LIST * stack_at( STACK * s, int n ) { check_alignment( s ); - return *((LIST * *)s->data + n); + return *( (LIST * *)s->data + n ); } void stack_set( STACK * s, int n, LIST * value ) @@ -270,12 +281,12 @@ void stack_set( STACK * s, int n, LIST * value ) void * stack_get( STACK * s ) { check_alignment( s ); - return (LIST * *)s->data; + return s->data; } LIST * frame_get_local( FRAME * frame, int idx ) { - /* The only local variables are the arguments */ + /* The only local variables are the arguments. */ return list_copy( lol_get( frame->args, idx ) ); } @@ -284,55 +295,63 @@ static OBJECT * function_get_constant( JAM_FUNCTION * function, int idx ) return function->constants[ idx ]; } -static LIST * function_get_variable( JAM_FUNCTION * function, FRAME * frame, int idx ) +static LIST * function_get_variable( JAM_FUNCTION * function, FRAME * frame, + int idx ) { - return list_copy( var_get( frame->module, function->constants[idx] ) ); + return list_copy( var_get( frame->module, function->constants[ idx ] ) ); } -static void function_set_variable( JAM_FUNCTION * function, FRAME * frame, int idx, LIST * value ) +static void function_set_variable( JAM_FUNCTION * function, FRAME * frame, + int idx, LIST * value ) { - var_set( frame->module, function->constants[idx], value, VAR_SET ); + var_set( frame->module, function->constants[ idx ], value, VAR_SET ); } -static LIST * function_swap_variable( JAM_FUNCTION * function, FRAME * frame, int idx, LIST * value ) +static LIST * function_swap_variable( JAM_FUNCTION * function, FRAME * frame, + int idx, LIST * value ) { - return var_swap( frame->module, function->constants[idx], value ); + return var_swap( frame->module, function->constants[ idx ], value ); } -static void function_append_variable( JAM_FUNCTION * function, FRAME * frame, int idx, LIST * value ) +static void function_append_variable( JAM_FUNCTION * function, FRAME * frame, + int idx, LIST * value ) { - var_set( frame->module, function->constants[idx], value, VAR_APPEND ); + var_set( frame->module, function->constants[ idx ], value, VAR_APPEND ); } -static void function_default_variable( JAM_FUNCTION * function, FRAME * frame, int idx, LIST * value ) +static void function_default_variable( JAM_FUNCTION * function, FRAME * frame, + int idx, LIST * value ) { - var_set( frame->module, function->constants[idx], value, VAR_DEFAULT ); + var_set( frame->module, function->constants[ idx ], value, VAR_DEFAULT ); } -static void function_set_rule( JAM_FUNCTION * function, FRAME * frame, STACK * s, int idx ) +static void function_set_rule( JAM_FUNCTION * function, FRAME * frame, + STACK * s, int idx ) { SUBFUNCTION * sub = function->functions + idx; new_rule_body( frame->module, sub->name, sub->code, !sub->local ); } -static void function_set_actions( JAM_FUNCTION * function, FRAME * frame, STACK * s, int idx ) +static void function_set_actions( JAM_FUNCTION * function, FRAME * frame, + STACK * s, int idx ) { SUBACTION * sub = function->actions + idx; LIST * bindlist = stack_pop( s ); - - new_rule_actions( frame->module, sub->name, sub->command, bindlist, sub->flags ); + new_rule_actions( frame->module, sub->name, sub->command, bindlist, + sub->flags ); } + /* - * returns the index if name is "<", ">", "1", "2", ... or "19" - * otherwise returns -1. + * Returns the index if name is "<", ">", "1", "2", ... or "19" otherwise + * returns -1. */ -static int get_argument_index( const char * s ) +static int get_argument_index( char const * s ) { - if( s[ 0 ] != '\0') + if ( s[ 0 ] != '\0') { - if( s[ 1 ] == '\0' ) + if ( s[ 1 ] == '\0' ) { switch ( s[ 0 ] ) { @@ -372,42 +391,43 @@ static int get_argument_index( const char * s ) return -1; } -static LIST * function_get_named_variable( JAM_FUNCTION * function, FRAME * frame, OBJECT * name ) +static LIST * function_get_named_variable( JAM_FUNCTION * function, + FRAME * frame, OBJECT * name ) { - int idx = get_argument_index( object_str( name ) ); - if( idx != -1 ) - { - return list_copy( lol_get( frame->args, idx ) ); - } - else - { - return list_copy( var_get( frame->module, name ) ); - } + int const idx = get_argument_index( object_str( name ) ); + return idx == -1 + ? list_copy( var_get( frame->module, name ) ) + : list_copy( lol_get( frame->args, idx ) ); } -static void function_set_named_variable( JAM_FUNCTION * function, FRAME * frame, OBJECT * name, LIST * value) +static void function_set_named_variable( JAM_FUNCTION * function, FRAME * frame, + OBJECT * name, LIST * value) { var_set( frame->module, name, value, VAR_SET ); } -static LIST * function_swap_named_variable( JAM_FUNCTION * function, FRAME * frame, OBJECT * name, LIST * value ) +static LIST * function_swap_named_variable( JAM_FUNCTION * function, + FRAME * frame, OBJECT * name, LIST * value ) { return var_swap( frame->module, name, value ); } -static void function_append_named_variable( JAM_FUNCTION * function, FRAME * frame, OBJECT * name, LIST * value) +static void function_append_named_variable( JAM_FUNCTION * function, + FRAME * frame, OBJECT * name, LIST * value) { var_set( frame->module, name, value, VAR_APPEND ); } -static void function_default_named_variable( JAM_FUNCTION * function, FRAME * frame, OBJECT * name, LIST * value ) +static void function_default_named_variable( JAM_FUNCTION * function, + FRAME * frame, OBJECT * name, LIST * value ) { var_set( frame->module, name, value, VAR_DEFAULT ); } -static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, STACK * s, int n_args, const char * unexpanded, OBJECT * file, int line ) +static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, + STACK * s, int n_args, char const * unexpanded, OBJECT * file, int line ) { - FRAME inner[ 1 ]; + FRAME inner[ 1 ]; int i; LIST * first = stack_pop( s ); LIST * result = L0; @@ -416,12 +436,68 @@ static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, STACK frame->file = file; frame->line = line; - + if ( list_empty( first ) ) { backtrace_line( frame ); printf( "warning: rulename %s expands to empty string\n", unexpanded ); backtrace( frame ); + list_free( first ); + for ( i = 0; i < n_args; ++i ) + list_free( stack_pop( s ) ); + return result; + } + + rulename = object_copy( list_front( first ) ); + + 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(). */ + + for ( i = 0; i < n_args; ++i ) + lol_add( inner->args, stack_at( s, n_args - i - 1 ) ); + + for ( i = 0; i < n_args; ++i ) + stack_pop( s ); + + trailing = list_pop_front( first ); + if ( trailing ) + { + if ( inner->args->count == 0 ) + lol_add( inner->args, trailing ); + else + { + LIST * * const l = &inner->args->list[ 0 ]; + *l = list_append( trailing, *l ); + } + } + + result = evaluate_rule( bindrule( rulename, inner->module ), rulename, inner ); + frame_free( inner ); + object_free( rulename ); + return result; +} + +static LIST * function_call_member_rule( JAM_FUNCTION * function, FRAME * frame, STACK * s, int n_args, OBJECT * rulename, OBJECT * file, int line ) +{ + FRAME inner[ 1 ]; + int i; + LIST * first = stack_pop( s ); + LIST * result = L0; + LIST * trailing; + RULE * rule; + module_t * module; + OBJECT * real_rulename = 0; + + frame->file = file; + frame->line = line; + + if ( list_empty( first ) ) + { + backtrace_line( frame ); + printf( "warning: object is empty\n" ); + backtrace( frame ); list_free( first ); @@ -433,7 +509,26 @@ static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, STACK return result; } - rulename = object_copy( list_front( first ) ); + /* FIXME: handle generic case */ + assert( list_length( first ) == 1 ); + + module = bindmodule( list_front( first ) ); + if ( module->class_module ) + { + rule = bindrule( rulename, module ); + real_rulename = object_copy( function_rulename( rule->procedure ) ); + } + else + { + string buf[ 1 ]; + string_new( buf ); + string_append( buf, object_str( list_front( first ) ) ); + string_push_back( buf, '.' ); + string_append( buf, object_str( rulename ) ); + real_rulename = object_new( buf->value ); + string_free( buf ); + rule = bindrule( real_rulename, frame->module ); + } frame_init( inner ); @@ -451,26 +546,39 @@ static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, STACK stack_pop( s ); } - trailing = list_pop_front( first ); - if ( trailing ) + if ( list_length( first ) > 1 ) { - if ( inner->args->count == 0 ) + string buf[ 1 ]; + LIST * trailing = L0; + LISTITER iter = list_begin( first ), end = list_end( first ); + iter = list_next( iter ); + string_new( buf ); + for ( ; iter != end; iter = list_next( iter ) ) { - lol_add( inner->args, trailing ); + string_append( buf, object_str( list_item( iter ) ) ); + string_push_back( buf, '.' ); + string_append( buf, object_str( rulename ) ); + trailing = list_push_back( trailing, object_new( buf->value ) ); + string_truncate( buf, 0 ); } + string_free( buf ); + if ( inner->args->count == 0 ) + lol_add( inner->args, trailing ); else { - LIST * * l = &inner->args->list[0]; + LIST * * const l = &inner->args->list[ 0 ]; *l = list_append( trailing, *l ); } } - result = evaluate_rule( rulename, inner ); + result = evaluate_rule( rule, real_rulename, inner ); frame_free( inner ); object_free( rulename ); + object_free( real_rulename ); return result; } + /* Variable expansion */ typedef struct @@ -492,11 +600,10 @@ typedef struct PATHPART join; /* :J -- join list with char */ } VAR_EDITS; -static LIST * apply_modifiers_impl( LIST * result, string * buf, VAR_EDITS * edits, int n, LISTITER iter, LISTITER end ); -static void get_iters( subscript_t subscript, LISTITER * first, LISTITER * last, int length ); -static void var_edit_file( const char * in, string * out, VAR_EDITS * edits ); -static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits ); -static int var_edit_parse( const char * mods, VAR_EDITS * edits, int havezeroed ); +static LIST * apply_modifiers_impl( LIST * result, string * buf, + VAR_EDITS * edits, int n, LISTITER iter, LISTITER end ); +static void get_iters( subscript_t const subscript, LISTITER * const first, + LISTITER * const last, int const length ); /* @@ -534,7 +641,8 @@ static int var_edit_parse( const char * mods, VAR_EDITS * edits, int havezeroed * var_edit_file() below and path_build() obligingly follow this convention. */ -static int var_edit_parse( const char * mods, VAR_EDITS * edits, int havezeroed ) +static int var_edit_parse( char const * mods, VAR_EDITS * edits, int havezeroed + ) { while ( *mods ) { @@ -601,11 +709,12 @@ static int var_edit_parse( const char * mods, VAR_EDITS * edits, int havezeroed return havezeroed; } + /* * var_edit_file() - copy input target name to output, modifying filename. */ -static void var_edit_file( const char * in, string * out, VAR_EDITS * edits ) +static void var_edit_file( char const * in, string * out, VAR_EDITS * edits ) { if ( edits->filemods ) { @@ -627,37 +736,97 @@ static void var_edit_file( const char * in, string * out, VAR_EDITS * edits ) path_parent( &pathname ); /* Put filename back together. */ - path_build( &pathname, out, 0 ); + path_build( &pathname, out ); } else - { string_append( out, in ); - } } /* - * var_edit_shift() - do upshift/downshift mods. + * var_edit_cyg2win() - conversion of a cygwin to a Windows path. + * + * FIXME: skip grist */ -static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits ) +#ifdef OS_CYGWIN +static void var_edit_cyg2win( string * out, size_t pos, VAR_EDITS * edits ) { - if ( edits->upshift || edits->downshift || edits->to_windows || edits->to_slashes ) + if ( edits->to_windows ) { - /* Handle upshifting, downshifting and slash translation now. */ - char * p; -# ifdef OS_CYGWIN - if ( edits->to_windows ) + #ifdef CYGWIN_VERSION_CYGWIN_CONV + /* Use new Cygwin API added with Cygwin 1.7. Old one had no error + * handling and has been deprecated. + */ + char * dynamicBuffer = 0; + char buffer[ MAX_PATH + 1001 ]; + char const * result = buffer; + cygwin_conv_path_t const conv_type = CCP_POSIX_TO_WIN_A | CCP_RELATIVE; + ssize_t const apiResult = cygwin_conv_path( conv_type, out->value + pos, + buffer, sizeof( buffer ) / sizeof( *buffer ) ); + assert( apiResult == 0 || apiResult == -1 ); + assert( apiResult || strlen( result ) < sizeof( buffer ) / sizeof( + *buffer ) ); + if ( apiResult ) + { + result = 0; + if ( errno == ENOSPC ) + { + ssize_t const size = cygwin_conv_path( conv_type, out->value + + pos, NULL, 0 ); + assert( size >= -1 ); + if ( size > 0 ) + { + dynamicBuffer = (char *)BJAM_MALLOC_ATOMIC( size ); + if ( dynamicBuffer ) + { + ssize_t const apiResult = cygwin_conv_path( conv_type, + out->value + pos, dynamicBuffer, size ); + assert( apiResult == 0 || apiResult == -1 ); + if ( !apiResult ) + { + result = dynamicBuffer; + assert( strlen( result ) < size ); + } + } + } + } + } + #else /* CYGWIN_VERSION_CYGWIN_CONV */ + /* Use old Cygwin API deprecated with Cygwin 1.7. */ + char result[ MAX_PATH + 1 ]; + cygwin_conv_to_win32_path( out->value + pos, result ); + assert( strlen( result ) <= MAX_PATH ); + #endif /* CYGWIN_VERSION_CYGWIN_CONV */ + if ( result ) { - /* FIXME: skip grist */ - char result[ MAX_PATH + 1 ]; - cygwin_conv_to_win32_path( out->value + pos, result ); - assert( strlen( result ) <= MAX_PATH ); string_truncate( out, pos ); string_append( out, result ); edits->to_slashes = 0; } -# endif - for ( p = out->value + pos; *p; ++p) + #ifdef CYGWIN_VERSION_CYGWIN_CONV + if ( dynamicBuffer ) + BJAM_FREE( dynamicBuffer ); + #endif + } +} +#endif /* OS_CYGWIN */ + + +/* + * var_edit_shift() - do upshift/downshift & other mods. + */ + +static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits ) +{ +#ifdef OS_CYGWIN + var_edit_cyg2win( out, pos, edits ); +#endif + + if ( edits->upshift || edits->downshift || edits->to_slashes ) + { + /* Handle upshifting, downshifting and slash translation now. */ + char * p; + for ( p = out->value + pos; *p; ++p ) { if ( edits->upshift ) *p = toupper( *p ); @@ -669,12 +838,10 @@ static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits ) } } + /* - * Reads n LISTs from the top of the STACK and - * combines them to form VAR_EDITS. - * - * returns the number of VAR_EDITS pushed onto - * the STACK. + * Reads n LISTs from the top of the STACK and combines them to form VAR_EDITS. + * Returns the number of VAR_EDITS pushed onto the STACK. */ static int expand_modifiers( STACK * s, int n ) @@ -682,39 +849,33 @@ static int expand_modifiers( STACK * s, int n ) int i; int total = 1; LIST * * args = stack_get( s ); - for( i = 0; i < n; ++i) - total *= list_length( args[i] ); + for ( i = 0; i < n; ++i ) + total *= list_length( args[ i ] ); if ( total != 0 ) { - VAR_EDITS * out = stack_allocate( s, total * sizeof(VAR_EDITS) ); - LISTITER * iter = stack_allocate( s, n * sizeof(LIST *) ); - for (i = 0; i < n; ++i ) - { - iter[i] = list_begin( args[i] ); - } + VAR_EDITS * out = stack_allocate( s, total * sizeof( VAR_EDITS ) ); + LISTITER * iter = stack_allocate( s, n * sizeof( LIST * ) ); + for ( i = 0; i < n; ++i ) + iter[ i ] = list_begin( args[ i ] ); i = 0; { int havezeroed; loop: memset( out, 0, sizeof( *out ) ); havezeroed = 0; - for (i = 0; i < n; ++i ) - { - havezeroed = var_edit_parse( object_str( list_item( iter[i] ) ), out, havezeroed ); - } + for ( i = 0; i < n; ++i ) + havezeroed = var_edit_parse( object_str( list_item( iter[ i ] ) + ), out, havezeroed ); ++out; while ( --i >= 0 ) { - if ( list_next( iter[i] ) != list_end( args[i] ) ) + if ( list_next( iter[ i ] ) != list_end( args[ i ] ) ) { - iter[i] = list_next( iter[i] ); + iter[ i ] = list_next( iter[ i ] ); goto loop; } - else - { - iter[i] = list_begin( args[i] ); - } + iter[ i ] = list_begin( args[ i ] ); } } stack_deallocate( s, n * sizeof( LIST * ) ); @@ -726,20 +887,22 @@ static LIST * apply_modifiers( STACK * s, int n ) { LIST * value = stack_top( s ); LIST * result = L0; - VAR_EDITS * edits = (VAR_EDITS *)( (LIST * *)stack_get( s ) + 1 ); - string buf[1]; + VAR_EDITS * const edits = (VAR_EDITS *)( (LIST * *)stack_get( s ) + 1 ); + string buf[ 1 ]; string_new( buf ); - result = apply_modifiers_impl( result, buf, edits, n, list_begin( value ), list_end( value ) ); + result = apply_modifiers_impl( result, buf, edits, n, list_begin( value ), + list_end( value ) ); string_free( buf ); return result; } + /* - * Parse a string of the form "1-2", "-2--1", "2-" - * and return the two subscripts. + * Parse a string of the form "1-2", "-2--1", "2-" and return the two + * subscripts. */ -subscript_t parse_subscript( const char * s ) +subscript_t parse_subscript( char const * s ) { subscript_t result; result.sub1 = 0; @@ -801,30 +964,33 @@ static LIST * apply_subscript( STACK * s ) LIST * indices = stack_at( s, 1 ); LIST * result = L0; int length = list_length( value ); - string buf[1]; - LISTITER indices_iter = list_begin( indices ), indices_end = list_end( indices ); + string buf[ 1 ]; + LISTITER indices_iter = list_begin( indices ); + LISTITER const indices_end = list_end( indices ); string_new( buf ); - for ( ; indices_iter != indices_end; indices_iter = list_next( indices_iter ) ) + for ( ; indices_iter != indices_end; indices_iter = list_next( indices_iter + ) ) { LISTITER iter = list_begin( value ); LISTITER end = list_end( value ); - subscript_t subscript = parse_subscript( object_str( list_item( indices_iter ) ) ); + subscript_t const subscript = parse_subscript( object_str( list_item( + indices_iter ) ) ); get_iters( subscript, &iter, &end, length ); for ( ; iter != end; iter = list_next( iter ) ) - { result = list_push_back( result, object_copy( list_item( iter ) ) ); - } } string_free( buf ); return result; } + /* - * Reads the LIST from first and applies subscript to it. - * The results are written to *first and *last. + * Reads the LIST from first and applies subscript to it. The results are + * written to *first and *last. */ -static void get_iters( subscript_t subscript, LISTITER * first, LISTITER * last, int length ) +static void get_iters( subscript_t const subscript, LISTITER * const first, + LISTITER * const last, int const length ) { int start; int size; @@ -834,28 +1000,24 @@ static void get_iters( subscript_t subscript, LISTITER * first, LISTITER * last, if ( subscript.sub1 < 0 ) start = length + subscript.sub1; - else if( subscript.sub1 > length ) + else if ( subscript.sub1 > length ) start = length; else start = subscript.sub1 - 1; - if ( subscript.sub2 < 0 ) - size = length + 1 + subscript.sub2 - start; - else - size = subscript.sub2 - start; + size = subscript.sub2 < 0 + ? length + 1 + subscript.sub2 - start + : subscript.sub2 - start; /* - * HACK: When the first subscript is before the start of the - * list, it magically becomes the beginning of the list. - * This is inconsistent, but needed for backwards - * compatibility. + * HACK: When the first subscript is before the start of the list, it + * magically becomes the beginning of the list. This is inconsistent, + * but needed for backwards compatibility. */ if ( start < 0 ) start = 0; - /* The "sub2 < 0" test handles the semantic error of sub2 < - * sub1. - */ + /* The "sub2 < 0" test handles the semantic error of sub2 < sub1. */ if ( size < 0 ) size = 0; @@ -875,15 +1037,16 @@ static void get_iters( subscript_t subscript, LISTITER * first, LISTITER * last, *last = end; } -static LIST * apply_modifiers_empty( LIST * result, string * buf, VAR_EDITS * edits, int n) +static LIST * apply_modifiers_empty( LIST * result, string * buf, + VAR_EDITS * edits, int n ) { int i; for ( i = 0; i < n; ++i ) { - if ( edits[i].empty.ptr ) + if ( edits[ i ].empty.ptr ) { /** FIXME: is empty.ptr always null-terminated? */ - var_edit_file( edits[i].empty.ptr, buf, edits + i ); + var_edit_file( edits[ i ].empty.ptr, buf, edits + i ); var_edit_shift( buf, 0, edits + i ); result = list_push_back( result, object_new( buf->value ) ); string_truncate( buf, 0 ); @@ -892,22 +1055,25 @@ static LIST * apply_modifiers_empty( LIST * result, string * buf, VAR_EDITS * ed return result; } -static LIST * apply_modifiers_non_empty( LIST * result, string * buf, VAR_EDITS * edits, int n, LISTITER begin, LISTITER end ) +static LIST * apply_modifiers_non_empty( LIST * result, string * buf, + VAR_EDITS * edits, int n, LISTITER begin, LISTITER end ) { int i; LISTITER iter; for ( i = 0; i < n; ++i ) { - if ( edits[i].join.ptr ) + if ( edits[ i ].join.ptr ) { var_edit_file( object_str( list_item( begin ) ), buf, edits + i ); var_edit_shift( buf, 0, edits + i ); - for ( iter = list_next( begin ); iter != end; iter = list_next( iter ) ) + for ( iter = list_next( begin ); iter != end; iter = list_next( iter + ) ) { size_t size; - string_append( buf, edits[i].join.ptr ); + string_append( buf, edits[ i ].join.ptr ); size = buf->size; - var_edit_file( object_str( list_item( iter ) ), buf, edits + i ); + var_edit_file( object_str( list_item( iter ) ), buf, edits + i + ); var_edit_shift( buf, size, edits + i ); } result = list_push_back( result, object_new( buf->value ) ); @@ -927,33 +1093,32 @@ static LIST * apply_modifiers_non_empty( LIST * result, string * buf, VAR_EDITS return result; } -static LIST * apply_modifiers_impl( LIST * result, string * buf, VAR_EDITS * edits, int n, LISTITER iter, LISTITER end ) +static LIST * apply_modifiers_impl( LIST * result, string * buf, + VAR_EDITS * edits, int n, LISTITER iter, LISTITER end ) { - if ( iter != end ) - { - return apply_modifiers_non_empty( result, buf, edits, n, iter, end ); - } - else - { - return apply_modifiers_empty( result, buf, edits, n ); - } + return iter == end + ? apply_modifiers_empty( result, buf, edits, n ) + : apply_modifiers_non_empty( result, buf, edits, n, iter, end ); } static LIST * apply_subscript_and_modifiers( STACK * s, int n ) { - LIST * value = stack_top( s ); - LIST * indices = stack_at( s, 1 ); + LIST * const value = stack_top( s ); + LIST * const indices = stack_at( s, 1 ); LIST * result = L0; - VAR_EDITS * edits = (VAR_EDITS *)((LIST * *)stack_get( s ) + 2); - int length = list_length( value ); - string buf[1]; - LISTITER indices_iter = list_begin( indices ), indices_end = list_end( indices ); + VAR_EDITS * const edits = (VAR_EDITS *)((LIST * *)stack_get( s ) + 2); + int const length = list_length( value ); + string buf[ 1 ]; + LISTITER indices_iter = list_begin( indices ); + LISTITER const indices_end = list_end( indices ); string_new( buf ); - for ( ; indices_iter != indices_end; indices_iter = list_next( indices_iter ) ) + for ( ; indices_iter != indices_end; indices_iter = list_next( indices_iter + ) ) { LISTITER iter = list_begin( value ); LISTITER end = list_end( value ); - subscript_t sub = parse_subscript( object_str( list_item( indices_iter ) ) ); + subscript_t const sub = parse_subscript( object_str( list_item( + indices_iter ) ) ); get_iters( sub, &iter, &end, length ); result = apply_modifiers_impl( result, buf, edits, n, iter, end ); } @@ -961,57 +1126,116 @@ static LIST * apply_subscript_and_modifiers( STACK * s, int n ) return result; } + +/* + * expand() - expands a list of concatenated strings and variable refereces + * + * Takes a list of expansion items - each representing one element to be + * concatenated and each containing a list of its values. Returns a list of all + * possible values constructed by selecting a single value from each of the + * elements and concatenating them together. + * + * For example, in the following code: + * + * local a = one two three four ; + * local b = foo bar ; + * ECHO /$(a)/$(b)/$(a)/ ; + * + * When constructing the result of /$(a)/$(b)/ this function would get called + * with the following 7 expansion items: + * 1. / + * 2. one two three four + * 3. / + * 4. foo bar + * 5. / + * 6. one two three four + * 7. / + * + * And would result in a list containing 32 values: + * 1. /one/foo/one/ + * 2. /one/foo/two/ + * 3. /one/foo/three/ + * 4. /one/foo/four/ + * 5. /one/bar/one/ + * ... + * + */ + typedef struct expansion_item { - LISTITER elem; - LIST * saved; - int size; + /* Item's value list initialized prior to calling expand(). */ + LIST * values; + + /* Internal data initialized and used inside expand(). */ + LISTITER current; /* Currently used value. */ + int size; /* Concatenated string length prior to concatenating the + * item's current value. + */ } expansion_item; -static LIST * expand( expansion_item * elem, int length ) +static LIST * expand( expansion_item * items, int const length ) { LIST * result = L0; - string buf[1]; + string buf[ 1 ]; int size = 0; int i; + assert( length > 0 ); for ( i = 0; i < length; ++i ) { - int max = 0; - LISTITER iter = elem[i].elem, end = list_end( elem[i].saved ); - if ( iter == end ) return result; - for ( ; iter != end; iter = list_next( iter ) ) + LISTITER iter = list_begin( items[ i ].values ); + LISTITER const end = list_end( items[ i ].values ); + + /* If any of the items has no values - the result is an empty list. */ + if ( iter == end ) return L0; + + /* Set each item's 'current' to its first listed value. This indicates + * each item's next value to be used when constructing the list of all + * possible concatenated values. + */ + items[ i ].current = iter; + + /* Calculate the longest concatenated string length - to know how much + * memory we need to allocate as a buffer for holding the concatenated + * strings. + */ { - int len = strlen( object_str( list_item( iter ) ) ); - if ( len > max ) max = len; + int max = 0; + for ( ; iter != end; iter = list_next( iter ) ) + { + int const len = strlen( object_str( list_item( iter ) ) ); + if ( len > max ) max = len; + } + size += max; } - size += max; } + string_new( buf ); string_reserve( buf, size ); + i = 0; + while ( i >= 0 ) { - loop: for ( ; i < length; ++i ) { - elem[i].size = buf->size; - string_append( buf, object_str( list_item( elem[i].elem ) ) ); + items[ i ].size = buf->size; + string_append( buf, object_str( list_item( items[ i ].current ) ) ); } result = list_push_back( result, object_new( buf->value ) ); while ( --i >= 0 ) { - if( list_next( elem[i].elem ) != list_end( elem[i].saved ) ) + if ( list_next( items[ i ].current ) != list_end( items[ i ].values + ) ) { - elem[i].elem = list_next( elem[i].elem ); - string_truncate( buf, elem[i].size ); - goto loop; + items[ i ].current = list_next( items[ i ].current ); + string_truncate( buf, items[ i ].size ); + break; } else - { - elem[i].elem = list_begin( elem[i].saved ); - } + items[ i ].current = list_begin( items[ i ].values ); } } + string_free( buf ); return result; } @@ -1021,12 +1245,14 @@ static void combine_strings( STACK * s, int n, string * out ) int i; for ( i = 0; i < n; ++i ) { - LIST * values = stack_pop( s ); - LISTITER iter = list_begin( values ), end = list_end( values ); + LIST * const values = stack_pop( s ); + LISTITER iter = list_begin( values ); + LISTITER const end = list_end( values ); if ( iter != end ) { string_append( out, object_str( list_item( iter ) ) ); - for ( iter = list_next( iter ); iter != end; iter = list_next( iter ) ) + for ( iter = list_next( iter ); iter != end; iter = list_next( iter + ) ) { string_push_back( out, ' ' ); string_append( out, object_str( list_item( iter ) ) ); @@ -1055,7 +1281,8 @@ static void dynamic_array_free( struct dynamic_array * array ) BJAM_FREE( array->data ); } -static void dynamic_array_push_impl( struct dynamic_array * array, void * value, int unit_size ) +static void dynamic_array_push_impl( struct dynamic_array * const array, + void const * const value, int const unit_size ) { if ( array->capacity == 0 ) { @@ -1075,9 +1302,10 @@ static void dynamic_array_push_impl( struct dynamic_array * array, void * value, ++array->size; } -#define dynamic_array_push( array, value ) ( dynamic_array_push_impl( array, &value, sizeof(value) ) ) +#define dynamic_array_push( array, value ) (dynamic_array_push_impl(array, &value, sizeof(value))) #define dynamic_array_at( type, array, idx ) (((type *)(array)->data)[idx]) + /* * struct compiler */ @@ -1085,7 +1313,7 @@ static void dynamic_array_push_impl( struct dynamic_array * array, void * value, struct label_info { int absolute_position; - struct dynamic_array uses[1]; + struct dynamic_array uses[ 1 ]; }; struct stored_rule @@ -1099,11 +1327,11 @@ struct stored_rule typedef struct compiler { - struct dynamic_array code[1]; - struct dynamic_array constants[1]; - struct dynamic_array labels[1]; - struct dynamic_array rules[1]; - struct dynamic_array actions[1]; + struct dynamic_array code[ 1 ]; + struct dynamic_array constants[ 1 ]; + struct dynamic_array labels[ 1 ]; + struct dynamic_array rules[ 1 ]; + struct dynamic_array actions[ 1 ]; } compiler; static void compiler_init( compiler * c ) @@ -1121,9 +1349,8 @@ static void compiler_free( compiler * c ) dynamic_array_free( c->actions ); dynamic_array_free( c->rules ); for ( i = 0; i < c->labels->size; ++i ) - { - dynamic_array_free( dynamic_array_at( struct label_info, c->labels, i ).uses ); - } + dynamic_array_free( dynamic_array_at( struct label_info, c->labels, i + ).uses ); dynamic_array_free( c->labels ); dynamic_array_free( c->constants ); dynamic_array_free( c->code ); @@ -1146,15 +1373,16 @@ static int compile_new_label( compiler * c ) static void compile_set_label( compiler * c, int label ) { - struct label_info * l = &dynamic_array_at( struct label_info, c->labels, label ); - int pos = c->code->size; + struct label_info * const l = &dynamic_array_at( struct label_info, + c->labels, label ); + int const pos = c->code->size; int i; assert( l->absolute_position == -1 ); l->absolute_position = pos; for ( i = 0; i < l->uses->size; ++i ) { int id = dynamic_array_at( int, l->uses, i ); - int offset = (int)(pos - id - 1); + int offset = (int)( pos - id - 1 ); dynamic_array_at( instruction, c->code, id ).arg = offset; } } @@ -1169,8 +1397,9 @@ static void compile_emit( compiler * c, unsigned int op_code, int arg ) static void compile_emit_branch( compiler * c, unsigned int op_code, int label ) { - struct label_info * l = &dynamic_array_at( struct label_info, c->labels, label ); - int pos = c->code->size; + struct label_info * const l = &dynamic_array_at( struct label_info, + c->labels, label ); + int const pos = c->code->size; instruction instr; instr.op_code = op_code; if ( l->absolute_position == -1 ) @@ -1179,9 +1408,7 @@ static void compile_emit_branch( compiler * c, unsigned int op_code, int label ) dynamic_array_push( l->uses, pos ); } else - { instr.arg = (int)( l->absolute_position - pos - 1 ); - } compile_emit_instruction( c, instr ); } @@ -1192,7 +1419,8 @@ static int compile_emit_constant( compiler * c, OBJECT * value ) return c->constants->size - 1; } -static int compile_emit_rule( compiler * c, OBJECT * name, PARSE * parse, int num_arguments, struct arg_list * arguments, int local ) +static int compile_emit_rule( compiler * c, OBJECT * name, PARSE * parse, + int num_arguments, struct arg_list * arguments, int local ) { struct stored_rule rule; rule.name = object_copy( name ); @@ -1208,7 +1436,8 @@ static int compile_emit_actions( compiler * c, PARSE * parse ) { SUBACTION a; a.name = object_copy( parse->string ); - a.command = function_compile_actions( object_str( parse->string1 ), parse->file, parse->line ); + a.command = function_compile_actions( object_str( parse->string1 ), + parse->file, parse->line ); a.flags = parse->num; dynamic_array_push( c->actions, a ); return (int)( c->actions->size - 1 ); @@ -1216,7 +1445,7 @@ static int compile_emit_actions( compiler * c, PARSE * parse ) static JAM_FUNCTION * compile_to_function( compiler * c ) { - JAM_FUNCTION * result = BJAM_MALLOC( sizeof(JAM_FUNCTION) ); + JAM_FUNCTION * const result = BJAM_MALLOC( sizeof( JAM_FUNCTION ) ); int i; result->base.type = FUNCTION_JAM; result->base.reference_count = 1; @@ -1226,27 +1455,30 @@ static JAM_FUNCTION * compile_to_function( compiler * c ) 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) ); + result->code = BJAM_MALLOC( c->code->size * sizeof( instruction ) ); + memcpy( result->code, c->code->data, c->code->size * sizeof( instruction ) ); - result->constants = BJAM_MALLOC( c->constants->size * sizeof(OBJECT *) ); - memcpy( result->constants, c->constants->data, c->constants->size * sizeof(OBJECT *) ); + result->constants = BJAM_MALLOC( c->constants->size * sizeof( OBJECT * ) ); + memcpy( result->constants, c->constants->data, c->constants->size * sizeof( + OBJECT * ) ); result->num_constants = c->constants->size; result->num_subfunctions = c->rules->size; - result->functions = BJAM_MALLOC( c->rules->size * sizeof(SUBFUNCTION) ); + result->functions = BJAM_MALLOC( c->rules->size * sizeof( SUBFUNCTION ) ); for ( i = 0; i < c->rules->size; ++i ) { - struct stored_rule * rule = &dynamic_array_at( struct stored_rule, c->rules, i ); - result->functions[i].name = rule->name; - result->functions[i].code = function_compile( rule->parse ); - result->functions[i].code->num_formal_arguments = rule->num_arguments; - result->functions[i].code->formal_arguments = rule->arguments; - result->functions[i].local = rule->local; + struct stored_rule * const rule = &dynamic_array_at( struct stored_rule, + c->rules, i ); + result->functions[ i ].name = rule->name; + result->functions[ i ].code = function_compile( rule->parse ); + result->functions[ i ].code->num_formal_arguments = rule->num_arguments; + result->functions[ i ].code->formal_arguments = rule->arguments; + result->functions[ i ].local = rule->local; } - result->actions = BJAM_MALLOC( c->actions->size * sizeof(SUBACTION) ); - memcpy( result->actions, c->actions->data, c->actions->size * sizeof(SUBACTION) ); + result->actions = BJAM_MALLOC( c->actions->size * sizeof( SUBACTION ) ); + memcpy( result->actions, c->actions->data, c->actions->size * sizeof( + SUBACTION ) ); result->num_subactions = c->actions->size; result->generic = 0; @@ -1257,18 +1489,19 @@ static JAM_FUNCTION * compile_to_function( compiler * c ) return result; } + /* * Parsing of variable expansions */ typedef struct VAR_PARSE_GROUP { - struct dynamic_array elems[1]; + struct dynamic_array elems[ 1 ]; } VAR_PARSE_GROUP; typedef struct VAR_PARSE_ACTIONS { - struct dynamic_array elems[1]; + struct dynamic_array elems[ 1 ]; } VAR_PARSE_ACTIONS; #define VAR_PARSE_TYPE_VAR 0 @@ -1277,7 +1510,7 @@ typedef struct VAR_PARSE_ACTIONS typedef struct _var_parse { - int type; /* string or variable */ + int type; /* string, variable or file */ } VAR_PARSE; typedef struct @@ -1285,7 +1518,7 @@ typedef struct VAR_PARSE base; VAR_PARSE_GROUP * name; VAR_PARSE_GROUP * subscript; - struct dynamic_array modifiers[1]; + struct dynamic_array modifiers[ 1 ]; } VAR_PARSE_VAR; typedef struct @@ -1297,19 +1530,20 @@ typedef struct typedef struct { VAR_PARSE base; - struct dynamic_array filename[1]; - struct dynamic_array contents[1]; + struct dynamic_array filename[ 1 ]; + struct dynamic_array contents[ 1 ]; } VAR_PARSE_FILE; static void var_parse_free( VAR_PARSE * ); + /* * VAR_PARSE_GROUP */ static VAR_PARSE_GROUP * var_parse_group_new() { - VAR_PARSE_GROUP * result = BJAM_MALLOC( sizeof( VAR_PARSE_GROUP ) ); + VAR_PARSE_GROUP * const result = BJAM_MALLOC( sizeof( VAR_PARSE_GROUP ) ); dynamic_array_init( result->elems ); return result; } @@ -1318,9 +1552,7 @@ static void var_parse_group_free( VAR_PARSE_GROUP * group ) { int i; for ( i = 0; i < group->elems->size; ++i ) - { var_parse_free( dynamic_array_at( VAR_PARSE *, group->elems, i ) ); - } dynamic_array_free( group->elems ); BJAM_FREE( group ); } @@ -1330,12 +1562,14 @@ static void var_parse_group_add( VAR_PARSE_GROUP * group, VAR_PARSE * elem ) dynamic_array_push( group->elems, elem ); } -static void var_parse_group_maybe_add_constant( VAR_PARSE_GROUP * group, const char * start, const char * end ) +static void var_parse_group_maybe_add_constant( VAR_PARSE_GROUP * group, + char const * start, char const * end ) { if ( start != end ) { - string buf[1]; - VAR_PARSE_STRING * value = (VAR_PARSE_STRING *)BJAM_MALLOC( sizeof(VAR_PARSE_STRING) ); + string buf[ 1 ]; + VAR_PARSE_STRING * const value = (VAR_PARSE_STRING *)BJAM_MALLOC( + sizeof(VAR_PARSE_STRING) ); value->base.type = VAR_PARSE_TYPE_STRING; string_new( buf ); string_append_range( buf, start, end ); @@ -1351,20 +1585,20 @@ VAR_PARSE_STRING * var_parse_group_as_literal( VAR_PARSE_GROUP * group ) { VAR_PARSE * result = dynamic_array_at( VAR_PARSE *, group->elems, 0 ); if ( result->type == VAR_PARSE_TYPE_STRING ) - { return (VAR_PARSE_STRING *)result; - } } return 0; } + /* * VAR_PARSE_ACTIONS */ static VAR_PARSE_ACTIONS * var_parse_actions_new() { - VAR_PARSE_ACTIONS * result = (VAR_PARSE_ACTIONS *)BJAM_MALLOC( sizeof(VAR_PARSE_ACTIONS) ); + VAR_PARSE_ACTIONS * const result = (VAR_PARSE_ACTIONS *)BJAM_MALLOC( + sizeof(VAR_PARSE_ACTIONS) ); dynamic_array_init( result->elems ); return result; } @@ -1373,13 +1607,13 @@ static void var_parse_actions_free( VAR_PARSE_ACTIONS * actions ) { int i; for ( i = 0; i < actions->elems->size; ++i ) - { - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, actions->elems, i ) ); - } + var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, + actions->elems, i ) ); dynamic_array_free( actions->elems ); BJAM_FREE( actions ); } + /* * VAR_PARSE_VAR */ @@ -1400,8 +1634,9 @@ static void var_parse_var_free( VAR_PARSE_VAR * var ) var_parse_group_free( var->name ); if ( var->subscript ) var_parse_group_free( var->subscript ); - for( i = 0; i < var->modifiers->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, var->modifiers, i ) ); + for ( i = 0; i < var->modifiers->size; ++i ) + var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, + var->modifiers, i ) ); dynamic_array_free( var->modifiers ); BJAM_FREE( var ); } @@ -1413,6 +1648,7 @@ static VAR_PARSE_GROUP * var_parse_var_new_modifier( VAR_PARSE_VAR * var ) return result; } + /* * VAR_PARSE_STRING */ @@ -1423,13 +1659,15 @@ static void var_parse_string_free( VAR_PARSE_STRING * string ) BJAM_FREE( string ); } + /* * VAR_PARSE_FILE */ static VAR_PARSE_FILE * var_parse_file_new( void ) { - VAR_PARSE_FILE * result = (VAR_PARSE_FILE *)BJAM_MALLOC( sizeof( VAR_PARSE_FILE ) ); + VAR_PARSE_FILE * const result = (VAR_PARSE_FILE *)BJAM_MALLOC( sizeof( + VAR_PARSE_FILE ) ); result->base.type = VAR_PARSE_TYPE_FILE; dynamic_array_init( result->filename ); dynamic_array_init( result->contents ); @@ -1439,83 +1677,102 @@ static VAR_PARSE_FILE * var_parse_file_new( void ) static void var_parse_file_free( VAR_PARSE_FILE * file ) { int i; - for( i = 0; i < file->filename->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, file->filename, i ) ); + for ( i = 0; i < file->filename->size; ++i ) + var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, + file->filename, i ) ); dynamic_array_free( file->filename ); - for( i = 0; i < file->contents->size; ++i ) - var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, file->contents, i ) ); + for ( i = 0; i < file->contents->size; ++i ) + var_parse_group_free( dynamic_array_at( VAR_PARSE_GROUP *, + file->contents, i ) ); dynamic_array_free( file->contents ); BJAM_FREE( file ); } + /* * VAR_PARSE */ static void var_parse_free( VAR_PARSE * parse ) { - if ( parse->type == VAR_PARSE_TYPE_VAR ) - { - var_parse_var_free( (VAR_PARSE_VAR *)parse ); - } - else if ( parse->type == VAR_PARSE_TYPE_STRING ) - { - var_parse_string_free( (VAR_PARSE_STRING *)parse ); - } - else if ( parse->type == VAR_PARSE_TYPE_FILE ) - { - var_parse_file_free( (VAR_PARSE_FILE *)parse ); - } - else + switch ( parse->type ) { - assert(!"Invalid type"); + case VAR_PARSE_TYPE_VAR: + var_parse_var_free( (VAR_PARSE_VAR *)parse ); + break; + + case VAR_PARSE_TYPE_STRING: + var_parse_string_free( (VAR_PARSE_STRING *)parse ); + break; + + case VAR_PARSE_TYPE_FILE: + var_parse_file_free( (VAR_PARSE_FILE *)parse ); + break; + + default: + assert( !"Invalid type" ); } } + /* * Compile VAR_PARSE */ -static void var_parse_group_compile( const VAR_PARSE_GROUP * parse, compiler * c ); +static void var_parse_group_compile( VAR_PARSE_GROUP const * parse, + compiler * c ); -static void var_parse_var_compile( const VAR_PARSE_VAR * parse, compiler * c ) +static void var_parse_var_compile( VAR_PARSE_VAR const * parse, compiler * c ) { int expand_name = 0; + int is_get_grist = 0; + int has_modifiers = 0; + /* Special case common modifiers */ + if ( parse->modifiers->size == 1 ) + { + VAR_PARSE_GROUP * mod = dynamic_array_at( VAR_PARSE_GROUP *, parse->modifiers, 0 ); + if ( mod->elems->size == 1 ) + { + VAR_PARSE * mod1 = dynamic_array_at( VAR_PARSE *, mod->elems, 0 ); + if ( mod1->type == VAR_PARSE_TYPE_STRING ) + { + OBJECT * s = ( (VAR_PARSE_STRING *)mod1 )->s; + if ( ! strcmp ( object_str( s ), "G" ) ) + { + is_get_grist = 1; + } + } + } + } /* If there are modifiers, emit them in reverse order. */ - if ( parse->modifiers->size > 0 ) + if ( parse->modifiers->size > 0 && !is_get_grist ) { int i; + has_modifiers = 1; for ( i = 0; i < parse->modifiers->size; ++i ) - { - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, parse->modifiers, parse->modifiers->size - i - 1 ), c ); - } + var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, + parse->modifiers, parse->modifiers->size - i - 1 ), c ); } - /* If there's a subscript, emit it. */ + /* If there is a subscript, emit it. */ if ( parse->subscript ) - { var_parse_group_compile( parse->subscript, c ); - } /* If the variable name is empty, look it up. */ if ( parse->name->elems->size == 0 ) - { - compile_emit( c, INSTR_PUSH_VAR, compile_emit_constant( c, constant_empty ) ); - } - /* If the variable name doesn't need to be expanded, look it up. */ - else if ( parse->name->elems->size == 1 && - dynamic_array_at( VAR_PARSE *, parse->name->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) - { - OBJECT * name = ( (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, parse->name->elems, 0 ) )->s; - int idx = get_argument_index( object_str( name ) ); + compile_emit( c, INSTR_PUSH_VAR, compile_emit_constant( c, + constant_empty ) ); + /* If the variable name does not need to be expanded, look it up. */ + else if ( parse->name->elems->size == 1 && dynamic_array_at( VAR_PARSE *, + parse->name->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) + { + OBJECT * const name = ( (VAR_PARSE_STRING *)dynamic_array_at( + VAR_PARSE *, parse->name->elems, 0 ) )->s; + int const idx = get_argument_index( object_str( name ) ); if ( idx != -1 ) - { compile_emit( c, INSTR_PUSH_ARG, idx ); - } else - { compile_emit( c, INSTR_PUSH_VAR, compile_emit_constant( c, name ) ); - } } /* Otherwise, push the var names and use the group instruction. */ else @@ -1525,164 +1782,156 @@ static void var_parse_var_compile( const VAR_PARSE_VAR * parse, compiler * c ) } /** Select the instruction for expanding the variable. */ - if ( !parse->modifiers->size && !parse->subscript && !expand_name ) - { - /* Nothing to do */ - } - else if ( !parse->modifiers->size && !parse->subscript && expand_name ) - { + if ( !has_modifiers && !parse->subscript && !expand_name ) + ; + else if ( !has_modifiers && !parse->subscript && expand_name ) compile_emit( c, INSTR_PUSH_GROUP, 0 ); - } - else if ( !parse->modifiers->size && parse->subscript && !expand_name ) - { + else if ( !has_modifiers && parse->subscript && !expand_name ) compile_emit( c, INSTR_APPLY_INDEX, 0 ); - } - else if ( !parse->modifiers->size && parse->subscript && expand_name ) - { + else if ( !has_modifiers && parse->subscript && expand_name ) compile_emit( c, INSTR_APPLY_INDEX_GROUP, 0 ); - } - if ( parse->modifiers->size && !parse->subscript && !expand_name ) - { + else if ( has_modifiers && !parse->subscript && !expand_name ) compile_emit( c, INSTR_APPLY_MODIFIERS, parse->modifiers->size ); - } - else if ( parse->modifiers->size && !parse->subscript && expand_name ) - { + else if ( has_modifiers && !parse->subscript && expand_name ) compile_emit( c, INSTR_APPLY_MODIFIERS_GROUP, parse->modifiers->size ); - } - else if ( parse->modifiers->size && parse->subscript && !expand_name ) - { + else if ( has_modifiers && parse->subscript && !expand_name ) compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS, parse->modifiers->size ); - } - else if ( parse->modifiers->size && parse->subscript && expand_name ) + else if ( has_modifiers && parse->subscript && expand_name ) + compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS_GROUP, + parse->modifiers->size ); + + /* Now apply any special modifiers */ + if ( is_get_grist ) { - compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS_GROUP, parse->modifiers->size ); + compile_emit( c, INSTR_GET_GRIST, 0 ); } } -static void var_parse_string_compile( const VAR_PARSE_STRING * parse, compiler * c ) +static void var_parse_string_compile( VAR_PARSE_STRING const * parse, + compiler * c ) { - compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, parse->s ) ); + compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, parse->s ) + ); } -static void var_parse_file_compile( const VAR_PARSE_FILE * parse, compiler * c ) +static void var_parse_file_compile( VAR_PARSE_FILE const * parse, compiler * c ) { int i; for ( i = 0; i < parse->filename->size; ++i ) - { - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, parse->filename, parse->filename->size - i - 1 ), c ); - } + var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, + parse->filename, parse->filename->size - i - 1 ), c ); compile_emit( c, INSTR_APPEND_STRINGS, parse->filename->size ); for ( i = 0; i < parse->contents->size; ++i ) - { - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, parse->contents, parse->contents->size - i - 1 ), c ); - } + var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, + parse->contents, parse->contents->size - i - 1 ), c ); compile_emit( c, INSTR_WRITE_FILE, parse->contents->size ); } -static void var_parse_compile( const VAR_PARSE * parse, compiler * c ) +static void var_parse_compile( VAR_PARSE const * parse, compiler * c ) { - if( parse->type == VAR_PARSE_TYPE_VAR ) - { - var_parse_var_compile( (const VAR_PARSE_VAR *)parse, c ); - } - else if( parse->type == VAR_PARSE_TYPE_STRING ) - { - var_parse_string_compile( (const VAR_PARSE_STRING *)parse, c ); - } - else if( parse->type == VAR_PARSE_TYPE_FILE ) - { - var_parse_file_compile( (const VAR_PARSE_FILE *)parse, c ); - } - else + switch ( parse->type ) { - assert( !"Unknown var parse type." ); + case VAR_PARSE_TYPE_VAR: + var_parse_var_compile( (VAR_PARSE_VAR const *)parse, c ); + break; + + case VAR_PARSE_TYPE_STRING: + var_parse_string_compile( (VAR_PARSE_STRING const *)parse, c ); + break; + + case VAR_PARSE_TYPE_FILE: + var_parse_file_compile( (VAR_PARSE_FILE const *)parse, c ); + break; + + default: + assert( !"Unknown var parse type." ); } } -static void var_parse_group_compile( const VAR_PARSE_GROUP * parse, compiler * c ) +static void var_parse_group_compile( VAR_PARSE_GROUP const * parse, compiler * c + ) { /* Emit the elements in reverse order. */ int i; - for( i = 0; i < parse->elems->size; ++i) - { - var_parse_compile( dynamic_array_at( VAR_PARSE *, parse->elems, parse->elems->size - i - 1 ), c ); - } - /* If there're no elements, emit an empty string. */ + for ( i = 0; i < parse->elems->size; ++i ) + var_parse_compile( dynamic_array_at( VAR_PARSE *, parse->elems, + parse->elems->size - i - 1 ), c ); + /* If there are no elements, emit an empty string. */ if ( parse->elems->size == 0 ) - { - compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, constant_empty ) ); - } - /* If there's more than one element, combine them. */ + compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, + constant_empty ) ); + /* If there is more than one element, combine them. */ if ( parse->elems->size > 1 ) - { compile_emit( c, INSTR_COMBINE_STRINGS, parse->elems->size ); - } } -static void var_parse_actions_compile( const VAR_PARSE_ACTIONS * actions, compiler * c ) +static void var_parse_actions_compile( VAR_PARSE_ACTIONS const * actions, + compiler * c ) { int i; for ( i = 0; i < actions->elems->size; ++i ) - { - var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, actions->elems, actions->elems->size - i - 1 ), c ); - } + var_parse_group_compile( dynamic_array_at( VAR_PARSE_GROUP *, + actions->elems, actions->elems->size - i - 1 ), c ); compile_emit( c, INSTR_OUTPUT_STRINGS, actions->elems->size ); } + /* * Parse VAR_PARSE_VAR */ -static VAR_PARSE * parse_at_file( const char * start, const char * mid, const char * end ); -static VAR_PARSE * parse_variable( const char * * string ); -static int try_parse_variable( const char * * s_, const char * * string, VAR_PARSE_GROUP * out); -static void balance_parentheses( const char * * s_, const char * * string, VAR_PARSE_GROUP * out); -static void parse_var_string( const char * first, const char * last, struct dynamic_array * out ); +static VAR_PARSE * parse_at_file( char const * start, char const * mid, + char const * end ); +static VAR_PARSE * parse_variable( char const * * string ); +static int try_parse_variable( char const * * s_, char const * * string, + VAR_PARSE_GROUP * out ); +static void balance_parentheses( char const * * s_, char const * * string, + VAR_PARSE_GROUP * out ); +static void parse_var_string( char const * first, char const * last, + struct dynamic_array * out ); + /* * Parses a string that can contain variables to expand. */ -static VAR_PARSE_GROUP * parse_expansion( const char * * string ) +static VAR_PARSE_GROUP * parse_expansion( char const * * string ) { VAR_PARSE_GROUP * result = var_parse_group_new(); - const char * s = *string; - for (;;) + char const * s = *string; + for ( ; ; ) { - if(try_parse_variable( &s, string, result )) {} - else if(s[0] == '\0') + if ( try_parse_variable( &s, string, result ) ) {} + else if ( s[ 0 ] == '\0' ) { var_parse_group_maybe_add_constant( result, *string, s ); return result; } else - { ++s; - } } } -static VAR_PARSE_ACTIONS * parse_actions( const char * string ) +static VAR_PARSE_ACTIONS * parse_actions( char const * string ) { - VAR_PARSE_ACTIONS * result = var_parse_actions_new(); + VAR_PARSE_ACTIONS * const result = var_parse_actions_new(); parse_var_string( string, string + strlen( string ), result->elems ); return result; } /* - * Checks whether the string a *s_ starts with - * a variable expansion "$(". *string should point - * to the first unemitted character before *s. - * If *s_ starts with variable expansion, appends - * elements to out up to the closing ")", and - * adjusts *s_ and *string to point to next character. - * Returns 1 if s_ starts with a variable, 0 otherwise. + * Checks whether the string a *s_ starts with a variable expansion "$(". + * *string should point to the first unemitted character before *s. If *s_ + * starts with variable expansion, appends elements to out up to the closing + * ")", and adjusts *s_ and *string to point to next character. Returns 1 if s_ + * starts with a variable, 0 otherwise. */ -static int try_parse_variable( const char * * s_, const char * * string, VAR_PARSE_GROUP * out) +static int try_parse_variable( char const * * s_, char const * * string, + VAR_PARSE_GROUP * out ) { - const char * s = *s_; - if(s[0] == '$' && s[1] == '(') + char const * s = *s_; + if ( s[ 0 ] == '$' && s[ 1 ] == '(' ) { var_parse_group_maybe_add_constant( out, *string, s ); s += 2; @@ -1691,11 +1940,11 @@ static int try_parse_variable( const char * * s_, const char * * string, VAR_PAR *s_ = s; return 1; } - else if(s[0] == '@' && s[1] == '(') + if ( s[ 0 ] == '@' && s[ 1 ] == '(' ) { int depth = 1; - const char * ine; - const char * split = 0; + char const * ine; + char const * split = 0; var_parse_group_maybe_add_constant( out, *string, s ); s += 2; ine = s; @@ -1708,54 +1957,50 @@ static int try_parse_variable( const char * * s_, const char * * string, VAR_PAR case '(': ++depth; break; case ')': --depth; break; case ':': - if ( ( depth == 1 ) && ( ine[ 1 ] == 'E' ) && ( ine[ 2 ] == '=' ) ) + if ( ( depth == 1 ) && ( ine[ 1 ] == 'E' ) && ( ine[ 2 ] == '=' + ) ) split = ine; break; } ++ine; } - - if ( !split || depth != 0 ) - { + + if ( !split || depth ) return 0; - } - + var_parse_group_add( out, parse_at_file( s, split, ine - 1 ) ); *string = ine; *s_ = ine; - return 1; } - else - { - return 0; - } + return 0; } -static const char * current_file = ""; + +static char const * current_file = ""; static int current_line; -static void parse_error( const char * message ) +static void parse_error( char const * message ) { printf( "%s:%d: %s\n", current_file, current_line, message ); } + /* - * Parses a single variable up to the closing ")" and - * adjusts *string to point to the next character. *string - * should point to the character immediately after - * the initial "$(" + * Parses a single variable up to the closing ")" and adjusts *string to point + * to the next character. *string should point to the character immediately + * after the initial "$(". */ -static VAR_PARSE * parse_variable( const char * * string ) +static VAR_PARSE * parse_variable( char const * * string ) { - VAR_PARSE_VAR * result = var_parse_var_new(); - VAR_PARSE_GROUP * name = result->name; - const char * s = *string; + VAR_PARSE_VAR * const result = var_parse_var_new(); + VAR_PARSE_GROUP * const name = result->name; + char const * s = *string; for ( ; ; ) { if ( try_parse_variable( &s, string, name ) ) {} - else if ( s[0] == ':' ) + else if ( s[ 0 ] == ':' ) { VAR_PARSE_GROUP * mod; var_parse_group_maybe_add_constant( name, *string, s ); @@ -1765,31 +2010,29 @@ static VAR_PARSE * parse_variable( const char * * string ) for ( ; ; ) { if ( try_parse_variable( &s, string, mod ) ) {} - else if ( s[0] == ')' ) + else if ( s[ 0 ] == ')' ) { var_parse_group_maybe_add_constant( mod, *string, s ); - ++s; - *string = s; + *string = ++s; return (VAR_PARSE *)result; } - else if ( s[0] == '(' ) + else if ( s[ 0 ] == '(' ) { ++s; balance_parentheses( &s, string, mod ); } - else if ( s[0] == ':' ) + else if ( s[ 0 ] == ':' ) { var_parse_group_maybe_add_constant( mod, *string, s ); - ++s; - *string = s; + *string = ++s; mod = var_parse_var_new_modifier( result ); } - else if ( s[0] == '[' ) + else if ( s[ 0 ] == '[' ) { parse_error("unexpected subscript"); ++s; } - else if ( s[0] == '\0' ) + else if ( s[ 0 ] == '\0' ) { parse_error( "unbalanced parentheses" ); var_parse_group_maybe_add_constant( mod, *string, s ); @@ -1797,41 +2040,31 @@ static VAR_PARSE * parse_variable( const char * * string ) return (VAR_PARSE *)result; } else - { ++s; - } } } - else if ( s[0] == '[' ) + else if ( s[ 0 ] == '[' ) { VAR_PARSE_GROUP * subscript = var_parse_group_new(); result->subscript = subscript; var_parse_group_maybe_add_constant( name, *string, s ); - ++s; - *string = s; + *string = ++s; for ( ; ; ) { if ( try_parse_variable( &s, string, subscript ) ) {} - else if ( s[0] == ']' ) + else if ( s[ 0 ] == ']' ) { var_parse_group_maybe_add_constant( subscript, *string, s ); - ++s; - *string = s; - if ( s[0] == ')' || s[0] == ':' || s[0] == '\0') - { - break; - } - else - { + *string = ++s; + if ( s[ 0 ] != ')' && s[ 0 ] != ':' && s[ 0 ] != '\0' ) parse_error( "unexpected text following []" ); - break; - } + break; } - else if ( isdigit( s[0] ) || s[0] == '-' ) + else if ( isdigit( s[ 0 ] ) || s[ 0 ] == '-' ) { ++s; } - else if( s[0] == '\0' ) + else if ( s[ 0 ] == '\0' ) { parse_error( "malformed subscript" ); break; @@ -1843,19 +2076,18 @@ static VAR_PARSE * parse_variable( const char * * string ) } } } - else if ( s[0] == ')' ) + else if ( s[ 0 ] == ')' ) { var_parse_group_maybe_add_constant( name, *string, s ); - ++s; - *string = s; + *string = ++s; return (VAR_PARSE *)result; } - else if ( s[0] == '(' ) + else if ( s[ 0 ] == '(' ) { ++s; balance_parentheses( &s, string, name ); } - else if ( s[0] == '\0' ) + else if ( s[ 0 ] == '\0' ) { parse_error( "unbalanced parentheses" ); var_parse_group_maybe_add_constant( name, *string, s ); @@ -1863,64 +2095,55 @@ static VAR_PARSE * parse_variable( const char * * string ) return (VAR_PARSE *)result; } else - { ++s; - } } } -static void parse_var_string( const char * first, const char * last, struct dynamic_array * out ) +static void parse_var_string( char const * first, char const * last, + struct dynamic_array * out ) { - const char * saved = first; - for ( ; ; ) + char const * saved = first; + while ( first != last ) { - /* Handle whitespace */ - for ( ; first != last; ++first ) if ( !isspace(*first) ) break; + /* Handle whitespace. */ + while ( first != last && isspace( *first ) ) ++first; if ( saved != first ) { - VAR_PARSE_GROUP * group = var_parse_group_new(); + VAR_PARSE_GROUP * const group = var_parse_group_new(); var_parse_group_maybe_add_constant( group, saved, first ); saved = first; dynamic_array_push( out, group ); } - if ( first == last ) break; /* Handle non-whitespace */ - { VAR_PARSE_GROUP * group = var_parse_group_new(); for ( ; ; ) { - - if( first == last || isspace( *first ) ) + if ( first == last || isspace( *first ) ) { var_parse_group_maybe_add_constant( group, saved, first ); saved = first; break; } - else if ( try_parse_variable( &first, &saved, group ) ) - { + if ( try_parse_variable( &first, &saved, group ) ) assert( first <= last ); - } - else - { + else ++first; - } } dynamic_array_push( out, group ); } - if ( first == last ) break; } } /* - * start should point to the character immediately following the - * opening "@(", mid should point to the ":E=", and end should - * point to the closing ")". + * start should point to the character immediately following the opening "@(", + * mid should point to the ":E=", and end should point to the closing ")". */ -static VAR_PARSE * parse_at_file( const char * start, const char * mid, const char * end ) +static VAR_PARSE * parse_at_file( char const * start, char const * mid, + char const * end ) { VAR_PARSE_FILE * result = var_parse_file_new(); parse_var_string( start, mid, result->filename ); @@ -1929,54 +2152,51 @@ static VAR_PARSE * parse_at_file( const char * start, const char * mid, const ch } /* - * Given that *s_ points to the character after a "(", - * parses up to the matching ")". *string should - * point to the first unemitted character before *s_. + * Given that *s_ points to the character after a "(", parses up to the matching + * ")". *string should point to the first unemitted character before *s_. * - * When the function returns, *s_ will point to the character - * after the ")", and *string will point to the first - * unemitted character before *s_. The range from *string - * to *s_ does not contain any variables that need to be - * expanded. + * When the function returns, *s_ will point to the character after the ")", and + * *string will point to the first unemitted character before *s_. The range + * from *string to *s_ does not contain any variables that need to be expanded. */ -void balance_parentheses( const char * * s_, const char * * string, VAR_PARSE_GROUP * out) +void balance_parentheses( char const * * s_, char const * * string, + VAR_PARSE_GROUP * out) { int depth = 1; - const char * s = *s_; + char const * s = *s_; for ( ; ; ) { if ( try_parse_variable( &s, string, out ) ) { } - else if(s[0] == ':' || s[0] == '[') + else if ( s[ 0 ] == ':' || s[ 0 ] == '[' ) { parse_error( "unbalanced parentheses" ); ++s; } - else if(s[0] == '\0') + else if ( s[ 0 ] == '\0' ) { parse_error( "unbalanced parentheses" ); break; } - else if(s[0] == ')') + else if ( s[ 0 ] == ')' ) { ++s; - if(--depth == 0) break; + if ( --depth == 0 ) break; } - else if(s[0] == '(') + else if ( s[ 0 ] == '(' ) { ++depth; ++s; } else - { ++s; - } } *s_ = s; } + /* - * Main compile + * Main compile. */ #define RESULT_STACK 0 @@ -1991,17 +2211,15 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int assert( parse->type == PARSE_EVAL ); switch ( parse->num ) { - case EXPR_EXISTS: - { + case EXPR_EXISTS: compile_parse( parse->left, c, RESULT_STACK ); if ( branch_true ) compile_emit_branch( c, INSTR_JUMP_NOT_EMPTY, label ); else compile_emit_branch( c, INSTR_JUMP_EMPTY, label ); break; - } - case EXPR_EQUALS: - { + + case EXPR_EQUALS: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2009,9 +2227,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_NE, label ); break; - } - case EXPR_NOTEQ: - { + + case EXPR_NOTEQ: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2019,9 +2236,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_EQ, label ); break; - } - case EXPR_LESS: - { + + case EXPR_LESS: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2029,9 +2245,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_GE, label ); break; - } - case EXPR_LESSEQ: - { + + case EXPR_LESSEQ: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2039,9 +2254,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_GT, label ); break; - } - case EXPR_MORE: - { + + case EXPR_MORE: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2049,9 +2263,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_LE, label ); break; - } - case EXPR_MOREEQ: - { + + case EXPR_MOREEQ: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2059,9 +2272,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_LT, label ); break; - } - case EXPR_IN: - { + + case EXPR_IN: compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); if ( branch_true ) @@ -2069,9 +2281,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int else compile_emit_branch( c, INSTR_JUMP_NOT_IN, label ); break; - } - case EXPR_AND: - { + + case EXPR_AND: if ( branch_true ) { int f = compile_new_label( c ); @@ -2085,9 +2296,8 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int compile_condition( parse->right, c, 0, label ); } break; - } - case EXPR_OR: - { + + case EXPR_OR: if ( branch_true ) { compile_condition( parse->left, c, 1, label ); @@ -2101,24 +2311,23 @@ static void compile_condition( PARSE * parse, compiler * c, int branch_true, int compile_set_label( c, t ); } break; - } - case EXPR_NOT: - { + + case EXPR_NOT: compile_condition( parse->left, c, !branch_true, label ); break; - } } } -static void adjust_result( compiler * c, int actual_location, int desired_location ) +static void adjust_result( compiler * c, int actual_location, + int desired_location ) { if ( actual_location == desired_location ) ; else if ( actual_location == RESULT_STACK && desired_location == RESULT_RETURN ) compile_emit( c, INSTR_SET_RESULT, 0 ); - else if( actual_location == RESULT_STACK && desired_location == RESULT_NONE ) + else if ( actual_location == RESULT_STACK && desired_location == RESULT_NONE ) compile_emit( c, INSTR_POP, 0 ); - else if( actual_location == RESULT_RETURN && desired_location == RESULT_STACK ) + else if ( actual_location == RESULT_RETURN && desired_location == RESULT_STACK ) compile_emit( c, INSTR_PUSH_RESULT, 0 ); else if ( actual_location == RESULT_RETURN && desired_location == RESULT_NONE ) ; @@ -2130,12 +2339,10 @@ static void adjust_result( compiler * c, int actual_location, int desired_locati compile_emit( c, INSTR_SET_RESULT, 0 ); } else - { assert( !"invalid result location" ); - } } -static const char * parse_type( PARSE * parse ) +static char const * parse_type( PARSE * parse ) { switch ( parse->type ) { @@ -2150,9 +2357,7 @@ static void compile_append_chain( PARSE * parse, compiler * c ) { assert( parse->type == PARSE_APPEND ); if ( parse->left->type == PARSE_NULL ) - { compile_parse( parse->right, c, RESULT_STACK ); - } else { if ( parse->left->type == PARSE_APPEND ) @@ -2173,21 +2378,23 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) } else if ( parse->type == PARSE_EVAL ) { - /* FIXME: This is only needed because of the bizarre parsing of conditions. */ + /* FIXME: This is only needed because of the bizarre parsing of + * conditions. + */ if ( parse->num == EXPR_EXISTS ) - { compile_parse( parse->left, c, result_location ); - } else { int f = compile_new_label( c ); int end = compile_new_label( c ); - printf( "%s:%d: Conditional used as list (check operator precedence).\n", object_str(parse->file), parse->line ); - + printf( "%s:%d: Conditional used as list (check operator " + "precedence).\n", object_str( parse->file ), parse->line ); + /* Emit the condition */ compile_condition( parse, c, 0, f ); - compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, constant_true ) ); + compile_emit( c, INSTR_PUSH_CONSTANT, compile_emit_constant( c, + constant_true ) ); compile_emit_branch( c, INSTR_JUMP, end ); compile_set_label( c, f ); compile_emit( c, INSTR_PUSH_EMPTY, 0 ); @@ -2218,7 +2425,6 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) compile_set_label( c, top ); compile_emit_branch( c, INSTR_FOR_LOOP, end ); compile_emit( c, INSTR_SET, var ); - compile_emit( c, INSTR_POP, 0 ); /* Run the loop body */ compile_parse( parse->right, c, RESULT_NONE ); @@ -2227,13 +2433,11 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) compile_set_label( c, end ); if ( parse->num ) - { compile_emit( c, INSTR_POP_LOCAL, var ); - } adjust_result( c, RESULT_NONE, result_location); } - else if( parse->type == PARSE_IF ) + else if ( parse->type == PARSE_IF ) { int f = compile_new_label( c ); /* Emit the condition */ @@ -2250,24 +2454,25 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) compile_set_label( c, end ); } else - { compile_set_label( c, f ); - } } - else if( parse->type == PARSE_WHILE ) + else if ( parse->type == PARSE_WHILE ) { - int nested_result = result_location == RESULT_NONE? RESULT_NONE : RESULT_RETURN; + int nested_result = result_location == RESULT_NONE + ? RESULT_NONE + : RESULT_RETURN; int test = compile_new_label( c ); int top = compile_new_label( c ); - /* Make sure that we return an empty list if the loop runs zero times. */ + /* Make sure that we return an empty list if the loop runs zero times. + */ adjust_result( c, RESULT_NONE, nested_result ); - /* Jump to the loop test */ + /* Jump to the loop test. */ compile_emit_branch( c, INSTR_JUMP, test ); compile_set_label( c, top ); - /* Emit the loop body */ + /* Emit the loop body. */ compile_parse( parse->right, c, nested_result ); - /* Emit the condition */ + /* Emit the condition. */ compile_set_label( c, test ); compile_condition( parse->left, c, 1, top ); @@ -2282,7 +2487,9 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) } else if ( parse->type == PARSE_MODULE ) { - int nested_result = result_location == RESULT_NONE? RESULT_NONE : RESULT_RETURN; + int const nested_result = result_location == RESULT_NONE + ? RESULT_NONE + : RESULT_RETURN; compile_parse( parse->left, c, RESULT_STACK ); compile_emit( c, INSTR_PUSH_MODULE, 0 ); compile_parse( parse->right, c, nested_result ); @@ -2295,13 +2502,9 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) compile_parse( parse->left->right, c, RESULT_STACK ); /* Evaluate the base classes. */ if ( parse->left->left ) - { compile_parse( parse->left->left->right, c, RESULT_STACK ); - } else - { compile_emit( c, INSTR_PUSH_EMPTY, 0 ); - } compile_emit( c, INSTR_CLASS, 0 ); compile_parse( parse->right, c, RESULT_NONE ); compile_emit( c, INSTR_BIND_MODULE_VARIABLES, 0 ); @@ -2311,8 +2514,8 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) } else if ( parse->type == PARSE_LIST ) { - OBJECT * o = parse->string; - const char * s = object_str( o ); + OBJECT * const o = parse->string; + char const * s = object_str( o ); VAR_PARSE_GROUP * group; current_file = object_str( parse->file ); current_line = parse->line; @@ -2323,10 +2526,10 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) } else if ( parse->type == PARSE_LOCAL ) { - int nested_result = result_location == RESULT_NONE? RESULT_NONE : RESULT_RETURN; - /* - * This should be left recursive group of compile_appends - */ + int nested_result = result_location == RESULT_NONE + ? RESULT_NONE + : RESULT_RETURN; + /* This should be left recursive group of compile_appends. */ PARSE * vars = parse->left; /* Special case an empty list of vars */ @@ -2336,22 +2539,21 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) compile_parse( parse->third, c, result_location ); nested_result = result_location; } - /* - * Check whether there is exactly one variable - * with a constant name - */ + /* Check whether there is exactly one variable with a constant name. */ else if ( vars->left->type == PARSE_NULL && vars->right->type == PARSE_LIST ) { - const char * s = object_str( vars->right->string ); + char const * s = object_str( vars->right->string ); VAR_PARSE_GROUP * group; current_file = object_str( parse->file ); current_line = parse->line; group = parse_expansion( &s ); - if ( group->elems->size == 1 && - dynamic_array_at( VAR_PARSE *, group->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) + if ( group->elems->size == 1 && dynamic_array_at( VAR_PARSE *, + group->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) { - int name = compile_emit_constant( c, ( (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, group->elems, 0 ) )->s ); + int const name = compile_emit_constant( c, ( + (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, + group->elems, 0 ) )->s ); var_parse_group_free( group ); compile_parse( parse->right, c, RESULT_STACK ); compile_emit( c, INSTR_PUSH_LOCAL, name ); @@ -2380,12 +2582,62 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) } else if ( parse->type == PARSE_ON ) { - int end = compile_new_label( c ); - compile_parse( parse->left, c, RESULT_STACK ); - compile_emit_branch( c, INSTR_PUSH_ON, end ); - compile_parse( parse->right, c, RESULT_STACK ); - compile_emit( c, INSTR_POP_ON, 0 ); - compile_set_label( c, end ); + if ( parse->right->type == PARSE_APPEND && + parse->right->left->type == PARSE_NULL && + parse->right->right->type == PARSE_LIST ) + { + /* [ on $(target) return $(variable) ] */ + PARSE * value = parse->right->right; + OBJECT * const o = value->string; + char const * s = object_str( o ); + VAR_PARSE_GROUP * group; + OBJECT * varname = 0; + current_file = object_str( value->file ); + current_line = value->line; + group = parse_expansion( &s ); + if ( group->elems->size == 1 ) + { + VAR_PARSE * one = dynamic_array_at( VAR_PARSE *, group->elems, 0 ); + if ( one->type == VAR_PARSE_TYPE_VAR ) + { + VAR_PARSE_VAR * var = ( VAR_PARSE_VAR * )one; + if ( var->modifiers->size == 0 && !var->subscript && var->name->elems->size == 1 ) + { + VAR_PARSE * name = dynamic_array_at( VAR_PARSE *, var->name->elems, 0 ); + if ( name->type == VAR_PARSE_TYPE_STRING ) + { + varname = ( ( VAR_PARSE_STRING * )name )->s; + } + } + } + } + if ( varname ) + { + /* We have one variable with a fixed name and no modifiers. */ + compile_parse( parse->left, c, RESULT_STACK ); + compile_emit( c, INSTR_GET_ON, compile_emit_constant( c, varname ) ); + } + else + { + /* Too complex. Fall back on push/pop. */ + int end = compile_new_label( c ); + compile_parse( parse->left, c, RESULT_STACK ); + compile_emit_branch( c, INSTR_PUSH_ON, end ); + var_parse_group_compile( group, c ); + compile_emit( c, INSTR_POP_ON, 0 ); + compile_set_label( c, end ); + } + var_parse_group_free( group ); + } + else + { + int end = compile_new_label( c ); + compile_parse( parse->left, c, RESULT_STACK ); + compile_emit_branch( c, INSTR_PUSH_ON, end ); + compile_parse( parse->right, c, RESULT_STACK ); + compile_emit( c, INSTR_POP_ON, 0 ); + compile_set_label( c, end ); + } adjust_result( c, RESULT_STACK, result_location ); } else if ( parse->type == PARSE_RULE ) @@ -2393,24 +2645,41 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) PARSE * p; int n = 0; VAR_PARSE_GROUP * group; - const char * s = object_str( parse->string ); + char const * s = object_str( parse->string ); - if ( parse->left->left == NULL && parse->left->right->type == PARSE_NULL ) - ; - else + if ( parse->left->left || parse->left->right->type != PARSE_NULL ) for ( p = parse->left; p; p = p->left ) { compile_parse( p->right, c, RESULT_STACK ); ++n; } - + current_file = object_str( parse->file ); current_line = parse->line; group = parse_expansion( &s ); - var_parse_group_compile( group, c ); - var_parse_group_free( group ); - compile_emit( c, INSTR_CALL_RULE, n ); - compile_emit( c, compile_emit_constant( c, parse->string ), parse->line ); + + if ( group->elems->size == 2 && + dynamic_array_at( VAR_PARSE *, group->elems, 0 )->type == VAR_PARSE_TYPE_VAR && + dynamic_array_at( VAR_PARSE *, group->elems, 1 )->type == VAR_PARSE_TYPE_STRING && + ( object_str( ( (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, group->elems, 1 ) )->s )[ 0 ] == '.' ) ) + { + VAR_PARSE_STRING * access = (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, group->elems, 1 ); + OBJECT * member = object_new( object_str( access->s ) + 1 ); + /* Emit the object */ + var_parse_var_compile( (VAR_PARSE_VAR *)dynamic_array_at( VAR_PARSE *, group->elems, 0 ), c ); + var_parse_group_free( group ); + compile_emit( c, INSTR_CALL_MEMBER_RULE, n ); + compile_emit( c, compile_emit_constant( c, member ), parse->line ); + object_free( member ); + } + else + { + var_parse_group_compile( group, c ); + var_parse_group_free( group ); + compile_emit( c, INSTR_CALL_RULE, n ); + compile_emit( c, compile_emit_constant( c, parse->string ), parse->line ); + } + adjust_result( c, RESULT_STACK, result_location ); } else if ( parse->type == PARSE_RULES ) @@ -2427,28 +2696,31 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) switch ( parse->num ) { - case ASSIGN_SET: default: op_code = INSTR_SET; op_code_group = INSTR_SET_GROUP; break; case ASSIGN_APPEND: op_code = INSTR_APPEND; op_code_group = INSTR_APPEND_GROUP; break; case ASSIGN_DEFAULT: op_code = INSTR_DEFAULT; op_code_group = INSTR_DEFAULT_GROUP; break; + default: op_code = INSTR_SET; op_code_group = INSTR_SET_GROUP; break; } - /* - * Check whether there is exactly one variable - * with a constant name - */ + /* Check whether there is exactly one variable with a constant name. */ if ( vars->type == PARSE_LIST ) { - const char * s = object_str( vars->string ); + char const * s = object_str( vars->string ); VAR_PARSE_GROUP * group; current_file = object_str( parse->file ); current_line = parse->line; group = parse_expansion( &s ); - if ( group->elems->size == 1 && - dynamic_array_at( VAR_PARSE *, group->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) + if ( group->elems->size == 1 && dynamic_array_at( VAR_PARSE *, + group->elems, 0 )->type == VAR_PARSE_TYPE_STRING ) { - int name = compile_emit_constant( c, ( (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, group->elems, 0 ) )->s ); + int const name = compile_emit_constant( c, ( + (VAR_PARSE_STRING *)dynamic_array_at( VAR_PARSE *, + group->elems, 0 ) )->s ); var_parse_group_free( group ); compile_parse( parse->right, c, RESULT_STACK ); + if ( result_location != RESULT_NONE ) + { + compile_emit( c, INSTR_SET_RESULT, 1 ); + } compile_emit( c, op_code, name ); } else @@ -2456,6 +2728,10 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) var_parse_group_compile( group, c ); var_parse_group_free( group ); compile_parse( parse->right, c, RESULT_STACK ); + if ( result_location != RESULT_NONE ) + { + compile_emit( c, INSTR_SET_RESULT, 1 ); + } compile_emit( c, op_code_group, 0 ); } } @@ -2463,26 +2739,30 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) { compile_parse( parse->left, c, RESULT_STACK ); compile_parse( parse->right, c, RESULT_STACK ); + if ( result_location != RESULT_NONE ) + { + compile_emit( c, INSTR_SET_RESULT, 1 ); + } compile_emit( c, op_code_group, 0 ); } - adjust_result( c, RESULT_STACK, result_location ); + if ( result_location != RESULT_NONE ) + { + adjust_result( c, RESULT_RETURN, result_location ); + } } else if ( parse->type == PARSE_SETCOMP ) { int n_args; struct arg_list * args = arg_list_compile( parse->right, &n_args ); - - int rule_id = compile_emit_rule( c, parse->string, parse->left, n_args, args, parse->num ); - + int const rule_id = compile_emit_rule( c, parse->string, parse->left, + n_args, args, parse->num ); compile_emit( c, INSTR_RULE, rule_id ); adjust_result( c, RESULT_NONE, result_location ); } else if ( parse->type == PARSE_SETEXEC ) { - int actions_id = compile_emit_actions( c, parse ); - + int const actions_id = compile_emit_actions( c, parse ); compile_parse( parse->left, c, RESULT_STACK ); - compile_emit( c, INSTR_ACTIONS, actions_id ); adjust_result( c, RESULT_NONE, result_location ); } @@ -2494,22 +2774,22 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) switch ( parse->num ) { - case ASSIGN_SET: default: compile_emit( c, INSTR_SET_ON, 0 ); break; case ASSIGN_APPEND: compile_emit( c, INSTR_APPEND_ON, 0 ); break; case ASSIGN_DEFAULT: compile_emit( c, INSTR_DEFAULT_ON, 0 ); break; + default: compile_emit( c, INSTR_SET_ON, 0 ); break; } adjust_result( c, RESULT_STACK, result_location ); } - else if ( parse->type == PARSE_SWITCH ) + else if ( parse->type == PARSE_SWITCH ) { - int switch_end = compile_new_label( c ); + int const switch_end = compile_new_label( c ); compile_parse( parse->left, c, RESULT_STACK ); for ( parse = parse->right; parse; parse = parse->right ) { - int id = compile_emit_constant( c, parse->left->string ); - int next_case = compile_new_label( c ); + int const id = compile_emit_constant( c, parse->left->string ); + int const next_case = compile_new_label( c ); compile_emit( c, INSTR_PUSH_CONSTANT, id ); compile_emit_branch( c, INSTR_JUMP_NOT_GLOB, next_case ); compile_parse( parse->left->left, c, result_location ); @@ -2521,13 +2801,9 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) compile_set_label( c, switch_end ); } else if ( parse->type == PARSE_NULL ) - { adjust_result( c, RESULT_NONE, result_location ); - } else - { assert( !"unknown PARSE type." ); - } } OBJECT * function_rulename( FUNCTION * function ) @@ -2563,15 +2839,18 @@ void function_location( FUNCTION * function_, OBJECT * * file, int * line ) } } -static struct arg_list * arg_list_compile_builtin( const char * * args, int * num_arguments ); +static struct arg_list * arg_list_compile_builtin( char const * * args, + int * num_arguments ); -FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int flags ), int flags, const char * * args ) +FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int flags ), + int flags, char const * * args ) { BUILTIN_FUNCTION * result = BJAM_MALLOC( sizeof( BUILTIN_FUNCTION ) ); result->base.type = FUNCTION_BUILTIN; result->base.reference_count = 1; result->base.rulename = 0; - result->base.formal_arguments = arg_list_compile_builtin( args, &result->base.num_formal_arguments ); + result->base.formal_arguments = arg_list_compile_builtin( args, + &result->base.num_formal_arguments ); result->func = func; result->flags = flags; return (FUNCTION *)result; @@ -2579,7 +2858,7 @@ FUNCTION * function_builtin( LIST * ( * func )( FRAME * frame, int flags ), int FUNCTION * function_compile( PARSE * parse ) { - compiler c[1]; + compiler c[ 1 ]; JAM_FUNCTION * result; compiler_init( c ); compile_parse( parse, c, RESULT_RETURN ); @@ -2591,9 +2870,10 @@ FUNCTION * function_compile( PARSE * parse ) return (FUNCTION *)result; } -FUNCTION * function_compile_actions( const char * actions, OBJECT * file, int line ) +FUNCTION * function_compile_actions( char const * actions, OBJECT * file, + int line ) { - compiler c[1]; + compiler c[ 1 ]; JAM_FUNCTION * result; VAR_PARSE_ACTIONS * parse; current_file = object_str( file ); @@ -2624,18 +2904,21 @@ static void argument_list_print( struct arg_list * args, int num_args ); * specification. */ -int is_type_name( const char * s ) +int is_type_name( char const * s ) { - return ( s[ 0 ] == TYPE_OPEN_DELIM ) && - ( s[ strlen( s ) - 1 ] == TYPE_CLOSE_DELIM ); + return s[ 0 ] == TYPE_OPEN_DELIM && s[ strlen( s ) - 1 ] == + TYPE_CLOSE_DELIM; } -static void argument_error( const char * message, FUNCTION * procedure, FRAME * frame, OBJECT * arg ) -{ extern void print_source_line( FRAME * ); +static void argument_error( char const * message, FUNCTION * procedure, + FRAME * frame, OBJECT * arg ) +{ + extern void print_source_line( FRAME * ); LOL * actual = frame->args; backtrace_line( frame->prev ); printf( "*** argument error\n* rule %s ( ", frame->rulename ); - argument_list_print( procedure->formal_arguments, procedure->num_formal_arguments ); + argument_list_print( procedure->formal_arguments, + procedure->num_formal_arguments ); printf( " )\n* called with: ( " ); lol_print( actual ); printf( " )\n* %s %s\n", message, arg ? object_str ( arg ) : "" ); @@ -2646,15 +2929,8 @@ static void argument_error( const char * message, FUNCTION * procedure, FRAME * exit( 1 ); } -static void type_check_range -( - OBJECT * type_name, - LISTITER iter, - LISTITER end, - FRAME * caller, - FUNCTION * called, - OBJECT * arg_name -) +static void type_check_range( OBJECT * type_name, LISTITER iter, LISTITER end, + FRAME * caller, FUNCTION * called, OBJECT * arg_name ) { static module_t * typecheck = 0; @@ -2663,9 +2939,7 @@ static void type_check_range return; if ( !typecheck ) - { typecheck = bindmodule( constant_typecheck ); - } /* If the checking rule can not be found, also bail. */ if ( !typecheck->rules || !hash_find( typecheck->rules, type_name ) ) @@ -2673,56 +2947,60 @@ static void type_check_range for ( ; iter != end; iter = list_next( iter ) ) { - LIST *error; - FRAME frame[1]; + 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; + frame->prev_user = caller->module->user_module + ? caller + : caller->prev_user; /* Prepare the argument list */ lol_add( frame->args, list_new( object_copy( list_item( iter ) ) ) ); - error = evaluate_rule( type_name, frame ); + error = evaluate_rule( bindrule( type_name, frame->module ), type_name, frame ); if ( !list_empty( error ) ) - argument_error( object_str( list_front( error ) ), called, caller, arg_name ); + argument_error( object_str( list_front( error ) ), called, caller, + arg_name ); frame_free( frame ); } } -static void type_check -( - OBJECT * type_name, - LIST * values, - FRAME * caller, - FUNCTION * called, - OBJECT * arg_name -) +static void type_check( OBJECT * type_name, LIST * values, FRAME * caller, + FUNCTION * called, OBJECT * arg_name ) { - type_check_range( type_name, list_begin( values ), list_end( values ), caller, called, arg_name ); + type_check_range( type_name, list_begin( values ), list_end( values ), + caller, called, arg_name ); } -void argument_list_check( struct arg_list * formal, int formal_count, FUNCTION * function, FRAME * frame ) +void argument_list_check( struct arg_list * formal, int formal_count, + FUNCTION * function, FRAME * frame ) { LOL * all_actual = frame->args; - int i, j; + int i; 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 ) + LIST * actual = lol_get( all_actual, i ); + LISTITER actual_iter = list_begin( actual ); + LISTITER const actual_end = list_end( actual ); + int j; + for ( j = 0; j < formal[ i ].size; ++j ) { - struct argument * formal_arg = &formal[i].args[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", function, frame, formal_arg->arg_name ); - type_check_range( formal_arg->type_name, actual_iter, list_next( actual_iter ), frame, function, formal_arg->arg_name ); + argument_error( "missing argument", function, frame, + formal_arg->arg_name ); + type_check_range( formal_arg->type_name, actual_iter, + list_next( actual_iter ), frame, function, + formal_arg->arg_name ); actual_iter = list_next( actual_iter ); break; case ARG_OPTIONAL: @@ -2730,16 +3008,20 @@ void argument_list_check( struct arg_list * formal, int formal_count, FUNCTION * value = L0; else { - type_check_range( formal_arg->type_name, actual_iter, list_next( actual_iter ), frame, function, formal_arg->arg_name ); + type_check_range( formal_arg->type_name, actual_iter, + list_next( actual_iter ), frame, function, + formal_arg->arg_name ); actual_iter = list_next( actual_iter ); } break; case ARG_PLUS: if ( actual_iter == actual_end ) - argument_error( "missing argument", function, frame, formal_arg->arg_name ); + argument_error( "missing argument", function, frame, + formal_arg->arg_name ); /* fallthrough */ case ARG_STAR: - type_check_range( formal_arg->type_name, actual_iter, actual_end, frame, function, formal_arg->arg_name ); + type_check_range( formal_arg->type_name, actual_iter, + actual_end, frame, function, formal_arg->arg_name ); actual_iter = actual_end; break; case ARG_VARIADIC: @@ -2748,40 +3030,42 @@ void argument_list_check( struct arg_list * formal, int formal_count, FUNCTION * } if ( actual_iter != actual_end ) - { - argument_error( "extra argument", function, frame, list_item( actual_iter ) ); - } + argument_error( "extra argument", function, 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", function, frame, list_front( actual ) ); - } + argument_error( "extra argument", function, frame, list_front( + actual ) ); } } -void argument_list_push( struct arg_list * formal, int formal_count, FUNCTION * function, FRAME * frame, STACK * s ) +void argument_list_push( struct arg_list * formal, int formal_count, + FUNCTION * function, FRAME * frame, STACK * s ) { LOL * all_actual = frame->args; - int i, j; + int i; 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 ) + LIST * actual = lol_get( all_actual, i ); + LISTITER actual_iter = list_begin( actual ); + LISTITER const actual_end = list_end( actual ); + int j; + for ( j = 0; j < formal[ i ].size; ++j ) { - struct argument * formal_arg = &formal[i].args[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", function, frame, formal_arg->arg_name ); + argument_error( "missing argument", function, frame, + formal_arg->arg_name ); value = list_new( object_copy( list_item( actual_iter ) ) ); actual_iter = list_next( actual_iter ); break; @@ -2796,7 +3080,8 @@ void argument_list_push( struct arg_list * formal, int formal_count, FUNCTION * break; case ARG_PLUS: if ( actual_iter == actual_end ) - argument_error( "missing argument", function, frame, formal_arg->arg_name ); + argument_error( "missing argument", function, frame, + formal_arg->arg_name ); /* fallthrough */ case ARG_STAR: value = list_copy_range( actual, actual_iter, actual_end ); @@ -2806,61 +3091,59 @@ void argument_list_push( struct arg_list * formal, int formal_count, FUNCTION * return; } - type_check( formal_arg->type_name, value, frame, function, formal_arg->arg_name ); + type_check( formal_arg->type_name, value, frame, function, + formal_arg->arg_name ); if ( formal_arg->index != -1 ) { - LIST * * old = &frame->module->fixed_variables[ formal_arg->index ]; + LIST * * const 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 ) ); - } + stack_push( s, var_swap( frame->module, formal_arg->arg_name, + value ) ); } if ( actual_iter != actual_end ) - { - argument_error( "extra argument", function, frame, list_item( actual_iter ) ); - } + argument_error( "extra argument", function, frame, list_item( + actual_iter ) ); } for ( ; i < all_actual->count; ++i ) { - LIST * actual = lol_get( all_actual, i ); + LIST * const actual = lol_get( all_actual, i ); if ( !list_empty( actual ) ) - { - argument_error( "extra argument", function, frame, list_front( actual ) ); - } + argument_error( "extra argument", function, frame, list_front( + actual ) ); } } -void argument_list_pop( struct arg_list * formal, int formal_count, FRAME * frame, STACK * s ) +void argument_list_pop( struct arg_list * formal, int formal_count, + FRAME * frame, STACK * s ) { - int i, j; - + int i; for ( i = formal_count - 1; i >= 0; --i ) { - for ( j = formal[i].size - 1; j >= 0 ; --j ) + int j; + for ( j = formal[ i ].size - 1; j >= 0 ; --j ) { - struct argument * formal_arg = &formal[i].args[j]; + struct argument * formal_arg = &formal[ i ].args[ j ]; if ( formal_arg->flags == ARG_VARIADIC ) - { continue; - } - else if ( formal_arg->index != -1 ) + if ( formal_arg->index != -1 ) { - LIST * old = stack_pop( s ); - LIST * * pos = &frame->module->fixed_variables[ formal_arg->index ]; + LIST * const old = stack_pop( s ); + LIST * * const 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 ); - } + var_set( frame->module, formal_arg->arg_name, stack_pop( s ), + VAR_SET ); } } } @@ -2889,7 +3172,8 @@ static void argument_compiler_free( struct argument_compiler * c ) dynamic_array_free( c->args ); } -static void argument_compiler_add( struct argument_compiler * c, OBJECT * arg, OBJECT * file, int line ) +static void argument_compiler_add( struct argument_compiler * c, OBJECT * arg, + OBJECT * file, int line ) { switch ( c->state ) { @@ -2930,13 +3214,14 @@ static void argument_compiler_add( struct argument_compiler * c, OBJECT * arg, O /* fall-through */ case ARGUMENT_COMPILER_FOUND_TYPE: - + if ( is_type_name( object_str( arg ) ) ) { - printf( "%s:%d: missing argument name before type name: %s\n", object_str( file ), line, object_str( arg ) ); + printf( "%s:%d: missing argument name before type name: %s\n", + object_str( file ), line, object_str( arg ) ); exit( 1 ); } - + c->arg.arg_name = object_copy( arg ); if ( object_equal( arg, constant_star ) ) { @@ -2955,7 +3240,8 @@ static void argument_compiler_add( struct argument_compiler * c, OBJECT * arg, O } } -static void argument_compiler_recurse( struct argument_compiler * c, PARSE * parse ) +static void argument_compiler_recurse( struct argument_compiler * c, + PARSE * parse ) { if ( parse->type == PARSE_APPEND ) { @@ -2969,7 +3255,8 @@ static void argument_compiler_recurse( struct argument_compiler * c, PARSE * par } } -static struct arg_list arg_compile_impl( struct argument_compiler * c, OBJECT * file, int line ) +static struct arg_list arg_compile_impl( struct argument_compiler * c, + OBJECT * file, int line ) { struct arg_list result; switch ( c->state ) @@ -2978,7 +3265,8 @@ static struct arg_list arg_compile_impl( struct argument_compiler * c, OBJECT * case ARGUMENT_COMPILER_DONE: break; case ARGUMENT_COMPILER_FOUND_TYPE: - printf( "%s:%d: missing argument name after type name: %s\n", object_str( file ), line, object_str( c->arg.type_name ) ); + printf( "%s:%d: missing argument name after type name: %s\n", + object_str( file ), line, object_str( c->arg.type_name ) ); exit( 1 ); case ARGUMENT_COMPILER_FOUND_OBJECT: dynamic_array_push( c->args, c->arg ); @@ -2986,7 +3274,8 @@ static struct arg_list arg_compile_impl( struct argument_compiler * c, OBJECT * } result.size = c->args->size; result.args = BJAM_MALLOC( c->args->size * sizeof( struct argument ) ); - memcpy( result.args, c->args->data, c->args->size * sizeof( struct argument ) ); + memcpy( result.args, c->args->data, c->args->size * sizeof( struct argument + ) ); return result; } @@ -3016,13 +3305,15 @@ static void argument_list_compiler_free( struct argument_list_compiler * c ) dynamic_array_free( c->args ); } -static void argument_list_compiler_add( struct argument_list_compiler * c, PARSE * parse ) +static void argument_list_compiler_add( struct argument_list_compiler * c, + PARSE * parse ) { struct arg_list args = arg_compile( parse ); dynamic_array_push( c->args, args ); } -static void argument_list_compiler_recurse( struct argument_list_compiler * c, PARSE * parse ) +static void argument_list_compiler_recurse( struct argument_list_compiler * c, + PARSE * parse ) { if ( parse ) { @@ -3041,18 +3332,17 @@ static struct arg_list * arg_list_compile( PARSE * parse, int * num_arguments ) argument_list_compiler_recurse( c, parse ); *num_arguments = c->args->size; result = BJAM_MALLOC( c->args->size * sizeof( struct arg_list ) ); - memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) ); + memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) + ); argument_list_compiler_free( c ); return result; } - else - { - *num_arguments = 0; - return 0; - } + *num_arguments = 0; + return 0; } -static struct arg_list * arg_list_compile_builtin( const char * * args, int * num_arguments ) +static struct arg_list * arg_list_compile_builtin( char const * * args, + int * num_arguments ) { if ( args ) { @@ -3082,32 +3372,32 @@ static struct arg_list * arg_list_compile_builtin( const char * * args, int * nu } *num_arguments = c->args->size; result = BJAM_MALLOC( c->args->size * sizeof( struct arg_list ) ); - memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) ); + memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) + ); argument_list_compiler_free( c ); return result; } - else - { - *num_arguments = 0; - return 0; - } + *num_arguments = 0; + return 0; } static void argument_list_print( struct arg_list * args, int num_args ) { if ( args ) { - int i, j; + int i; for ( i = 0; i < num_args; ++i ) { - if ( i ) printf(" : "); + int j; + if ( i ) printf( " : " ); for ( j = 0; j < args[ i ].size; ++j ) { struct argument * formal_arg = &args[ i ].args[ j ]; if ( j ) printf( " " ); - if ( formal_arg->type_name ) printf( "%s ", object_str( formal_arg->type_name ) ); - printf( "%s", formal_arg->arg_name ); - switch( formal_arg->flags ) + if ( formal_arg->type_name ) + printf( "%s ", object_str( formal_arg->type_name ) ); + printf( "%s", object_str( formal_arg->arg_name ) ); + switch ( formal_arg->flags ) { case ARG_OPTIONAL: printf( " ?" ); break; case ARG_PLUS: printf( " +" ); break; @@ -3119,16 +3409,20 @@ static void argument_list_print( struct arg_list * args, int num_args ) } -struct arg_list * argument_list_bind_variables( struct arg_list * formal, int formal_count, module_t * module, int * counter ) +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; + struct arg_list * result = (struct arg_list *)BJAM_MALLOC( sizeof( + struct arg_list ) * formal_count ); + int i; for ( i = 0; i < formal_count; ++i ) { - struct argument * args = (struct argument *)BJAM_MALLOC( sizeof( struct argument ) * formal[ i ].size ); + int j; + 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 ]; @@ -3136,28 +3430,25 @@ struct arg_list * argument_list_bind_variables( struct arg_list * formal, int fo args[ j ].type_name = object_copy( args[ j ].type_name ); args[ j ].arg_name = object_copy( args[ j ].arg_name ); if ( args[ j ].flags != ARG_VARIADIC ) - { - args[ j ].index = module_add_fixed_var( module, args[ j ].arg_name, counter ); - } + 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; - } + return 0; } void argument_list_free( struct arg_list * args, int args_count ) { - int i, j; + int i; for ( i = 0; i < args_count; ++i ) { + int j; for ( j = 0; j < args[ i ].size; ++j ) { if ( args[ i ].args[ j ].type_name ) @@ -3174,38 +3465,26 @@ 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; + JAM_FUNCTION * const func = (JAM_FUNCTION *)f; + return func->generic ? func->generic : f; } #ifdef HAVE_PYTHON - else if ( f->type == FUNCTION_PYTHON ) - { + if ( f->type == FUNCTION_PYTHON ) return f; - } #endif - else - { - assert( f->type == FUNCTION_BUILTIN ); - return f; - } + assert( f->type == FUNCTION_BUILTIN ); + return f; } -FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * counter ) +FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, + int * counter ) { if ( f->type == FUNCTION_BUILTIN ) - { return f; - } #ifdef HAVE_PYTHON - else if ( f->type == FUNCTION_PYTHON ) - { + if ( f->type == FUNCTION_PYTHON ) return f; - } #endif - else { JAM_FUNCTION * func = (JAM_FUNCTION *)f; JAM_FUNCTION * new_func = BJAM_MALLOC( sizeof( JAM_FUNCTION ) ); @@ -3214,9 +3493,11 @@ FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * count assert( f->type == FUNCTION_JAM ); 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->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 ) ); + memcpy( new_func->code, func->code, func->code_size * sizeof( + instruction ) ); new_func->generic = (FUNCTION *)func; func = new_func; for ( i = 0; ; ++i ) @@ -3233,6 +3514,7 @@ FUNCTION * function_bind_variables( FUNCTION * f, module_t * module, int * count 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_MEMBER_RULE: case INSTR_CALL_RULE: ++i; continue; case INSTR_PUSH_MODULE: { @@ -3283,9 +3565,12 @@ void function_free( FUNCTION * function_ ) { int i; - if ( --function_->reference_count != 0 ) return; - - if ( function_->formal_arguments ) argument_list_free( function_->formal_arguments, function_->num_formal_arguments ); + if ( --function_->reference_count != 0 ) + return; + + if ( function_->formal_arguments ) + argument_list_free( function_->formal_arguments, + function_->num_formal_arguments ); if ( function_->type == FUNCTION_JAM ) { @@ -3300,22 +3585,20 @@ void function_free( FUNCTION * function_ ) if ( function_->rulename ) object_free( function_->rulename ); for ( i = 0; i < func->num_constants; ++i ) - { - object_free( func->constants[i] ); - } + object_free( func->constants[ i ] ); BJAM_FREE( func->constants ); for ( i = 0; i < func->num_subfunctions; ++i ) { - object_free( func->functions[i].name ); - function_free( func->functions[i].code ); + 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 ); + object_free( func->actions[ i ].name ); + function_free( func->actions[ i ].command ); } BJAM_FREE( func->actions ); @@ -3360,7 +3643,8 @@ static char check_align_expansion_item[ sizeof(struct align_expansion_item) <= s static char check_ptr_size1[ sizeof(LIST *) <= sizeof(void *) ? 1 : -1 ]; static char check_ptr_size2[ sizeof(char *) <= sizeof(void *) ? 1 : -1 ]; -void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s, string * out ) +void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s, + string * out ) { *(string * *)stack_allocate( s, sizeof( string * ) ) = out; list_free( function_run( function, frame, s ) ); @@ -3368,9 +3652,8 @@ void function_run_actions( FUNCTION * function, FRAME * frame, STACK * s, string } /* - * WARNING: The instruction set is tuned for Jam and - * is not really generic. Be especially careful about - * stack push/pop. + * WARNING: The instruction set is tuned for Jam and is not really generic. Be + * especially careful about stack push/pop. */ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) @@ -3384,26 +3667,26 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) if ( function_->type == FUNCTION_BUILTIN ) { - BUILTIN_FUNCTION * f = (BUILTIN_FUNCTION *)function_; + BUILTIN_FUNCTION const * const f = (BUILTIN_FUNCTION *)function_; if ( function_->formal_arguments ) - argument_list_check( function_->formal_arguments, function_->num_formal_arguments, function_, frame ); + argument_list_check( function_->formal_arguments, + function_->num_formal_arguments, function_, frame ); return f->func( frame, f->flags ); } #ifdef HAVE_PYTHON - else if ( function_->type == FUNCTION_PYTHON ) { PYTHON_FUNCTION * f = (PYTHON_FUNCTION *)function_; return call_python_function( f, frame ); } - #endif assert( function_->type == FUNCTION_JAM ); - + if ( function_->formal_arguments ) - argument_list_push( function_->formal_arguments, function_->num_formal_arguments, function_, frame, s ); + argument_list_push( function_->formal_arguments, + function_->num_formal_arguments, function_, frame, s ); function = (JAM_FUNCTION *)function_; code = function->code; @@ -3417,10 +3700,8 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) */ case INSTR_PUSH_EMPTY: - { stack_push( s, L0 ); break; - } case INSTR_PUSH_CONSTANT: { @@ -3430,184 +3711,149 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) } case INSTR_PUSH_ARG: - { stack_push( s, frame_get_local( frame, code->arg ) ); break; - } case INSTR_PUSH_VAR: - { stack_push( s, function_get_variable( function, frame, code->arg ) ); break; - } case INSTR_PUSH_VAR_FIXED: - { - stack_push( s, list_copy( frame->module->fixed_variables[ code->arg ] ) ); + stack_push( s, list_copy( frame->module->fixed_variables[ code->arg + ] ) ); break; - } case INSTR_PUSH_GROUP: { LIST * value = L0; - LISTITER iter, end; + LISTITER iter; + LISTITER end; l = stack_pop( s ); - for ( iter = list_begin( l ), end = list_end( l ); iter != end; iter = list_next( iter ) ) - { - LIST * one = function_get_named_variable( function, frame, list_item( iter ) ); - value = list_append( value, one ); - } + for ( iter = list_begin( l ), end = list_end( l ); iter != end; + iter = list_next( iter ) ) + value = list_append( value, function_get_named_variable( + function, frame, list_item( iter ) ) ); list_free( l ); stack_push( s, value ); break; } case INSTR_PUSH_APPEND: - { r = stack_pop( s ); l = stack_pop( s ); stack_push( s, list_append( l, r ) ); break; - } case INSTR_SWAP: - { l = stack_top( s ); stack_set( s, 0, stack_at( s, code->arg ) ); stack_set( s, code->arg, l ); break; - } case INSTR_POP: - { list_free( stack_pop( s ) ); break; - } /* * Branch instructions */ case INSTR_JUMP: - { code += code->arg; break; - } case INSTR_JUMP_EMPTY: - { l = stack_pop( s ); - if ( !list_cmp( l, L0 ) ) { code += code->arg; } + if ( !list_cmp( l, L0 ) ) code += code->arg; list_free( l ); break; - } case INSTR_JUMP_NOT_EMPTY: - { l = stack_pop( s ); - if( list_cmp( l, L0 ) ) { code += code->arg; } + if ( list_cmp( l, L0 ) ) code += code->arg; list_free( l ); break; - } case INSTR_JUMP_LT: - { r = stack_pop( s ); l = stack_pop( s ); - if ( list_cmp( l, r ) < 0 ) { code += code->arg; } + if ( list_cmp( l, r ) < 0 ) code += code->arg; list_free( l ); list_free( r ); break; - } case INSTR_JUMP_LE: - { r = stack_pop( s ); l = stack_pop( s ); - if ( list_cmp( l, r ) <= 0 ) { code += code->arg; } + if ( list_cmp( l, r ) <= 0 ) code += code->arg; list_free( l ); list_free( r ); break; - } case INSTR_JUMP_GT: - { r = stack_pop( s ); l = stack_pop( s ); - if ( list_cmp( l, r ) > 0 ) { code += code->arg; } + if ( list_cmp( l, r ) > 0 ) code += code->arg; list_free( l ); list_free( r ); break; - } case INSTR_JUMP_GE: - { r = stack_pop( s ); l = stack_pop( s ); - if ( list_cmp( l, r ) >= 0 ) { code += code->arg; } + if ( list_cmp( l, r ) >= 0 ) code += code->arg; list_free( l ); list_free( r ); break; - } case INSTR_JUMP_EQ: - { r = stack_pop( s ); l = stack_pop( s ); - if( list_cmp( l, r ) == 0 ) { code += code->arg; } + if ( list_cmp( l, r ) == 0 ) code += code->arg; list_free( l ); list_free( r ); break; - } case INSTR_JUMP_NE: - { r = stack_pop(s); l = stack_pop(s); - if( list_cmp(l, r) != 0 ) { code += code->arg; } + if ( list_cmp(l, r) != 0 ) code += code->arg; list_free(l); list_free(r); break; - } case INSTR_JUMP_IN: - { r = stack_pop(s); l = stack_pop(s); - if ( list_is_sublist( l, r ) ) { code += code->arg; } + if ( list_is_sublist( l, r ) ) code += code->arg; list_free(l); list_free(r); break; - } case INSTR_JUMP_NOT_IN: - { r = stack_pop( s ); l = stack_pop( s ); - if( !list_is_sublist( l, r ) ) { code += code->arg; } + if ( !list_is_sublist( l, r ) ) code += code->arg; list_free( l ); list_free( r ); break; - } /* * For */ - + case INSTR_FOR_INIT: - { l = stack_top( s ); *(LISTITER *)stack_allocate( s, sizeof( LISTITER ) ) = list_begin( l ); break; - } - + case INSTR_FOR_LOOP: { LISTITER iter = *(LISTITER *)stack_get( s ); stack_deallocate( s, sizeof( LISTITER ) ); l = stack_top( s ); - if( iter == list_end( l ) ) + if ( iter == list_end( l ) ) { list_free( stack_pop( s ) ); code += code->arg; @@ -3628,20 +3874,16 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_JUMP_NOT_GLOB: { - const char * pattern; - const char * match; + char const * pattern; + char const * match; l = stack_pop( s ); r = stack_top( s ); - pattern = !list_empty( l ) ? object_str( list_front( l ) ) : ""; - match = !list_empty( r ) ? object_str( list_front( r ) ) : ""; - if( glob( pattern, match ) ) - { + pattern = list_empty( l ) ? "" : object_str( list_front( l ) ); + match = list_empty( r ) ? "" : object_str( list_front( r ) ); + if ( glob( pattern, match ) ) code += code->arg; - } else - { list_free( stack_pop( s ) ); - } list_free( l ); break; } @@ -3651,25 +3893,24 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) */ case INSTR_SET_RESULT: - { list_free( result ); - result = stack_pop( s ); + if ( !code->arg ) + result = stack_pop( s ); + else + result = list_copy( stack_top( s ) ); break; - } case INSTR_PUSH_RESULT: - { stack_push( s, result ); result = L0; break; - } case INSTR_RETURN: { if ( function_->formal_arguments ) - argument_list_pop( function_->formal_arguments, function_->num_formal_arguments, frame, s ); + argument_list_pop( function_->formal_arguments, + function_->num_formal_arguments, frame, s ); #ifndef NDEBUG - if ( !( saved_stack == s->data ) ) { frame->file = function->file; @@ -3691,15 +3932,14 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_PUSH_LOCAL: { LIST * value = stack_pop( s ); - stack_push( s, function_swap_variable( function, frame, code->arg, value ) ); + stack_push( s, function_swap_variable( function, frame, code->arg, + value ) ); break; } case INSTR_POP_LOCAL: - { function_set_variable( function, frame, code->arg, stack_pop( s ) ); break; - } case INSTR_PUSH_LOCAL_FIXED: { @@ -3723,14 +3963,14 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_PUSH_LOCAL_GROUP: { - LIST * value = stack_pop( s ); - LISTITER iter, end; + LIST * const value = stack_pop( s ); + LISTITER iter; + LISTITER end; l = stack_pop( s ); - for( iter = list_begin( l ), end = list_end( l ); iter != end; iter = list_next( iter ) ) - { - LIST * saved = function_swap_named_variable( function, frame, list_item( iter ), list_copy( value ) ); - stack_push( s, saved ); - } + for ( iter = list_begin( l ), end = list_end( l ); iter != end; + iter = list_next( iter ) ) + stack_push( s, function_swap_named_variable( function, frame, + list_item( iter ), list_copy( value ) ) ); list_free( value ); stack_push( s, l ); break; @@ -3738,14 +3978,15 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_POP_LOCAL_GROUP: { - LISTITER iter, end; + LISTITER iter; + LISTITER end; r = stack_pop( s ); l = list_reverse( r ); list_free( r ); - for( iter = list_begin( l ), end = list_end( l ); iter != end; iter = list_next( iter ) ) - { - function_set_named_variable( function, frame, list_item( iter ), stack_pop( s ) ); - } + for ( iter = list_begin( l ), end = list_end( l ); iter != end; + iter = list_next( iter ) ) + function_set_named_variable( function, frame, list_item( iter ), + stack_pop( s ) ); list_free( l ); break; } @@ -3759,18 +4000,15 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) LIST * targets = stack_top( s ); if ( !list_empty( targets ) ) { - /* - * FIXME: push the state onto the stack instead of - * using pushsettings. + /* FIXME: push the state onto the stack instead of using + * pushsettings. */ TARGET * t = bindtarget( list_front( targets ) ); pushsettings( frame->module, t->settings ); } else { - /* - * [ on $(TARGET) ... ] is ignored if $(TARGET) is empty. - */ + /* [ on $(TARGET) ... ] is ignored if $(TARGET) is empty. */ list_free( stack_pop( s ) ); stack_push( s, L0 ); code += code->arg; @@ -3797,15 +4035,17 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) LIST * targets = stack_pop( s ); LIST * value = stack_pop( s ); LIST * vars = stack_pop( s ); - LISTITER iter = list_begin( targets ), end = list_end( targets ); + LISTITER iter = list_begin( targets ); + LISTITER const end = list_end( targets ); for ( ; iter != end; iter = list_next( iter ) ) { TARGET * t = bindtarget( list_item( iter ) ); - LISTITER vars_iter = list_begin( vars ), vars_end = list_end( vars ); - - for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter ) ) - t->settings = addsettings( t->settings, VAR_SET, list_item( vars_iter ), - list_copy( value ) ); + LISTITER vars_iter = list_begin( vars ); + LISTITER const vars_end = list_end( vars ); + for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter + ) ) + t->settings = addsettings( t->settings, VAR_SET, list_item( + vars_iter ), list_copy( value ) ); } list_free( vars ); list_free( targets ); @@ -3818,15 +4058,17 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) LIST * targets = stack_pop( s ); LIST * value = stack_pop( s ); LIST * vars = stack_pop( s ); - LISTITER iter = list_begin( targets ), end = list_end( targets ); + LISTITER iter = list_begin( targets ); + LISTITER const end = list_end( targets ); for ( ; iter != end; iter = list_next( iter ) ) { - TARGET * t = bindtarget( list_item( iter ) ); - LISTITER vars_iter = list_begin( vars ), vars_end = list_end( vars ); - - for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter ) ) - t->settings = addsettings( t->settings, VAR_APPEND, list_item( vars_iter ), - list_copy( value ) ); + TARGET * const t = bindtarget( list_item( iter ) ); + LISTITER vars_iter = list_begin( vars ); + LISTITER const vars_end = list_end( vars ); + for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter + ) ) + t->settings = addsettings( t->settings, VAR_APPEND, + list_item( vars_iter ), list_copy( value ) ); } list_free( vars ); list_free( targets ); @@ -3839,15 +4081,17 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) LIST * targets = stack_pop( s ); LIST * value = stack_pop( s ); LIST * vars = stack_pop( s ); - LISTITER iter = list_begin( targets ), end = list_end( targets ); + LISTITER iter = list_begin( targets ); + LISTITER const end = list_end( targets ); for ( ; iter != end; iter = list_next( iter ) ) { TARGET * t = bindtarget( list_item( iter ) ); - LISTITER vars_iter = list_begin( vars ), vars_end = list_end( vars ); - - for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter ) ) - t->settings = addsettings( t->settings, VAR_DEFAULT, list_item( vars_iter ), - list_copy( value ) ); + LISTITER vars_iter = list_begin( vars ); + LISTITER const vars_end = list_end( vars ); + for ( ; vars_iter != vars_end; vars_iter = list_next( vars_iter + ) ) + t->settings = addsettings( t->settings, VAR_DEFAULT, + list_item( vars_iter ), list_copy( value ) ); } list_free( vars ); list_free( targets ); @@ -3855,34 +4099,60 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) break; } + /* [ on $(target) return $(variable) ] */ + case INSTR_GET_ON: + { + LIST * targets = stack_pop( s ); + LIST * result = L0; + if ( !list_empty( targets ) ) + { + OBJECT * varname = function->constants[ code->arg ]; + TARGET * t = bindtarget( list_front( targets ) ); + SETTINGS * s = t->settings; + int found = 0; + for ( ; s != 0; s = s->next ) + { + if ( object_equal( s->symbol, varname ) ) + { + result = s->value; + found = 1; + break; + } + } + if ( !found ) + { + result = var_get( frame->module, varname ) ; + } + } + stack_push( s, list_copy( result ) ); + break; + } + /* * Variable setting */ case INSTR_SET: - { - function_set_variable( function, frame, code->arg, list_copy( stack_top( s ) ) ); + function_set_variable( function, frame, code->arg, + stack_pop( s ) ); break; - } case INSTR_APPEND: - { - function_append_variable( function, frame, code->arg, list_copy( stack_top( s ) ) ); + function_append_variable( function, frame, code->arg, + stack_pop( s ) ); break; - } case INSTR_DEFAULT: - { - function_default_variable( function, frame, code->arg, list_copy( stack_top( s ) ) ); + function_default_variable( function, frame, code->arg, + stack_pop( 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( stack_top( s ) ); + *ptr = stack_pop( s ); break; } @@ -3890,16 +4160,19 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) { LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; assert( code->arg < frame->module->num_fixed_variables ); - *ptr = list_append( *ptr, list_copy( stack_top( s ) ) ); + *ptr = list_append( *ptr, stack_pop( s ) ); break; } case INSTR_DEFAULT_FIXED: { LIST * * ptr = &frame->module->fixed_variables[ code->arg ]; + LIST * value = stack_pop( s ); assert( code->arg < frame->module->num_fixed_variables ); if ( list_empty( *ptr ) ) - *ptr = list_copy( stack_top( s ) ); + *ptr = value; + else + list_free( value ); break; } @@ -3907,11 +4180,13 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) { LIST * value = stack_pop( s ); LIST * vars = stack_pop( s ); - LISTITER iter = list_begin( vars ), end = list_end( vars ); - for( ; iter != end; iter = list_next( iter ) ) - function_set_named_variable( function, frame, list_item( iter ), list_copy( value ) ); + LISTITER iter = list_begin( vars ); + LISTITER const end = list_end( vars ); + for ( ; iter != end; iter = list_next( iter ) ) + function_set_named_variable( function, frame, list_item( iter ), + list_copy( value ) ); list_free( vars ); - stack_push( s, value ); + list_free( value ); break; } @@ -3919,11 +4194,13 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) { LIST * value = stack_pop( s ); LIST * vars = stack_pop( s ); - LISTITER iter = list_begin( vars ), end = list_end( vars ); - for( ; iter != end; iter = list_next( iter ) ) - function_append_named_variable( function, frame, list_item( iter ), list_copy( value ) ); + LISTITER iter = list_begin( vars ); + LISTITER const end = list_end( vars ); + for ( ; iter != end; iter = list_next( iter ) ) + function_append_named_variable( function, frame, list_item( iter + ), list_copy( value ) ); list_free( vars ); - stack_push( s, value ); + list_free( value ); break; } @@ -3931,11 +4208,13 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) { LIST * value = stack_pop( s ); LIST * vars = stack_pop( s ); - LISTITER iter = list_begin( vars ), end = list_end( vars ); - for( ; iter != end; iter = list_next( iter ) ) - function_default_named_variable( function, frame, list_item( iter ), list_copy( value ) ); + LISTITER iter = list_begin( vars ); + LISTITER const end = list_end( vars ); + for ( ; iter != end; iter = list_next( iter ) ) + function_default_named_variable( function, frame, list_item( + iter ), list_copy( value ) ); list_free( vars ); - stack_push( s, value ); + list_free( value ); break; } @@ -3945,25 +4224,31 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_CALL_RULE: { - const char * unexpanded = - object_str( function_get_constant( function, code[1].op_code ) ); - LIST * result = function_call_rule( function, frame, s, code->arg, unexpanded, function->file, code[1].arg ); + char const * unexpanded = object_str( function_get_constant( + function, code[ 1 ].op_code ) ); + LIST * result = function_call_rule( function, frame, s, code->arg, + unexpanded, function->file, code[ 1 ].arg ); stack_push( s, result ); ++code; break; } - case INSTR_RULE: + case INSTR_CALL_MEMBER_RULE: { - function_set_rule( function, frame, s, code->arg ); + OBJECT * rule_name = function_get_constant( function, code[1].op_code ); + LIST * result = function_call_member_rule( function, frame, s, code->arg, rule_name, function->file, code[1].arg ); + stack_push( s, result ); + ++code; break; } + case INSTR_RULE: + function_set_rule( function, frame, s, code->arg ); + break; + case INSTR_ACTIONS: - { function_set_actions( function, frame, s, code->arg ); break; - } /* * Variable expansion @@ -3980,20 +4265,18 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) list_free( stack_pop( s ) ); stack_deallocate( s, n * sizeof( VAR_EDITS ) ); for ( i = 0; i < code->arg; ++i ) - list_free( stack_pop( s ) ); /* pop modifiers */ + list_free( stack_pop( s ) ); /* pop modifiers */ stack_push( s, l ); break; } - + case INSTR_APPLY_INDEX: - { l = apply_subscript( s ); list_free( stack_pop( s ) ); list_free( stack_pop( s ) ); stack_push( s, l ); break; - } - + case INSTR_APPLY_INDEX_MODIFIERS: { int i; @@ -4008,7 +4291,7 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) list_free( stack_pop( s ) ); stack_deallocate( s, n * sizeof( VAR_EDITS ) ); for ( i = 0; i < code->arg; ++i ) - list_free( stack_pop( s ) ); /* pop modifiers */ + list_free( stack_pop( s ) ); /* pop modifiers */ stack_push( s, l ); break; } @@ -4016,32 +4299,36 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_APPLY_MODIFIERS_GROUP: { int i; - LIST * vars = stack_pop( s ); - int n = expand_modifiers( s, code->arg ); + LIST * const vars = stack_pop( s ); + int const n = expand_modifiers( s, code->arg ); LIST * result = L0; - LISTITER iter = list_begin( vars ), end = list_end( vars ); - for( ; iter != end; iter = list_next( iter ) ) + LISTITER iter = list_begin( vars ); + LISTITER const end = list_end( vars ); + for ( ; iter != end; iter = list_next( iter ) ) { - stack_push( s, function_get_named_variable( function, frame, list_item( iter ) ) ); + stack_push( s, function_get_named_variable( function, frame, + list_item( iter ) ) ); result = list_append( result, apply_modifiers( s, n ) ); list_free( stack_pop( s ) ); } list_free( vars ); stack_deallocate( s, n * sizeof( VAR_EDITS ) ); for ( i = 0; i < code->arg; ++i ) - list_free( stack_pop( s ) ); /* pop modifiers */ + list_free( stack_pop( s ) ); /* pop modifiers */ stack_push( s, result ); break; } - + case INSTR_APPLY_INDEX_GROUP: { LIST * vars = stack_pop( s ); LIST * result = L0; - LISTITER iter = list_begin( vars ), end = list_end( vars ); - for( ; iter != end; iter = list_next( iter ) ) + LISTITER iter = list_begin( vars ); + LISTITER const end = list_end( vars ); + for ( ; iter != end; iter = list_next( iter ) ) { - stack_push( s, function_get_named_variable( function, frame, list_item( iter ) ) ); + stack_push( s, function_get_named_variable( function, frame, + list_item( iter ) ) ); result = list_append( result, apply_subscript( s ) ); list_free( stack_pop( s ) ); } @@ -4050,49 +4337,77 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) stack_push( s, result ); break; } - + case INSTR_APPLY_INDEX_MODIFIERS_GROUP: { int i; - LIST * vars = stack_pop( s ); - LIST * r = stack_pop( s ); - int n = expand_modifiers( s, code->arg ); + LIST * const vars = stack_pop( s ); + LIST * const r = stack_pop( s ); + int const n = expand_modifiers( s, code->arg ); LIST * result = L0; - LISTITER iter = list_begin( vars ), end = list_end( vars ); + LISTITER iter = list_begin( vars ); + LISTITER const end = list_end( vars ); stack_push( s, r ); - for( ; iter != end; iter = list_next( iter ) ) + for ( ; iter != end; iter = list_next( iter ) ) { - stack_push( s, function_get_named_variable( function, frame, list_item( iter ) ) ); - result = list_append( result, apply_subscript_and_modifiers( s, n ) ); + stack_push( s, function_get_named_variable( function, frame, + list_item( iter ) ) ); + result = list_append( result, apply_subscript_and_modifiers( s, + n ) ); list_free( stack_pop( s ) ); } list_free( stack_pop( s ) ); list_free( vars ); stack_deallocate( s, n * sizeof( VAR_EDITS ) ); for ( i = 0; i < code->arg; ++i ) - list_free( stack_pop( s ) ); /* pop modifiers */ + list_free( stack_pop( s ) ); /* pop modifiers */ stack_push( s, result ); break; } case INSTR_COMBINE_STRINGS: { - LIST * result; - size_t buffer_size = code->arg * sizeof( expansion_item ); - LIST * * stack_pos = stack_get( s ); + size_t const buffer_size = code->arg * sizeof( expansion_item ); + LIST * * const stack_pos = stack_get( s ); expansion_item * items = stack_allocate( s, buffer_size ); + LIST * result; int i; - for( i = 0; i < code->arg; ++i ) - { - items[i].saved = stack_pos[i]; - items[i].elem = list_begin( items[i].saved ); - } + for ( i = 0; i < code->arg; ++i ) + items[ i ].values = stack_pos[ i ]; result = expand( items, code->arg ); stack_deallocate( s, buffer_size ); - for( i = 0; i < code->arg; ++i ) - { + for ( i = 0; i < code->arg; ++i ) list_free( stack_pop( s ) ); + stack_push( s, result ); + break; + } + + case INSTR_GET_GRIST: + { + LIST * vals = stack_pop( s ); + LIST * result = L0; + LISTITER iter, end; + + for ( iter = list_begin( vals ), end = list_end( vals ); iter != end; ++iter ) + { + OBJECT * new_object; + const char * value = object_str( list_item( iter ) ); + const char * p; + if ( value[ 0 ] == '<' && ( p = strchr( value, '>' ) ) ) + { + if( p[ 1 ] ) + new_object = object_new_range( value, p - value + 1 ); + else + new_object = object_copy( list_item( iter ) ); + } + else + { + new_object = object_copy( constant_empty ); + } + result = list_push_back( result, new_object ); } + + list_free( vals ); stack_push( s, result ); break; } @@ -4100,33 +4415,33 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_INCLUDE: { LIST * nt = stack_pop( s ); - if ( !list_empty( nt ) ) { - TARGET * t = bindtarget( list_front( nt ) ); + TARGET * const t = bindtarget( list_front( nt ) ); list_free( nt ); - /* 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. + /* DWA 2001/10/22 - Perforce Jam cleared the arguments here, + * which prevented 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(). */ + /* Bind the include file under the influence of "on-target" + * variables. Though they are targets, include files are not + * built with make(). + */ pushsettings( root_module(), 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. */ + /* We do not expect that a file to be included is generated by + * some action. Therefore, pass 0 as third argument. If the name + * resolves to a directory, let it error out. + */ object_free( t->boundname ); t->boundname = search( t->name, &t->time, 0, 0 ); popsettings( root_module(), t->settings ); parse_file( t->boundname, frame ); } - break; } @@ -4136,21 +4451,20 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) case INSTR_PUSH_MODULE: { - LIST * module_name = stack_pop( s ); - - module_t * outer_module = frame->module; - frame->module = !list_empty( module_name ) ? bindmodule( list_front( module_name ) ) : root_module(); - + LIST * const module_name = stack_pop( s ); + module_t * const outer_module = frame->module; + frame->module = !list_empty( module_name ) + ? bindmodule( list_front( module_name ) ) + : root_module(); list_free( module_name ); - - *(module_t * *)stack_allocate( s, sizeof( module_t * ) ) = outer_module; - + *(module_t * *)stack_allocate( s, sizeof( module_t * ) ) = + outer_module; break; } case INSTR_POP_MODULE: { - module_t * outer_module = *(module_t * *)stack_get( s ); + module_t * const outer_module = *(module_t * *)stack_get( s ); stack_deallocate( s, sizeof( module_t * ) ); frame->module = outer_module; break; @@ -4162,35 +4476,33 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) LIST * name = stack_pop( s ); OBJECT * class_module = make_class_module( name, bases, frame ); - module_t * outer_module = frame->module; + module_t * const outer_module = frame->module; frame->module = bindmodule( class_module ); object_free( class_module ); - - *(module_t * *)stack_allocate( s, sizeof( module_t * ) ) = outer_module; + *(module_t * *)stack_allocate( s, sizeof( module_t * ) ) = + outer_module; break; } case INSTR_BIND_MODULE_VARIABLES: - { module_bind_variables( frame->module ); break; - } - + case INSTR_APPEND_STRINGS: { - string buf[1]; + string buf[ 1 ]; string_new( buf ); combine_strings( s, code->arg, buf ); stack_push( s, list_new( object_new( buf->value ) ) ); string_free( buf ); break; } - + case INSTR_WRITE_FILE: { - string buf[1]; - const char * out; + string buf[ 1 ]; + char const * out; OBJECT * tmp_filename = 0; int out_debug = DEBUG_EXEC ? 1 : 0; FILE * out_file = 0; @@ -4198,17 +4510,16 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) combine_strings( s, code->arg, buf ); out = object_str( list_front( stack_top( s ) ) ); - /* For stdout/stderr we will create a temp file and generate - * a command that outputs the content as needed. - */ + /* For stdout/stderr we will create a temp file and generate a + * command that outputs the content as needed. + */ if ( ( strcmp( "STDOUT", out ) == 0 ) || ( strcmp( "STDERR", out ) == 0 ) ) { int err_redir = strcmp( "STDERR", out ) == 0; - string result[1]; + string result[ 1 ]; tmp_filename = path_tmpfile(); string_new( result ); - #ifdef OS_NT string_append( result, "type \"" ); #else @@ -4226,40 +4537,36 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) string_free( result ); - /* We also make sure that the temp files created by this - * get nuked eventually. - */ + /* Make sure temp files created by this get nuked eventually. */ file_remove_atexit( tmp_filename ); } if ( !globs.noexec ) { - string out_name[1]; + string out_name[ 1 ]; /* Handle "path to file" filenames. */ - if ( ( out[ 0 ] == '"' ) && ( out[ strlen( out ) - 1 ] == '"' ) ) + if ( ( out[ 0 ] == '"' ) && ( out[ strlen( out ) - 1 ] == '"' ) + ) { string_copy( out_name, out + 1 ); string_truncate( out_name, out_name->size - 1 ); } else - { string_copy( out_name, out ); - } out_file = fopen( out_name->value, "w" ); - + if ( !out_file ) { - printf( "failed to write output file '%s'!\n", out_name->value ); + printf( "failed to write output file '%s'!\n", + out_name->value ); exit( EXITBAD ); } string_free( out_name ); } if ( out_debug ) printf( "\nfile %s\n", out ); - if ( out_file ) fputs( buf->value, out_file ); if ( out_debug ) fputs( buf->value, stdout ); - if ( out_file ) { fflush( out_file ); @@ -4270,13 +4577,13 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) object_free( tmp_filename ); if ( out_debug ) fputc( '\n', stdout ); - break; } case INSTR_OUTPUT_STRINGS: { - string * buf = *(string * *)( (char *)stack_get( s ) + ( code->arg * sizeof( LIST * ) ) ); + string * const buf = *(string * *)( (char *)stack_get( s ) + ( + code->arg * sizeof( LIST * ) ) ); combine_strings( s, code->arg, buf ); break; } @@ -4289,13 +4596,15 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) #ifdef HAVE_PYTHON -static struct arg_list * arg_list_compile_python( PyObject * bjam_signature, int * num_arguments ) +static struct arg_list * arg_list_compile_python( PyObject * bjam_signature, + int * num_arguments ) { if ( bjam_signature ) { struct argument_list_compiler c[ 1 ]; struct arg_list * result; - Py_ssize_t s, i, j, inner; + Py_ssize_t s; + Py_ssize_t i; argument_list_compiler_init( c ); s = PySequence_Size( bjam_signature ); @@ -4304,15 +4613,15 @@ static struct arg_list * arg_list_compile_python( PyObject * bjam_signature, int struct argument_compiler arg_comp[ 1 ]; struct arg_list arg; PyObject * v = PySequence_GetItem( bjam_signature, i ); + Py_ssize_t j; + Py_ssize_t inner; argument_compiler_init( arg_comp ); - + inner = PySequence_Size( v ); for ( j = 0; j < inner; ++j ) - { - PyObject * x = PySequence_GetItem( v, j ); - argument_compiler_add( arg_comp, object_new( PyString_AsString( x ) ), constant_builtin, -1 ); - } - + argument_compiler_add( arg_comp, object_new( PyString_AsString( + PySequence_GetItem( v, j ) ) ), constant_builtin, -1 ); + arg = arg_compile_impl( arg_comp, constant_builtin, -1 ); dynamic_array_push( c->args, arg ); argument_compiler_free( arg_comp ); @@ -4321,43 +4630,46 @@ static struct arg_list * arg_list_compile_python( PyObject * bjam_signature, int *num_arguments = c->args->size; result = BJAM_MALLOC( c->args->size * sizeof( struct arg_list ) ); - memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) ); + memcpy( result, c->args->data, c->args->size * sizeof( struct arg_list ) + ); argument_list_compiler_free( c ); return result; } - else - { - *num_arguments = 0; - return 0; - } + *num_arguments = 0; + return 0; } FUNCTION * function_python( PyObject * function, PyObject * bjam_signature ) { PYTHON_FUNCTION * result = BJAM_MALLOC( sizeof( PYTHON_FUNCTION ) ); - + result->base.type = FUNCTION_PYTHON; result->base.reference_count = 1; result->base.rulename = 0; - result->base.formal_arguments = arg_list_compile_python( bjam_signature, &result->base.num_formal_arguments ); + result->base.formal_arguments = arg_list_compile_python( bjam_signature, + &result->base.num_formal_arguments ); Py_INCREF( function ); result->python_function = function; return (FUNCTION *)result; } -static void argument_list_to_python( struct arg_list * formal, int formal_count, FUNCTION * function, FRAME * frame, PyObject * kw ) + +static void argument_list_to_python( struct arg_list * formal, int formal_count, + FUNCTION * function, FRAME * frame, PyObject * kw ) { LOL * all_actual = frame->args; - int i, j; + int i; 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 ) + LIST * actual = lol_get( all_actual, i ); + LISTITER actual_iter = list_begin( actual ); + LISTITER const actual_end = list_end( actual ); + int j; + for ( j = 0; j < formal[ i ].size; ++j ) { - struct argument * formal_arg = &formal[i].args[j]; + struct argument * formal_arg = &formal[ i ].args[ j ]; PyObject * value; LIST * l; @@ -4365,9 +4677,12 @@ static void argument_list_to_python( struct arg_list * formal, int formal_count, { case ARG_ONE: if ( actual_iter == actual_end ) - argument_error( "missing argument", function, frame, formal_arg->arg_name ); - type_check_range( formal_arg->type_name, actual_iter, list_next( actual_iter ), frame, function, formal_arg->arg_name ); - value = PyString_FromString( object_str( list_item( actual_iter) ) ); + argument_error( "missing argument", function, frame, + formal_arg->arg_name ); + type_check_range( formal_arg->type_name, actual_iter, list_next( + actual_iter ), frame, function, formal_arg->arg_name ); + value = PyString_FromString( object_str( list_item( actual_iter + ) ) ); actual_iter = list_next( actual_iter ); break; case ARG_OPTIONAL: @@ -4375,17 +4690,22 @@ static void argument_list_to_python( struct arg_list * formal, int formal_count, value = 0; else { - type_check_range( formal_arg->type_name, actual_iter, list_next( actual_iter ), frame, function, formal_arg->arg_name ); - value = PyString_FromString( object_str( list_item( actual_iter) ) ); + type_check_range( formal_arg->type_name, actual_iter, + list_next( actual_iter ), frame, function, + formal_arg->arg_name ); + value = PyString_FromString( object_str( list_item( + actual_iter ) ) ); actual_iter = list_next( actual_iter ); } break; case ARG_PLUS: if ( actual_iter == actual_end ) - argument_error( "missing argument", function, frame, formal_arg->arg_name ); + argument_error( "missing argument", function, frame, + formal_arg->arg_name ); /* fallthrough */ case ARG_STAR: - type_check_range( formal_arg->type_name, actual_iter, actual_end, frame, function, formal_arg->arg_name ); + type_check_range( formal_arg->type_name, actual_iter, + actual_end, frame, function, formal_arg->arg_name ); l = list_copy_range( actual, actual_iter, actual_end ); value = list_to_python( l ); list_free( l ); @@ -4394,10 +4714,11 @@ static void argument_list_to_python( struct arg_list * formal, int formal_count, case ARG_VARIADIC: return; } - - if (value) + + if ( value ) { - PyObject * key = PyString_FromString( object_str( formal_arg->arg_name ) ); + PyObject * key = PyString_FromString( object_str( + formal_arg->arg_name ) ); PyDict_SetItem( kw, key, value ); Py_DECREF( key ); Py_DECREF( value ); @@ -4405,88 +4726,84 @@ static void argument_list_to_python( struct arg_list * formal, int formal_count, } if ( actual_iter != actual_end ) - { - argument_error( "extra argument", function, frame, list_item( actual_iter ) ); - } + argument_error( "extra argument", function, frame, list_item( + actual_iter ) ); } for ( ; i < all_actual->count; ++i ) { - LIST * actual = lol_get( all_actual, i ); + LIST * const actual = lol_get( all_actual, i ); if ( !list_empty( actual ) ) - { - argument_error( "extra argument", function, frame, list_front( actual ) ); - } + argument_error( "extra argument", function, frame, list_front( + actual ) ); } } -/* 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. */ + +/* Given a Python object, return a string to use in Jam code instead of the said + * object. + * + * If the object is a string, use the string value. + * If the object implemenets __jam_repr__ method, use that. + * Otherwise return 0. + */ + OBJECT * python_to_string( PyObject * value ) { if ( PyString_Check( value ) ) + return object_new( PyString_AS_STRING( value ) ); + + /* See if this instance defines the special __jam_repr__ method. */ + if ( PyInstance_Check( value ) + && PyObject_HasAttrString( value, "__jam_repr__" ) ) { - return object_new( 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* 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 object_new( PyString_AsString( value2 ) ); - } - Py_DECREF( value2 ); - } + PyObject * arguments2 = PyTuple_New( 0 ); + PyObject * value2 = PyObject_Call( repr, arguments2, 0 ); + Py_DECREF( repr ); + Py_DECREF( arguments2 ); + if ( PyString_Check( value2 ) ) + return object_new( PyString_AS_STRING( value2 ) ); + Py_DECREF( value2 ); } - return 0; } + return 0; } + static module_t * python_module() { static module_t * python = 0; if ( !python ) - python = bindmodule(constant_python); + python = bindmodule( constant_python ); return python; } + static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame ) { LIST * result = 0; PyObject * arguments = 0; PyObject * kw = NULL; - int i ; + int i; PyObject * py_result; FRAME * prev_frame_before_python_call; if ( function->base.formal_arguments ) { - arguments = PyTuple_New(0); + arguments = PyTuple_New( 0 ); kw = PyDict_New(); - - argument_list_to_python( function->base.formal_arguments, function->base.num_formal_arguments, &function->base, frame, kw ); + argument_list_to_python( function->base.formal_arguments, + function->base.num_formal_arguments, &function->base, frame, kw ); } else { arguments = PyTuple_New( frame->args->count ); for ( i = 0; i < frame->args->count; ++i ) - { - PyTuple_SetItem( arguments, i, list_to_python( lol_get( frame->args, i ) ) ); - } + PyTuple_SetItem( arguments, i, list_to_python( lol_get( frame->args, + i ) ) ); } frame->module = python_module(); @@ -4505,32 +4822,32 @@ static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame ) int i; for ( i = 0; i < size; ++i ) { - PyObject * item = PyList_GetItem( py_result, i ); - OBJECT *s = python_to_string( item ); - if ( !s ) { - fprintf( stderr, "Non-string object returned by Python call.\n" ); - } else { + OBJECT * s = python_to_string( PyList_GetItem( py_result, i ) ); + if ( !s ) + fprintf( stderr, + "Non-string object returned by Python call.\n" ); + else result = list_push_back( result, s ); - } } } else if ( py_result == Py_None ) { result = L0; } - else + else { - OBJECT *s = python_to_string( py_result ); - if (s) + OBJECT * const s = python_to_string( py_result ); + if ( s ) result = list_new( 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; + else + /* We have tried all we could. Return empty list. There are + * cases, e.g. feature.feature function that should return a + * 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 would be a pile of + * them. + */ + result = L0; } Py_DECREF( py_result ); @@ -4538,7 +4855,7 @@ static LIST * call_python_function( PYTHON_FUNCTION * function, FRAME * frame ) else { PyErr_Print(); - fprintf( stderr,"Call failed\n" ); + fprintf( stderr, "Call failed\n" ); } return result; |