From 2984c9dee786e345b8797118567448954fd508fc Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurko=20Gospodneti=C4=87?= Date: Mon, 25 Jun 2012 00:33:54 +0000 Subject: [PATCH] Boost Jam code cleanup - minor stylistic changes. [SVN r79067] --- v2/engine/execcmd.h | 1 + v2/engine/function.c | 1955 ++++++++++++++++++++---------------------- v2/engine/output.c | 64 +- 3 files changed, 953 insertions(+), 1067 deletions(-) diff --git a/v2/engine/execcmd.h b/v2/engine/execcmd.h index 950563d4a..c46c472e0 100644 --- a/v2/engine/execcmd.h +++ b/v2/engine/execcmd.h @@ -80,4 +80,5 @@ int interrupted( void ); */ int is_raw_command_request( LIST * shell ); + #endif diff --git a/v2/engine/function.c b/v2/engine/function.c index 1688eba4e..bb3357986 100644 --- a/v2/engine/function.c +++ b/v2/engine/function.c @@ -4,13 +4,14 @@ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) */ +#include "jam.h" +#include "function.h" + #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" @@ -18,17 +19,18 @@ #include "class.h" #include "pathsys.h" #include "filesys.h" + #include #include #include #include -# ifdef OS_CYGWIN -# include -# include -# endif +#ifdef OS_CYGWIN +# include +# include +#endif -int glob( const char * s, const char * c ); +int glob( char const * s, char const * c ); void backtrace( FRAME * frame ); void backtrace_line( FRAME * frame ); @@ -113,7 +115,7 @@ void backtrace_line( FRAME * frame ); typedef struct instruction { unsigned int op_code; - int arg; + int arg; } instruction; typedef struct _subfunction @@ -125,9 +127,9 @@ typedef struct _subfunction typedef struct _subaction { - OBJECT * name; + OBJECT * name; FUNCTION * command; - int flags; + int flags; } SUBACTION; #define FUNCTION_BUILTIN 0 @@ -249,7 +251,7 @@ LIST * stack_pop( STACK * s ) return result; } -LIST * stack_top(STACK * s) +LIST * stack_top( STACK * s ) { check_alignment( s ); return *(LIST * *)s->data; @@ -258,7 +260,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 ) @@ -275,7 +277,7 @@ void * stack_get( STACK * s ) 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 +286,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 +382,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,51 +427,39 @@ 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 ) - { + 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(), below. */ + inner->module = frame->module; /* This gets fixed up in evaluate_rule(). */ - for( i = 0; i < n_args; ++i ) - { + 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 ) - { + 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 * * l = &inner->args->list[0]; + LIST * * const l = &inner->args->list[ 0 ]; *l = list_append( trailing, *l ); } } @@ -471,6 +470,7 @@ static LIST * function_call_rule( JAM_FUNCTION * function, FRAME * frame, STACK return result; } + /* Variable expansion */ typedef struct @@ -492,11 +492,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 +533,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 +601,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 ) { @@ -630,34 +631,33 @@ static void var_edit_file( const char * in, string * out, VAR_EDITS * edits ) path_build( &pathname, out, 0 ); } else - { string_append( out, in ); - } } /* - * var_edit_shift() - do upshift/downshift mods. + * var_edit_shift() - do upshift/downshift & other mods. */ static void var_edit_shift( string * out, size_t pos, VAR_EDITS * edits ) { - if ( edits->upshift || edits->downshift || edits->to_windows || edits->to_slashes ) +# ifdef OS_CYGWIN + if ( edits->to_windows ) + { + /* 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 + + if ( edits->upshift || edits->downshift || edits->to_slashes ) { /* Handle upshifting, downshifting and slash translation now. */ char * p; -# ifdef OS_CYGWIN - if ( edits->to_windows ) - { - /* 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) + for ( p = out->value + pos; *p; ++p ) { if ( edits->upshift ) *p = toupper( *p ); @@ -669,12 +669,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 +680,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 +718,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 +795,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 +831,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 +868,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 +886,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 +924,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 ); } @@ -971,18 +967,19 @@ typedef struct expansion_item static LIST * expand( expansion_item * elem, int 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 ); + LISTITER iter = elem[ i ].elem; + LISTITER const end = list_end( elem[ i ].saved ); if ( iter == end ) return result; for ( ; iter != end; iter = list_next( iter ) ) { - int len = strlen( object_str( list_item( iter ) ) ); + int const len = strlen( object_str( list_item( iter ) ) ); if ( len > max ) max = len; } size += max; @@ -994,22 +991,20 @@ static LIST * expand( expansion_item * elem, int length ) loop: for ( ; i < length; ++i ) { - elem[i].size = buf->size; - string_append( buf, object_str( list_item( elem[i].elem ) ) ); + elem[ i ].size = buf->size; + string_append( buf, object_str( list_item( elem[ i ].elem ) ) ); } 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( elem[ i ].elem ) != list_end( elem[ i ].saved ) ) { - elem[i].elem = list_next( elem[i].elem ); - string_truncate( buf, elem[i].size ); + elem[ i ].elem = list_next( elem[ i ].elem ); + string_truncate( buf, elem[ i ].size ); goto loop; } else - { - elem[i].elem = list_begin( elem[i].saved ); - } + elem[ i ].elem = list_begin( elem[ i ].saved ); } } string_free( buf ); @@ -1021,12 +1016,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 +1052,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 +1073,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 +1084,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 +1098,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 +1120,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 +1144,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 +1168,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 +1179,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 +1190,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 +1207,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 ); @@ -1230,23 +1230,26 @@ static JAM_FUNCTION * compile_to_function( compiler * c ) 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 *) ); + 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) ); 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) ); + memcpy( result->actions, c->actions->data, c->actions->size * sizeof( + SUBACTION) ); result->num_subactions = c->actions->size; result->generic = 0; @@ -1257,18 +1260,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 +1281,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 +1289,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 +1301,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 +1323,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 +1333,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 +1356,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 +1378,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 +1405,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 +1419,7 @@ static VAR_PARSE_GROUP * var_parse_var_new_modifier( VAR_PARSE_VAR * var ) return result; } + /* * VAR_PARSE_STRING */ @@ -1423,13 +1430,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,46 +1448,52 @@ 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 ) + switch ( parse->type ) { - 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 - { - 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; /* If there are modifiers, emit them in reverse order. */ @@ -1486,36 +1501,29 @@ static void var_parse_var_compile( const VAR_PARSE_VAR * parse, compiler * c ) { int i; 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 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 ) { - 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 ) ); + 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 @@ -1526,163 +1534,149 @@ 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 ) - { compile_emit( c, INSTR_PUSH_GROUP, 0 ); - } else if ( !parse->modifiers->size && parse->subscript && !expand_name ) - { compile_emit( c, INSTR_APPLY_INDEX, 0 ); - } else if ( !parse->modifiers->size && parse->subscript && expand_name ) - { compile_emit( c, INSTR_APPLY_INDEX_GROUP, 0 ); - } if ( parse->modifiers->size && !parse->subscript && !expand_name ) - { compile_emit( c, INSTR_APPLY_MODIFIERS, parse->modifiers->size ); - } else if ( parse->modifiers->size && !parse->subscript && expand_name ) - { compile_emit( c, INSTR_APPLY_MODIFIERS_GROUP, parse->modifiers->size ); - } else if ( parse->modifiers->size && parse->subscript && !expand_name ) - { compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS, parse->modifiers->size ); - } else if ( parse->modifiers->size && parse->subscript && expand_name ) - { - compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS_GROUP, parse->modifiers->size ); - } + compile_emit( c, INSTR_APPLY_INDEX_MODIFIERS_GROUP, + parse->modifiers->size ); } -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 ) + switch ( parse->type ) { - 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 - { - 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 +1685,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 +1702,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 +1755,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 +1785,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 +1821,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 +1840,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 +1897,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 +1956,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 +1972,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 +1981,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 +1990,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 +1999,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 +2008,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 +2017,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 +2026,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 +2041,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 +2056,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 +2084,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 +2102,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 +2123,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 ); @@ -2227,13 +2179,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 +2200,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 +2233,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 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 +2248,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 ); @@ -2312,7 +2261,7 @@ 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 ); + char const * s = object_str( o ); VAR_PARSE_GROUP * group; current_file = object_str( parse->file ); current_line = parse->line; @@ -2323,10 +2272,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 +2285,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 ); @@ -2393,24 +2341,23 @@ 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 ); + 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,26 +2374,25 @@ 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 ); compile_emit( c, op_code, name ); @@ -2471,18 +2417,15 @@ static void compile_parse( PARSE * parse, compiler * c, int result_location ) { 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 +2437,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 ) { - 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 +2464,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 +2502,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 +2521,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 +2533,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 +2567,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 +2592,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 +2602,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 +2610,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 ); 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 +2671,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 +2693,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 +2743,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 +2754,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 +2835,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 +2877,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 +2903,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 +2918,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 +2928,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 +2937,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 +2968,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 +2995,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 +3035,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 ) ); + if ( formal_arg->type_name ) + printf( "%s ", object_str( formal_arg->type_name ) ); printf( "%s", formal_arg->arg_name ); - switch( formal_arg->flags ) + switch ( formal_arg->flags ) { case ARG_OPTIONAL: printf( " ?" ); break; case ARG_PLUS: printf( " +" ); break; @@ -3119,16 +3072,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 +3093,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 +3128,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 +3156,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 ) @@ -3283,9 +3227,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 +3247,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 ); @@ -3386,7 +3331,8 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) { BUILTIN_FUNCTION * 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 ); } @@ -3401,9 +3347,10 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) #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 +3364,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 +3375,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 +3538,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 +3557,22 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) */ case INSTR_SET_RESULT: - { list_free( result ); result = stack_pop( 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 +3594,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 +3625,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 +3640,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 +3662,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 +3697,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 +3720,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 +3743,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 ); @@ -3860,22 +3766,19 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) */ case INSTR_SET: - { - function_set_variable( function, frame, code->arg, list_copy( stack_top( s ) ) ); + function_set_variable( function, frame, code->arg, list_copy( + stack_top( s ) ) ); break; - } case INSTR_APPEND: - { - function_append_variable( function, frame, code->arg, list_copy( stack_top( s ) ) ); + function_append_variable( function, frame, code->arg, list_copy( + stack_top( s ) ) ); break; - } case INSTR_DEFAULT: - { - function_default_variable( function, frame, code->arg, list_copy( stack_top( s ) ) ); + function_default_variable( function, frame, code->arg, list_copy( + stack_top( s ) ) ); break; - } case INSTR_SET_FIXED: { @@ -3907,9 +3810,11 @@ 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 ); break; @@ -3919,9 +3824,11 @@ 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 ); break; @@ -3931,9 +3838,11 @@ 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 ); break; @@ -3945,25 +3854,22 @@ 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: - { 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 +3886,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 +3912,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 +3920,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,27 +3958,30 @@ 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; } @@ -4082,17 +3993,15 @@ LIST * function_run( FUNCTION * function_, FRAME * frame, STACK * s ) LIST * * stack_pos = stack_get( s ); expansion_item * items = stack_allocate( s, buffer_size ); int i; - for( i = 0; i < code->arg; ++i ) + for ( i = 0; i < code->arg; ++i ) { - items[i].saved = stack_pos[i]; - items[i].elem = list_begin( items[i].saved ); + items[ i ].saved = stack_pos[ i ]; + items[ i ].elem = list_begin( items[ i ].saved ); } 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; } @@ -4100,33 +4009,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 +4045,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 +4070,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 +4104,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 +4131,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 +4171,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 +4190,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 +4207,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 +4224,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 +4271,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 +4284,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 +4308,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 +4320,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_AsString( value ) ); - } - else + + /* See if this instance defines the special __jam_repr__ method. */ + if ( PyInstance_Check( value ) + && PyObject_HasAttrString( value, "__jam_repr__" ) ) { - /* 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_AsString( 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 +4416,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 +4449,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; diff --git a/v2/engine/output.c b/v2/engine/output.c index a0154c6ea..44ad1be12 100644 --- a/v2/engine/output.c +++ b/v2/engine/output.c @@ -12,16 +12,12 @@ #define bjam_out (stdout) #define bjam_err (stderr) -static void out_ -( - char const * data, - FILE * io -) +static void out_( char const * data, FILE * io ) { while ( *data ) { - size_t len = strcspn(data,"\r"); - data += fwrite(data,1,len,io); + size_t const len = strcspn( data, "\r" ); + data += fwrite( data, 1, len, io ); if ( *data == '\r' ) ++data; } } @@ -34,16 +30,14 @@ void out_action char const * command, char const * out_data, char const * err_data, - int exit_reason + int exit_reason ) { - /* Print out the action+target line, if the action is quite the action + /* Print out the action + target line, if the action is quiet the action * should be null. */ if ( action ) - { fprintf( bjam_out, "%s %s\n", action, target ); - } /* Print out the command executed if given -d+2. */ if ( DEBUG_EXEC ) @@ -54,45 +48,25 @@ void out_action /* Print out the command executed to the command stream. */ if ( globs.cmdout ) - { fputs( command, globs.cmdout ); - } - switch ( exit_reason ) - { - case EXIT_OK: - break; - case EXIT_FAIL: - break; - case EXIT_TIMEOUT: - { - /* Process expired, make user aware with explicit message. */ - if ( action ) - { - /* But only output for non-quietly actions. */ - fprintf( bjam_out, "%ld second time limit exceeded\n", globs.timeout ); - } - break; - } - default: - break; - } + /* If the process expired, make user aware with an explicit message, but do + * this only for non-quiet actions. + */ + if ( exit_reason == EXIT_TIMEOUT && action ) + fprintf( bjam_out, "%ld second time limit exceeded\n", globs.timeout ); - /* Print out the command output, if requested, or if the program failed. */ - if ( action || exit_reason != EXIT_OK) + /* Print out the command output, if requested, or if the program failed, but + * only output for non-quiet actions. + */ + if ( action || exit_reason != EXIT_OK ) { - /* But only output for non-quietly actions. */ - if ( ( 0 != out_data ) && + if ( out_data && ( ( globs.pipe_action & 1 /* STDOUT_FILENO */ ) || ( globs.pipe_action == 0 ) ) ) - { out_( out_data, bjam_out ); - } - if ( ( 0 != err_data ) && - ( globs.pipe_action & 2 /* STDERR_FILENO */ ) ) - { + if ( err_data && ( globs.pipe_action & 2 /* STDERR_FILENO */ ) ) out_( err_data, bjam_err ); - } } fflush( bjam_out ); @@ -103,7 +77,7 @@ void out_action OBJECT * outf_int( int value ) { - char buffer[50]; + char buffer[ 50 ]; sprintf( buffer, "%i", value ); return object_new( buffer ); } @@ -111,7 +85,7 @@ OBJECT * outf_int( int value ) OBJECT * outf_double( double value ) { - char buffer[50]; + char buffer[ 50 ]; sprintf( buffer, "%f", value ); return object_new( buffer ); } @@ -119,7 +93,7 @@ OBJECT * outf_double( double value ) OBJECT * outf_time( time_t value ) { - char buffer[50]; + char buffer[ 50 ]; strftime( buffer, 49, "%Y-%m-%d %H:%M:%SZ", gmtime( &value ) ); return object_new( buffer ); }