From c16ae1c68a170959ea5ffd3ddf604512094da0e4 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jurko=20Gospodneti=C4=87?= Date: Tue, 17 Jul 2012 08:56:49 +0000 Subject: [PATCH] Boost Jam/Build cleanup - minor stylistic changes (comment updates; line wrapping; removed some dead/unused function declarations, parameters & code; declared variables as const; reordered some #include directives alphabetically, removed some unnecessary ones and added several missing ones discovered by the reordering). [SVN r79569] --- src/build/scanner.jam | 145 +++++++++++++----------- src/build/virtual-target.jam | 42 +++---- src/engine/builtins.c | 85 ++++++++------ src/engine/class.c | 36 +++--- src/engine/compile.c | 101 ++++++++--------- src/engine/filent.c | 66 +++++------ src/engine/fileunix.c | 2 +- src/engine/function.c | 2 +- src/engine/modules/order.c | 179 ++++++++++++++++-------------- src/engine/modules/property-set.c | 122 +++++++++----------- src/engine/modules/regex.c | 90 ++++++++------- src/engine/pathsys.h | 4 +- src/engine/pathunix.c | 5 +- src/engine/regexp.c | 3 +- src/engine/regexp.h | 20 ++-- src/engine/rules.c | 17 ++- src/engine/rules.h | 32 +++--- src/engine/search.c | 6 +- src/engine/timestamp.c | 4 +- src/util/print.jam | 44 ++++---- test/dependency-test/foo.jam | 11 +- 21 files changed, 526 insertions(+), 490 deletions(-) diff --git a/src/build/scanner.jam b/src/build/scanner.jam index d6042ea2c..6b85a6faf 100644 --- a/src/build/scanner.jam +++ b/src/build/scanner.jam @@ -1,78 +1,84 @@ -# Copyright 2003 Dave Abrahams -# Copyright 2002, 2003, 2004, 2005 Vladimir Prus -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) +# Copyright 2003 Dave Abrahams +# Copyright 2002, 2003, 2004, 2005 Vladimir Prus +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) -# Implements scanners: objects that compute implicit dependencies for -# files, such as includes in C++. +# Implements scanners: objects computing implicit dependencies for files, such +# as includes in C++. # -# Scanner has a regular expression used to find dependencies, some -# data needed to interpret those dependencies (for example, include -# paths), and a code which actually established needed relationship -# between actual jam targets. +# A scanner has a regular expression used to find the dependencies, some data +# needed to interpret those dependencies (e.g., include paths), and code which +# establishing needed relationships between actual jam targets. # -# Scanner objects are created by actions, when they try to actualize -# virtual targets, passed to 'virtual-target.actualize' method and are -# then associated with actual targets. It is possible to use -# several scanners for a virtual-target. For example, a single source -# might be used by to compile actions, with different include paths. -# In this case, two different actual targets will be created, each -# having scanner of its own. +# Scanner objects are created by actions when they try to actualize virtual +# targets, passed to the virtual-target.actualize() method and are then +# associated with actual targets. It is possible to use several scanners for a +# single virtual-target. For example, a single source file might be compiled +# twice - each time using a different include path. In this case, two separate +# actual targets will be created, each having a scanner of its own. # -# Typically, scanners are created from target type and action's -# properties, using the rule 'get' in this module. Directly creating -# scanners is not recommended, because it might create many equvivalent -# but different instances, and lead in unneeded duplication of -# actual targets. However, actions can also create scanners in a special -# way, instead of relying on just target type. +# Typically, scanners are created from target type and the action's properties, +# using the rule 'get' in this module. Directly creating scanners is not +# recommended, as it might create multiple equvivalent but different instances, +# and lead to unnecessary actual target duplication. However, actions can also +# create scanners in a special way, instead of relying on just the target type. import "class" : new ; -import property virtual-target property-set ; -import errors : error ; +import property ; +import property-set ; +import virtual-target ; -# Base scanner class. -class scanner +# Base scanner class. +# +class scanner { rule __init__ ( ) { } - - # Returns a pattern to use for scanning + + # Returns a pattern to use for scanning. + # rule pattern ( ) { - error "method must be overriden" ; + import errors ; + errors.error "method must be overriden" ; } - # Establish necessary relationship between targets, - # given actual target beeing scanned, and a list of - # pattern matches in that file. + # Establish necessary relationship between targets, given an actual target + # beeing scanned and a list of pattern matches in that file. + # rule process ( target : matches * ) { - error "method must be overriden" ; - } + import errors ; + errors.error "method must be overriden" ; + } } -# Registers a new generator class, specifying a set of -# properties relevant to this scanner. Ctor for that class -# should have one parameter: list of properties. + +# Registers a new generator class, specifying a set of properties relevant to +# this scanner. Constructor for that class should have one parameter: a list of +# properties. +# rule register ( scanner-class : relevant-properties * ) { .registered += $(scanner-class) ; .relevant-properties.$(scanner-class) = $(relevant-properties) ; } -# Common scanner class, which can be used when there's only one -# kind of includes (unlike C, where "" and <> includes have different -# search paths). -class common-scanner : scanner + +# Common scanner class, usable when there is only one kind of includes (unlike +# C, where "" and <> includes have different search paths). +# +class common-scanner : scanner { import scanner ; + rule __init__ ( includes * ) { scanner.__init__ ; self.includes = $(includes) ; } - + rule process ( target : matches * : binding ) { local target_path = [ NORMALIZE_PATH $(binding:D) ] ; @@ -81,55 +87,61 @@ class common-scanner : scanner INCLUDES $(target) : $(matches) ; SEARCH on $(matches) = $(target_path) $(self.includes:G=) ; ISFILE $(matches) ; - - scanner.propagate $(__name__) : $(matches) : $(target) ; + + scanner.propagate $(__name__) : $(matches) : $(target) ; } } -# Returns an instance of previously registered scanner, -# with the specified properties. -rule get ( scanner-class : property-set ) +# Returns an instance of a previously registered scanner, with the specified +# properties. +# +rule get ( scanner-class : property-set ) { if ! $(scanner-class) in $(.registered) { - error "attempt to get unregisted scanner" ; + import errors ; + errors.error "attempt to get an unregisted scanner" ; } - + local r = $(.rv-cache.$(property-set)) ; if ! $(r) { - r = [ property-set.create + r = [ property-set.create [ property.select $(.relevant-properties.$(scanner-class)) : - [ $(property-set).raw ] ] ] ; + [ $(property-set).raw ] ] ] ; .rv-cache.$(property-set) = $(r) ; } - + if ! $(scanner.$(scanner-class).$(r:J=-)) { - scanner.$(scanner-class).$(r:J=-) = [ new $(scanner-class) [ $(r).raw ] ] ; + local s = [ new $(scanner-class) [ $(r).raw ] ] ; + scanner.$(scanner-class).$(r:J=-) = $(s) ; } - return $(scanner.$(scanner-class).$(r:J=-)) ; + return $(scanner.$(scanner-class).$(r:J=-)) ; } -# Installs the specified scanner on actual target 'target'. +# Installs the specified scanner on the actual target 'target'. +# rule install ( scanner : target - vtarget # virtual target from which 'target' was actualized + vtarget # virtual target from which 'target' was actualized ) { HDRSCAN on $(target) = [ $(scanner).pattern ] ; SCANNER on $(target) = $(scanner) ; HDRRULE on $(target) = scanner.hdrrule ; - - # scanner reflects difference in properties affecting - # binding of 'target', which will be known when processing - # includes for it, will give information on how to - # interpret quoted includes. + + # Scanner reflects differences in properties affecting binding of 'target', + # which will be known when processing includes for it, and give information + # on how to interpret different include types (e.g. quoted vs. those in + # angle brackets in C files). HDRGRIST on $(target) = $(scanner) ; } -# Propagate scanner setting from 'including-target' to 'targets'. + +# Propagate scanner settings from 'including-target' to 'targets'. +# rule propagate ( scanner : targets * : including-target ) { HDRSCAN on $(targets) = [ on $(including-target) return $(HDRSCAN) ] ; @@ -144,8 +156,11 @@ rule hdrrule ( target : matches * : binding ) local scanner = [ on $(target) return $(SCANNER) ] ; $(scanner).process $(target) : $(matches) : $(binding) ; } -# hdrrule must be available at global scope so that it can be invoked -# by header scanning + + +# hdrrule must be available at global scope so it can be invoked by header +# scanning. +# IMPORT scanner : hdrrule : : scanner.hdrrule ; diff --git a/src/build/virtual-target.jam b/src/build/virtual-target.jam index 2e8446bcc..e6353a4a0 100644 --- a/src/build/virtual-target.jam +++ b/src/build/virtual-target.jam @@ -113,12 +113,12 @@ class virtual-target { return $(self.dependencies) ; } - + rule always ( ) { .always = 1 ; } - + # Generates all the actual targets and sets up build actions for this # target. # @@ -133,12 +133,12 @@ class virtual-target rule actualize ( scanner ? ) { local actual-name = [ actualize-no-scanner ] ; - + if $(.always) { ALWAYS $(actual-name) ; } - + if ! $(scanner) { return $(actual-name) ; @@ -203,7 +203,7 @@ class virtual-target # In fact, we just need to merge virtual-target with # abstract-file-target as the latter is the only class derived from the # former. But that has been left for later. - + errors.error "method should be defined in derived classes" ; } } @@ -760,20 +760,20 @@ class action DEPENDS $(actual-targets) : $(self.actual-sources) $(self.dependency-only-sources) ; - - # This works around a bug with -j and actions that - # produce multiple target, where: - # - dependency on the first output is found, and - # the action is started - # - dependency on the second output is found, and - # bjam noticed that command is already running - # - instead of waiting for the command, dependents - # of the second targets are immediately updated. + + # This works around a bug with -j and actions that produce multiple + # target, where: + # - dependency on the first output is found, and the action is + # started + # - dependency on the second output is found, and bjam noticed that + # command is already running + # - instead of waiting for the command, dependents of the second + # targets are immediately updated. if $(actual-targets[2]) - { + { INCLUDES $(actual-targets) : $(actual-targets) ; } - + # Action name can include additional argument to rule, which should # not be passed to 'set-target-variables' toolset.set-target-variables @@ -1104,7 +1104,8 @@ rule traverse ( target : include-roots ? : include-sources ? ) { if ! [ $(t).root ] { - result += [ traverse $(t) : $(include-roots) : $(include-sources) ] ; + result += [ traverse $(t) : $(include-roots) : + $(include-sources) ] ; } else if $(include-roots) { @@ -1125,7 +1126,8 @@ rule traverse ( target : include-roots ? : include-sources ? ) # 'new-rule-name' and 'new-properties', if those are specified. Returns the # cloned action. # -rule clone-action ( action : new-project : new-action-name ? : new-properties ? ) +rule clone-action ( action : new-project : new-action-name ? : new-properties ? + ) { if ! $(new-action-name) { @@ -1245,7 +1247,7 @@ class subvariant { $(theset).add $(t) ; r += [ $(t:G=).creating-subvariant ] ; - } + } } r = [ sequence.unique $(r) ] ; for local s in $(r) @@ -1259,7 +1261,7 @@ class subvariant # Returns the properties specifying implicit include paths to generated # headers. This traverses all targets in this subvariant and subvariants - # referred by properties. For all targets of type + # referred by properties. For all targets of type # 'target-type' (or for all targets, if 'target-type' is not specified), the # result will contain <$(feature)>path-to-that-target. # diff --git a/src/engine/builtins.c b/src/engine/builtins.c index c767fc04f..52bd56027 100644 --- a/src/engine/builtins.c +++ b/src/engine/builtins.c @@ -497,6 +497,7 @@ LIST * builtin_depends( FRAME * frame, int flags ) { LIST * const targets = lol_get( frame->args, 0 ); LIST * const sources = lol_get( frame->args, 1 ); + LISTITER iter = list_begin( targets ); LISTITER end = list_end( targets ); for ( ; iter != end; iter = list_next( iter ) ) @@ -664,7 +665,7 @@ static void builtin_glob_back( void * closure, OBJECT * file, int status, } string_new( buf ); - path_build( &f, buf, 0 ); + path_build( &f, buf ); if ( globbing->case_insensitive ) downcase_inplace( buf->value ); @@ -675,7 +676,8 @@ static void builtin_glob_back( void * closure, OBJECT * file, int status, { if ( !glob( object_str( list_item( iter ) ), buf->value ) ) { - globbing->results = list_push_back( globbing->results, object_copy( file ) ); + globbing->results = list_push_back( globbing->results, object_copy( + file ) ); break; } } @@ -824,7 +826,7 @@ LIST * glob_recursive( char const * pattern ) path->f_grist.len = 0; path->f_dir.ptr = 0; path->f_dir.len = 0; - path_build( path, basename, 0 ); + path_build( path, basename ); dirs = has_wildcards( dirname->value ) ? glob_recursive( dirname->value ) @@ -836,7 +838,8 @@ LIST * glob_recursive( char const * pattern ) LISTITER iter = list_begin( dirs ); LISTITER const end = list_end( dirs ); for ( ; iter != end; iter = list_next( iter ) ) - result = list_append( result, glob1( list_item( iter ), b ) ); + result = list_append( result, glob1( list_item( iter ), b ) + ); object_free( b ); } else @@ -852,7 +855,7 @@ LIST * glob_recursive( char const * pattern ) OBJECT * p; path->f_dir.ptr = object_str( list_item( iter ) ); path->f_dir.len = strlen( object_str( list_item( iter ) ) ); - path_build( path, file_string, 0 ); + path_build( path, file_string ); p = object_new( file_string->value ); @@ -1028,8 +1031,8 @@ LIST * builtin_hdrmacro( FRAME * frame, int flags ) static void add_rule_name( void * r_, void * result_ ) { - RULE * r = (RULE *)r_; - LIST * * result = (LIST * *)result_; + RULE * const r = (RULE *)r_; + LIST * * const result = (LIST * *)result_; if ( r->exported ) *result = list_push_back( *result, object_copy( r->name ) ); } @@ -1039,8 +1042,9 @@ LIST * builtin_rulenames( FRAME * frame, int flags ) { LIST * arg0 = lol_get( frame->args, 0 ); LIST * result = L0; - module_t * source_module = bindmodule( !list_empty( arg0 ) ? - list_front( arg0 ) : 0 ); + module_t * const source_module = bindmodule( list_empty( arg0 ) + ? 0 + : list_front( arg0 ) ); if ( source_module->rules ) hashenumerate( source_module->rules, add_rule_name, &result ); @@ -1069,10 +1073,11 @@ LIST * builtin_varnames( FRAME * frame, int flags ) { LIST * arg0 = lol_get( frame->args, 0 ); LIST * result = L0; - module_t * source_module = bindmodule( !list_empty(arg0) ? list_front(arg0) : 0 ); - - struct hash * vars = source_module->variables; + module_t * source_module = bindmodule( list_empty( arg0 ) + ? 0 + : list_front( arg0 ) ); + struct hash * const vars = source_module->variables; if ( vars ) hashenumerate( vars, add_hash_key, &result ); return result; @@ -1148,13 +1153,17 @@ LIST * builtin_import( FRAME * frame, int flags ) LIST * target_rules = lol_get( frame->args, 3 ); LIST * localize = lol_get( frame->args, 4 ); - module_t * target_module = - bindmodule( !list_empty( target_module_list ) ? list_front( target_module_list ) : 0 ); - module_t * source_module = - bindmodule( !list_empty( source_module_list ) ? list_front( source_module_list ) : 0 ); + module_t * target_module = bindmodule( list_empty( target_module_list ) + ? 0 + : list_front( target_module_list ) ); + module_t * source_module = bindmodule( list_empty( source_module_list ) + ? 0 + : list_front( source_module_list ) ); - LISTITER source_iter = list_begin( source_rules ), source_end = list_end( source_rules ); - LISTITER target_iter = list_begin( target_rules ), target_end = list_end( target_rules ); + LISTITER source_iter = list_begin( source_rules ); + LISTITER const source_end = list_end( source_rules ); + LISTITER target_iter = list_begin( target_rules ); + LISTITER const target_end = list_end( target_rules ); for ( ; source_iter != source_end && target_iter != target_end; @@ -1164,9 +1173,10 @@ LIST * builtin_import( FRAME * frame, int flags ) RULE * r; RULE * imported; - if ( !source_module->rules || - !(r = (RULE *)hash_find( source_module->rules, list_item( source_iter ) ) ) ) - unknown_rule( frame, "IMPORT", source_module, list_item( source_iter ) ); + if ( !source_module->rules || !(r = (RULE *)hash_find( + source_module->rules, list_item( source_iter ) ) ) ) + unknown_rule( frame, "IMPORT", source_module, list_item( source_iter + ) ); imported = import_rule( r, target_module, list_item( target_iter ) ); if ( !list_empty( localize ) ) @@ -1180,7 +1190,8 @@ LIST * builtin_import( FRAME * frame, int flags ) if ( source_iter != source_end || target_iter != target_end ) { backtrace_line( frame->prev ); - printf( "import error: length of source and target rule name lists don't match!\n" ); + printf( "import error: length of source and target rule name lists " + "don't match!\n" ); printf( " source: " ); list_print( source_rules ); printf( "\n target: " ); @@ -1575,13 +1586,14 @@ LIST * builtin_normalize_path( FRAME * frame, int flags ) /* Found a trailing or duplicate '/'. Remove it. */ *current = '\1'; } - else if ( ( end - current == 1 ) && ( *(current + 1) == '.' ) ) + else if ( ( end - current == 1 ) && ( *( current + 1 ) == '.' ) ) { /* Found '/.'. Remove them all. */ *current = '\1'; *(current + 1) = '\1'; } - else if ( ( end - current == 2 ) && ( *(current + 1) == '.' ) && ( *(current + 2) == '.' ) ) + else if ( ( end - current == 2 ) && ( *( current + 1 ) == '.' ) && + ( *( current + 2 ) == '.' ) ) { /* Found '/..'. Remove them all. */ *current = '\1'; @@ -1629,7 +1641,9 @@ LIST * builtin_normalize_path( FRAME * frame, int flags ) * the original path was rooted and we have an empty path we need to add * back the '/'. */ - result = object_new( out->size ? out->value + !rooted : ( rooted ? "/" : "." ) ); + result = object_new( out->size + ? out->value + !rooted + : ( rooted ? "/" : "." ) ); string_free( out ); string_free( in ); @@ -1646,7 +1660,8 @@ LIST * builtin_native_rule( FRAME * frame, int flags ) module_t * module = bindmodule( list_front( module_name ) ); native_rule_t * np; - if ( module->native_rules && (np = (native_rule_t *)hash_find( module->native_rules, list_front( rule_name ) ) ) ) + if ( module->native_rules && (np = (native_rule_t *)hash_find( + module->native_rules, list_front( rule_name ) ) ) ) { new_rule_body( module, np->name, np->procedure, 1 ); } @@ -1654,7 +1669,7 @@ LIST * builtin_native_rule( FRAME * frame, int flags ) { backtrace_line( frame->prev ); printf( "error: no native rule \"%s\" defined in module \"%s.\"\n", - object_str( list_front( rule_name ) ), object_str( module->name ) ); + object_str( list_front( rule_name ) ), object_str( module->name ) ); backtrace( frame->prev ); exit( 1 ); } @@ -1671,7 +1686,8 @@ LIST * builtin_has_native_rule( FRAME * frame, int flags ) module_t * module = bindmodule( list_front( module_name ) ); native_rule_t * np; - if ( module->native_rules && (np = (native_rule_t *)hash_find( module->native_rules, list_front( rule_name ) ) ) ) + if ( module->native_rules && (np = (native_rule_t *)hash_find( + module->native_rules, list_front( rule_name ) ) ) ) { int expected_version = atoi( object_str( list_front( version ) ) ); if ( np->version == expected_version ) @@ -1832,8 +1848,10 @@ LIST * builtin_makedir( FRAME * frame, int flags ) LIST * builtin_python_import_rule( FRAME * frame, int flags ) { static int first_time = 1; - char const * python_module = object_str( list_front( lol_get( frame->args, 0 ) ) ); - char const * python_function = object_str( list_front( lol_get( frame->args, 1 ) ) ); + char const * python_module = object_str( list_front( lol_get( frame->args, + 0 ) ) ); + char const * python_function = object_str( list_front( lol_get( frame->args, + 1 ) ) ); OBJECT * jam_module = list_front( lol_get( frame->args, 2 ) ); OBJECT * jam_rule = list_front( lol_get( frame->args, 3 ) ); @@ -2014,8 +2032,8 @@ PyObject * bjam_call( PyObject * self, PyObject * args ) * - rule name, * - Python callable. * - (optional) bjam language function signature. - * Creates a bjam rule with the specified name in the specified module, which will - * invoke the Python callable. + * Creates a bjam rule with the specified name in the specified module, which + * will invoke the Python callable. */ PyObject * bjam_import_rule( PyObject * self, PyObject * args ) @@ -2309,7 +2327,8 @@ LIST * builtin_shell( FRAME * frame, int flags ) string_new( &s ); - while ( ( ret = fread( buffer, sizeof( char ), sizeof( buffer ) - 1, p ) ) > 0 ) + while ( ( ret = fread( buffer, sizeof( char ), sizeof( buffer ) - 1, p ) ) > + 0 ) { buffer[ ret ] = 0; if ( !no_output_opt ) diff --git a/src/engine/class.c b/src/engine/class.c index 8871d1113..4d7344374 100644 --- a/src/engine/class.c +++ b/src/engine/class.c @@ -3,13 +3,14 @@ /* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ #include "class.h" + +#include "constants.h" +#include "frames.h" +#include "hash.h" +#include "object.h" +#include "rules.h" #include "strings.h" #include "variable.h" -#include "frames.h" -#include "rules.h" -#include "object.h" - -#include "hash.h" static struct hash * classes = 0; @@ -17,12 +18,14 @@ static struct hash * classes = 0; static void check_defined( LIST * class_names ) { - LISTITER iter = list_begin( class_names ), end = list_end( class_names ); + LISTITER iter = list_begin( class_names ); + LISTITER const end = list_end( class_names ); for ( ; iter != end; iter = list_next( iter ) ) { if ( !hash_find( classes, list_item( iter ) ) ) { - printf( "Class %s is not defined\n", object_str( list_item( iter ) ) ); + printf( "Class %s is not defined\n", object_str( list_item( iter ) ) + ); abort(); } } @@ -59,15 +62,15 @@ static void import_base_rule( void * r_, void * d_ ) RULE * ir1; RULE * ir2; struct import_base_data * d = (struct import_base_data *)d_; - string qualified_name[ 1 ]; OBJECT * qname; - string_new ( qualified_name ); + string qualified_name[ 1 ]; + string_new ( qualified_name ); string_append ( qualified_name, object_str( d->base_name ) ); - string_push_back( qualified_name, '.' ); - string_append ( qualified_name, object_str( r->name ) ); - + string_push_back( qualified_name, '.' ); + string_append ( qualified_name, object_str( r->name ) ); qname = object_new( qualified_name->value ); + string_free( qualified_name ); ir1 = import_rule( r, d->class_module, r->name ); ir2 = import_rule( r, d->class_module, qname ); @@ -84,8 +87,6 @@ static void import_base_rule( void * r_, void * d_ ) rule_localize( ir1, d->class_module ); rule_localize( ir2, d->class_module ); } - - string_free( qualified_name ); } @@ -144,21 +145,24 @@ OBJECT * make_class_module( LIST * xname, LIST * bases, FRAME * frame ) var_set( class_module, constant_name, xname, VAR_SET ); var_set( class_module, constant_bases, bases, VAR_SET ); - iter = list_begin( bases ), end = list_end( bases ); + iter = list_begin( bases ); + end = list_end( bases ); for ( ; iter != end; iter = list_next( iter ) ) import_base_rules( class_module, list_item( iter ) ); return name; } + static void free_class( void * xclass, void * data ) { object_free( *(OBJECT * *)xclass ); } + void class_done( void ) { - if( classes ) + if ( classes ) { hashenumerate( classes, free_class, (void *)0 ); hashdone( classes ); diff --git a/src/engine/compile.c b/src/engine/compile.c index ce3bb3bcf..dfac4443f 100644 --- a/src/engine/compile.c +++ b/src/engine/compile.c @@ -10,33 +10,10 @@ * (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) */ -# include "jam.h" - -# include "lists.h" -# include "parse.h" -# include "compile.h" -# include "variable.h" -# include "rules.h" -# include "object.h" -# include "make.h" -# include "search.h" -# include "hdrmacro.h" -# include "hash.h" -# include "modules.h" -# include "strings.h" -# include "builtins.h" -# include "class.h" -# include "constants.h" - -# include -# include -# include - /* * compile.c - compile parsed jam statements * * External routines: - * * compile_append() - append list results of two statements * compile_eval() - evaluate if to determine which leg to compile * compile_foreach() - compile the "for x in y" statement @@ -56,17 +33,34 @@ * compile_switch() - compile 'switch' rule * * Internal routines: - * - * debug_compile() - printf with indent to show rule expansion. + * debug_compile() - printf with indent to show rule expansion * evaluate_rule() - execute a rule invocation - * - * builtin_depends() - DEPENDS/INCLUDES rule - * builtin_echo() - ECHO rule - * builtin_exit() - EXIT rule - * builtin_flags() - NOCARE, NOTFILE, TEMPORARY rule */ -static void debug_compile( int which, const char * s, FRAME * ); +#include "jam.h" +#include "compile.h" + +#include "builtins.h" +#include "class.h" +#include "constants.h" +#include "hash.h" +#include "hdrmacro.h" +#include "lists.h" +#include "make.h" +#include "modules.h" +#include "object.h" +#include "parse.h" +#include "rules.h" +#include "search.h" +#include "strings.h" +#include "variable.h" + +#include +#include +#include + + +static void debug_compile( int which, char const * s, FRAME * ); /* Internal functions from builtins.c */ void backtrace( FRAME * ); @@ -76,7 +70,7 @@ void unknown_rule( FRAME *, char const * key, module_t *, OBJECT * rule_name ); /* - * evaluate_rule() - execute a rule invocation. + * evaluate_rule() - execute a rule invocation */ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) @@ -91,13 +85,14 @@ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) if ( DEBUG_COMPILE ) { /* Try hard to indicate in which module the rule is going to execute. */ - if ( rule->module != frame->module - && rule->procedure != 0 && !object_equal( rulename, function_rulename( rule->procedure ) ) ) + if ( rule->module != frame->module && rule->procedure && !object_equal( + rulename, function_rulename( rule->procedure ) ) ) { - char buf[256] = ""; + char buf[ 256 ] = ""; if ( rule->module->name ) { - strncat( buf, object_str( rule->module->name ), sizeof( buf ) - 1 ); + strncat( buf, object_str( rule->module->name ), sizeof( buf ) - + 1 ); strncat( buf, ".", sizeof( buf ) - 1 ); } strncat( buf, object_str( rule->name ), sizeof( buf ) - 1 ); @@ -150,11 +145,12 @@ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) /* If we have a group of targets all being built using the same action * then we must not allow any of them to be used as sources unless they - * had all already been built in the first place or their joined action - * has had a chance to finish its work and build all of them anew. + * are all up to date and their action does not need to be run or their + * action has had a chance to finish its work and build all of them + * anew. * * Without this it might be possible, in case of a multi-process build, - * for their action, triggered by buiding one of the targets, to still + * for their action, triggered to building one of the targets, to still * be running when another target in the group reports as done in order * to avoid triggering the same action again and gets used prematurely. * @@ -168,7 +164,7 @@ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) * dependency' issue. * * TODO: Although the current implementation solves the problem of one - * of the targets getting used before its action completes its work it + * of the targets getting used before its action completes its work, it * also forces the action to run whenever any of the targets in the * group is not up to date even though some of them might not actually * be used by the targets being built. We should see how we can @@ -182,7 +178,7 @@ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) */ if ( action->targets ) { - TARGET * t0 = action->targets->target; + TARGET * const t0 = action->targets->target; for ( t = action->targets->next; t; t = t->next ) { target_include( t->target, t0 ); @@ -198,13 +194,12 @@ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) } /* Now recursively compile any parse tree associated with this rule. - * function_refer()/function_free() call pair added to ensure rule not freed - * during use. + * function_refer()/function_free() call pair added to ensure the rule does + * not get freed while in use. */ if ( rule->procedure ) { - FUNCTION * function = rule->procedure; - + FUNCTION * const function = rule->procedure; function_refer( function ); result = function_run( function, frame, stack_global() ); function_free( function ); @@ -214,7 +209,7 @@ LIST * evaluate_rule( OBJECT * rulename, FRAME * frame ) profile_exit( prof ); if ( DEBUG_COMPILE ) - debug_compile( -1, 0, frame); + debug_compile( -1, 0, frame ); return result; } @@ -234,17 +229,18 @@ LIST * call_rule( OBJECT * rulename, FRAME * caller_frame, ... ) va_list va; LIST * result; - FRAME inner[1]; + FRAME inner[ 1 ]; frame_init( inner ); inner->prev = caller_frame; - inner->prev_user = caller_frame->module->user_module ? - caller_frame : caller_frame->prev_user; + inner->prev_user = caller_frame->module->user_module + ? caller_frame + : caller_frame->prev_user; inner->module = caller_frame->module; va_start( va, caller_frame ); for ( ; ; ) { - LIST * l = va_arg( va, LIST* ); + LIST * const l = va_arg( va, LIST * ); if ( !l ) break; lol_add( inner->args, l ); @@ -259,12 +255,11 @@ LIST * call_rule( OBJECT * rulename, FRAME * caller_frame, ... ) } - /* - * debug_compile() - printf with indent to show rule expansion. + * debug_compile() - printf with indent to show rule expansion */ -static void debug_compile( int which, const char * s, FRAME * frame ) +static void debug_compile( int which, char const * s, FRAME * frame ) { static int level = 0; static char indent[36] = ">>>>|>>>>|>>>>|>>>>|>>>>|>>>>|>>>>|"; diff --git a/src/engine/filent.c b/src/engine/filent.c index 7d7ba9388..ac9633f84 100644 --- a/src/engine/filent.c +++ b/src/engine/filent.c @@ -38,7 +38,6 @@ # include # endif # undef FILENAME /* cpp namespace collision */ -# define _finddata_t ffblk #endif #define WIN32_LEAN_AND_MEAN @@ -59,7 +58,6 @@ int file_collect_dir_content_( file_info_t * const d ) PATHNAME f; string pathspec[ 1 ]; string pathname[ 1 ]; - struct _finddata_t finfo[ 1 ]; LIST * files = L0; int d_length; @@ -90,34 +88,38 @@ int file_collect_dir_content_( file_info_t * const d ) } #if defined(__BORLANDC__) && __BORLANDC__ < 0x550 - if ( findfirst( pathspec->value, finfo, FA_NORMAL | FA_DIREC ) ) { - string_free( pathspec ); - return -1; - } - - string_new( pathname ); - do - { - f.f_base.ptr = finfo->ff_name; - f.f_base.len = strlen( finfo->ff_name ); - string_truncate( pathname, 0 ); - path_build( &f, pathname ); - - files = list_push_back( files, object_new( pathname->value ) ); + struct ffblk finfo; + if ( findfirst( pathspec->value, &finfo, FA_NORMAL | FA_DIREC ) ) { - file_info_t * const ff = file_info( pathname->value ); - ff->is_file = finfo->ff_attrib & FA_DIREC ? 0 : 1; - ff->is_dir = !ff->is_file; - ff->size = finfo->ff_fsize; - timestamp_init( &ff->time, ( finfo->ff_ftime << 16 ) | - finfo->ff_ftime, 0 ); + string_free( pathspec ); + return -1; } + + string_new( pathname ); + do + { + f.f_base.ptr = finfo.ff_name; + f.f_base.len = strlen( finfo.ff_name ); + string_truncate( pathname, 0 ); + path_build( &f, pathname ); + + { + file_info_t * const ff = file_info( pathname->value ); + ff->is_dir = finfo.ff_attrib & FA_DIREC ? 1 : 0; + ff->is_file = !ff->is_dir; + ff->size = finfo.ff_fsize; + timestamp_init( &ff->time, ( finfo.ff_ftime << 16 ) | + finfo.ff_ftime, 0 ); + files = list_push_back( files, object_new( pathname->value ) ); + } + } + while ( !findnext( &finfo ) ); } - while ( !findnext( finfo ) ); #else /* defined(__BORLANDC__) && __BORLANDC__ < 0x550 */ { - long const handle = _findfirst( pathspec->value, finfo ); + struct _finddata_t finfo; + long const handle = _findfirst( pathspec->value, &finfo ); if ( handle < 0L ) { string_free( pathspec ); @@ -129,23 +131,23 @@ int file_collect_dir_content_( file_info_t * const d ) { OBJECT * pathname_obj; - f.f_base.ptr = finfo->name; - f.f_base.len = strlen( finfo->name ); + f.f_base.ptr = finfo.name; + f.f_base.len = strlen( finfo.name ); string_truncate( pathname, 0 ); - path_build( &f, pathname, 0 ); + path_build( &f, pathname ); pathname_obj = object_new( pathname->value ); path_key__register_long_path( pathname_obj ); files = list_push_back( files, pathname_obj ); { file_info_t * const ff = file_info( pathname_obj ); - ff->is_file = finfo->attrib & _A_SUBDIR ? 0 : 1; - ff->is_dir = !ff->is_file; - ff->size = finfo->size; - timestamp_init( &ff->time, finfo->time_write, 0 ); + ff->is_dir = finfo.attrib & _A_SUBDIR ? 1 : 0; + ff->is_file = !ff->is_dir; + ff->size = finfo.size; + timestamp_init( &ff->time, finfo.time_write, 0 ); } } - while ( !_findnext( handle, finfo ) ); + while ( !_findnext( handle, &finfo ) ); _findclose( handle ); } diff --git a/src/engine/fileunix.c b/src/engine/fileunix.c index 68d80a9de..339533a5c 100644 --- a/src/engine/fileunix.c +++ b/src/engine/fileunix.c @@ -134,7 +134,7 @@ int file_collect_dir_content_( file_info_t * const d ) f.f_base.len = strlen( f.f_base.ptr ); string_truncate( path, 0 ); - path_build( &f, path, 0 ); + path_build( &f, path ); files = list_push_back( files, object_new( path->value ) ); } string_free( path ); diff --git a/src/engine/function.c b/src/engine/function.c index d3bf56092..7465c02eb 100644 --- a/src/engine/function.c +++ b/src/engine/function.c @@ -631,7 +631,7 @@ static void var_edit_file( char const * in, string * out, VAR_EDITS * edits ) path_parent( &pathname ); /* Put filename back together. */ - path_build( &pathname, out, 0 ); + path_build( &pathname, out ); } else string_append( out, in ); diff --git a/src/engine/modules/order.c b/src/engine/modules/order.c index ed632be3a..dd0f3f1e3 100644 --- a/src/engine/modules/order.c +++ b/src/engine/modules/order.c @@ -2,146 +2,157 @@ /* Software License, Version 1.0. (See accompanying */ /* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ -#include "../native.h" #include "../lists.h" -#include "../strings.h" +#include "../mem.h" +#include "../native.h" #include "../object.h" +#include "../strings.h" #include "../variable.h" -/* Use quite klugy approach: when we add order dependency from 'a' to 'b', - just append 'b' to of value of variable 'a'. -*/ -LIST *add_pair( FRAME *frame, int flags ) +/* Use quite klugy approach: when we add order dependency from 'a' to 'b', just + * append 'b' to of value of variable 'a'. + */ +LIST * add_pair( FRAME * frame, int flags ) { - LIST* arg = lol_get( frame->args, 0 ); - LISTITER iter = list_begin( arg ), end = list_end( arg ); - - var_set( frame->module, list_item( iter ), list_copy_range( arg, list_next( iter ), end ), VAR_APPEND ); - + LIST * arg = lol_get( frame->args, 0 ); + LISTITER iter = list_begin( arg ); + LISTITER const end = list_end( arg ); + var_set( frame->module, list_item( iter ), list_copy_range( arg, list_next( + iter ), end ), VAR_APPEND ); return L0; } -/** Given a list and a value, returns position of that value in - the list, or -1 if not found. -*/ -int list_index(LIST* list, OBJECT* value) + +/* Given a list and a value, returns position of that value in the list, or -1 + * if not found. + */ +int list_index( LIST * list, OBJECT * value ) { int result = 0; - LISTITER iter = list_begin(list), end = list_end(list); - for(; iter != end; iter = list_next(iter), ++result) { - if (object_equal(list_item(iter), value)) + LISTITER iter = list_begin( list ); + LISTITER const end = list_end( list ); + for ( ; iter != end; iter = list_next( iter ), ++result ) + if ( object_equal( list_item( iter ), value ) ) return result; - } return -1; } enum colors { white, gray, black }; -/* Main routite of topological sort. Calls itself recursively on all - adjacent vertices which were not yet visited. After that, 'current_vertex' - is added to '*result_ptr'. -*/ -void do_ts(int** graph, int current_vertex, int* colors, int** result_ptr) + +/* Main routine for topological sort. Calls itself recursively on all adjacent + * vertices which were not yet visited. After that, 'current_vertex' is added to + * '*result_ptr'. + */ +void do_ts( int * * graph, int current_vertex, int * colors, int * * result_ptr + ) { int i; - colors[current_vertex] = gray; - for(i = 0; graph[current_vertex][i] != -1; ++i) { - int adjacent_vertex = graph[current_vertex][i]; - - if (colors[adjacent_vertex] == white) - do_ts(graph, adjacent_vertex, colors, result_ptr); - /* The vertex is either black, in which case we don't have to do - anything, a gray, in which case we have a loop. If we have a loop, - it's not clear what useful diagnostic we can emit, so we emit - nothing. */ + colors[ current_vertex ] = gray; + for ( i = 0; graph[ current_vertex ][ i ] != -1; ++i ) + { + int adjacent_vertex = graph[ current_vertex ][ i ]; + if ( colors[ adjacent_vertex ] == white ) + do_ts( graph, adjacent_vertex, colors, result_ptr ); + /* The vertex is either black, in which case we do not have to do + * anything, or gray, in which case we have a loop. If we have a loop, + * it is not clear what useful diagnostic we can emit, so we emit + * nothing. + */ } - colors[current_vertex] = black; - **result_ptr = current_vertex; - (*result_ptr)++; + colors[ current_vertex ] = black; + **result_ptr = current_vertex; + ( *result_ptr )++; } -void topological_sort(int** graph, int num_vertices, int* result) + +void topological_sort( int * * graph, int num_vertices, int * result ) { int i; - int* colors = (int*)BJAM_CALLOC(num_vertices, sizeof(int)); - for (i = 0; i < num_vertices; ++i) - colors[i] = white; + int * colors = ( int * )BJAM_CALLOC( num_vertices, sizeof( int ) ); + for ( i = 0; i < num_vertices; ++i ) + colors[ i ] = white; - for(i = 0; i < num_vertices; ++i) - if (colors[i] == white) - do_ts(graph, i, colors, &result); + for ( i = 0; i < num_vertices; ++i ) + if ( colors[ i ] == white ) + do_ts( graph, i, colors, &result ); - BJAM_FREE(colors); + BJAM_FREE( colors ); } -LIST *order( FRAME *frame, int flags ) + +LIST * order( FRAME * frame, int flags ) { - LIST* arg = lol_get( frame->args, 0 ); - LIST* result = L0; + LIST * arg = lol_get( frame->args, 0 ); + LIST * result = L0; int src; - LISTITER iter = list_begin(arg), end = list_end(arg); + LISTITER iter = list_begin( arg ); + LISTITER const end = list_end( arg ); - /* We need to create a graph of order dependencies between - the passed objects. We assume that there are no duplicates - passed to 'add_pair'. - */ - int length = list_length(arg); - int** graph = (int**)BJAM_CALLOC(length, sizeof(int*)); - int* order = (int*)BJAM_MALLOC((length+1)*sizeof(int)); - - for(src = 0; iter != end; iter = list_next(iter), ++src) { - /* For all object this one depend upon, add elements - to 'graph' */ - LIST* dependencies = var_get(frame->module, list_item(iter)); + /* We need to create a graph of order dependencies between the passed + * objects. We assume there are no duplicates passed to 'add_pair'. + */ + int length = list_length( arg ); + int * * graph = ( int * * )BJAM_CALLOC( length, sizeof( int * ) ); + int * order = ( int * )BJAM_MALLOC( ( length + 1 ) * sizeof( int ) ); + + for ( src = 0; iter != end; iter = list_next( iter ), ++src ) + { + /* For all objects this one depends upon, add elements to 'graph'. */ + LIST * dependencies = var_get( frame->module, list_item( iter ) ); int index = 0; - LISTITER dep_iter = list_begin(dependencies), dep_end = list_end(dependencies); + LISTITER dep_iter = list_begin( dependencies ); + LISTITER const dep_end = list_end( dependencies ); - graph[src] = (int*)BJAM_CALLOC(list_length(dependencies)+1, sizeof(int)); - for(; dep_iter != dep_end; dep_iter = list_next(dep_iter)) { - int dst = list_index(arg, list_item(dep_iter)); - if (dst != -1) - graph[src][index++] = dst; + graph[ src ] = ( int * )BJAM_CALLOC( list_length( dependencies ) + 1, + sizeof( int ) ); + for ( ; dep_iter != dep_end; dep_iter = list_next( dep_iter ) ) + { + int const dst = list_index( arg, list_item( dep_iter ) ); + if ( dst != -1 ) + graph[ src ][ index++ ] = dst; } - graph[src][index] = -1; + graph[ src ][ index ] = -1; } - topological_sort(graph, length, order); + topological_sort( graph, length, order ); { - int index = length-1; - for(; index >= 0; --index) { + int index = length - 1; + for ( ; index >= 0; --index ) + { int i; - iter = list_begin(arg), end = list_end(arg); - for (i = 0; i < order[index]; ++i, iter = list_next(iter)); - result = list_push_back(result, object_copy(list_item(iter))); + LISTITER iter = list_begin( arg ); + LISTITER const end = list_end( arg ); + for ( i = 0; i < order[ index ]; ++i, iter = list_next( iter ) ); + result = list_push_back( result, object_copy( list_item( iter ) ) ); } } /* Clean up */ { int i; - for(i = 0; i < length; ++i) - BJAM_FREE(graph[i]); - BJAM_FREE(graph); - BJAM_FREE(order); + for ( i = 0; i < length; ++i ) + BJAM_FREE( graph[ i ] ); + BJAM_FREE( graph ); + BJAM_FREE( order ); } return result; } + void init_order() { { - const char* args[] = { "first", "second", 0 }; - declare_native_rule("class@order", "add-pair", args, add_pair, 1); + char const * args[] = { "first", "second", 0 }; + declare_native_rule( "class@order", "add-pair", args, add_pair, 1 ); } { - const char* args[] = { "objects", "*", 0 }; - declare_native_rule("class@order", "order", args, order, 1); + char const * args[] = { "objects", "*", 0 }; + declare_native_rule( "class@order", "order", args, order, 1 ); } - - } diff --git a/src/engine/modules/property-set.c b/src/engine/modules/property-set.c index 9d0c5cf63..20ef0d7cf 100644 --- a/src/engine/modules/property-set.c +++ b/src/engine/modules/property-set.c @@ -2,29 +2,33 @@ /* Software License, Version 1.0. (See accompanying */ /* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ +#include "../compile.h" +#include "../lists.h" #include "../native.h" -#include "../timestamp.h" #include "../object.h" #include "../strings.h" -#include "../lists.h" +#include "../timestamp.h" #include "../variable.h" -#include "../compile.h" -LIST* get_grist(char* f) +#include + + +LIST * get_grist( char const * const f ) { - char* end = strchr(f, '>'); - string s[1]; - LIST* result; + char const * const end = strchr( f, '>' ); + string s[ 1 ]; + LIST * result; - string_new(s); + string_new( s ); - string_append_range(s, f, end+1); - result = list_new(object_new(s->value)); + string_append_range( s, f, end + 1 ); + result = list_new( object_new( s->value ) ); - string_free(s); + string_free( s ); return result; } + /* rule create ( raw-properties * ) { @@ -41,77 +45,57 @@ rule create ( raw-properties * ) } */ -LIST *property_set_create( FRAME *frame, int flags ) +LIST * property_set_create( FRAME * frame, int flags ) { - LIST* properties = lol_get( frame->args, 0 ); - LIST* sorted = L0; -#if 0 - LIST* order_sensitive = 0; -#endif - LIST* unique; - LIST* val; - string var[1]; - OBJECT* name; - LISTITER iter, end; + LIST * properties = lol_get( frame->args, 0 ); + LIST * sorted = L0; + LIST * unique; + LIST * val; + string var[ 1 ]; + OBJECT * name; + LISTITER iter; + LISTITER end; -#if 0 - /* Sort all properties which are not order sensitive */ - for(tmp = properties; tmp; tmp = tmp->next) { - LIST* g = get_grist(tmp->string); - LIST* att = call_rule("feature.attributes", frame, g, 0); - if (list_in(att, "order-sensitive")) { - order_sensitive = list_new( order_sensitive, copystr(tmp->string)); - } else { - sorted = list_new( sorted, copystr(tmp->string)); - } - list_free(att); - } + sorted = list_sort( properties ); + unique = list_unique( sorted ); - sorted = list_sort(sorted); - sorted = list_append(sorted, order_sensitive); - unique = list_unique(sorted); -#endif - sorted = list_sort(properties); - unique = list_unique(sorted); + string_new( var ); + string_append( var, ".ps." ); - string_new(var); - string_append(var, ".ps."); - - iter = list_begin( unique ), end = list_end( unique ); - for( ; iter != end; iter = list_next( iter ) ) { - string_append(var, object_str( list_item( iter ) )); - string_push_back(var, '-'); - } - name = object_new(var->value); - val = var_get(frame->module, name); - if (list_empty(val)) + iter = list_begin( unique ); + end = list_end( unique ); + for ( ; iter != end; iter = list_next( iter ) ) { - OBJECT* rulename = object_new("new"); - val = call_rule(rulename, frame, - list_append(list_new(object_new("property-set")), unique), 0); - object_free(rulename); - - var_set(frame->module, name, list_copy(val), VAR_SET); + string_append( var, object_str( list_item( iter ) ) ); + string_push_back( var, '-' ); + } + name = object_new( var->value ); + val = var_get( frame->module, name ); + if ( list_empty( val ) ) + { + OBJECT * const rulename = object_new( "new" ); + val = call_rule( rulename, frame, list_append( list_new( object_new( + "property-set" ) ), unique ), 0 ); + /* The 'unique' variable is freed in 'call_rule'. */ + object_free( rulename ); + var_set( frame->module, name, list_copy( val ), VAR_SET ); } else { - list_free(unique); - val = list_copy(val); + list_free( unique ); + val = list_copy( val ); } - object_free(name); - - string_free(var); - /* The 'unique' variable is freed in 'call_rule'. */ - list_free(sorted); + object_free( name ); + string_free( var ); + list_free( sorted ); return val; - } + void init_property_set() { - { - const char* args[] = { "raw-properties", "*", 0 }; - declare_native_rule("property-set", "create", args, property_set_create, 1); - } + char const * args[] = { "raw-properties", "*", 0 }; + declare_native_rule( "property-set", "create", args, property_set_create, 1 + ); } diff --git a/src/engine/modules/regex.c b/src/engine/modules/regex.c index 9002f4bad..6f7593336 100644 --- a/src/engine/modules/regex.c +++ b/src/engine/modules/regex.c @@ -2,12 +2,13 @@ /* Software License, Version 1.0. (See accompanying */ /* file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) */ -#include "../native.h" -#include "../timestamp.h" -#include "../object.h" -#include "../strings.h" -#include "../regexp.h" #include "../compile.h" +#include "../mem.h" +#include "../native.h" +#include "../object.h" +#include "../regexp.h" +#include "../strings.h" + /* rule transform ( list * : pattern : indices * ) @@ -20,62 +21,65 @@ rule transform ( list * : pattern : indices * ) if $(m) { result += $(m[$(indices)]) ; - } + } } return $(result) ; } */ -LIST *regex_transform( FRAME *frame, int flags ) + +LIST * regex_transform( FRAME * frame, int flags ) { - LIST* l = lol_get( frame->args, 0 ); - LIST* pattern = lol_get( frame->args, 1 ); - LIST* indices_list = lol_get(frame->args, 2); - int* indices = 0; + LIST * l = lol_get( frame->args, 0 ); + LIST * pattern = lol_get( frame->args, 1 ); + LIST * indices_list = lol_get( frame->args, 2 ); + int * indices = 0; int size; - int* p; + int * p; LIST* result = L0; - string buf[1]; - string_new(buf); + string buf[ 1 ]; + string_new( buf ); - if (!list_empty(indices_list)) + if ( !list_empty( indices_list ) ) { - LISTITER iter = list_begin(indices_list), end = list_end(indices_list); - size = list_length(indices_list); - indices = (int*)BJAM_MALLOC(size*sizeof(int)); - for(p = indices; iter != end; iter = list_next(iter)) - { - *p++ = atoi(object_str(list_item(iter))); - } + LISTITER iter = list_begin( indices_list ); + LISTITER const end = list_end( indices_list ); + size = list_length( indices_list ); + indices = ( int * )BJAM_MALLOC( size * sizeof( int ) ); + for ( p = indices; iter != end; iter = list_next( iter ) ) + *p++ = atoi( object_str( list_item( iter ) ) ); } - else + else { size = 1; - indices = (int*)BJAM_MALLOC(sizeof(int)); + indices = ( int * )BJAM_MALLOC( sizeof( int ) ); *indices = 1; } { /* Result is cached and intentionally never freed */ - regexp *re = regex_compile( list_front( pattern ) ); + regexp * re = regex_compile( list_front( pattern ) ); - LISTITER iter = list_begin( l ), end = list_end( l ); - for( ; iter != end; iter = list_next( iter ) ) + LISTITER iter = list_begin( l ); + LISTITER const end = list_end( l ); + for ( ; iter != end; iter = list_next( iter ) ) { - if( regexec( re, object_str( list_item( iter ) ) ) ) + if ( regexec( re, object_str( list_item( iter ) ) ) ) { int i = 0; - for(; i < size; ++i) + for ( ; i < size; ++i ) { - int index = indices[i]; - /* Skip empty submatches. Not sure it's right in all cases, - but surely is right for the case for which this routine - is optimized -- header scanning. - */ - if (re->startp[index] != re->endp[index]) + int index = indices[ i ]; + /* Skip empty submatches. Not sure it is right in all cases, + * but surely is right for the case for which this routine + * is optimized -- header scanning. + */ + if ( re->startp[ index ] != re->endp[ index ] ) { - string_append_range( buf, re->startp[index], re->endp[index] ); - result = list_push_back( result, object_new( buf->value ) ); + string_append_range( buf, re->startp[ index ], + re->endp[ index ] ); + result = list_push_back( result, object_new( buf->value + ) ); string_truncate( buf, 0 ); } } @@ -84,15 +88,15 @@ LIST *regex_transform( FRAME *frame, int flags ) string_free( buf ); } - BJAM_FREE(indices); - + BJAM_FREE( indices ); + return result; } + void init_regex() { - { - const char* args[] = { "list", "*", ":", "pattern", ":", "indices", "*", 0 }; - declare_native_rule("regex", "transform", args, regex_transform, 2); - } + char const * args[] = { "list", "*", ":", "pattern", ":", "indices", "*", 0 + }; + declare_native_rule( "regex", "transform", args, regex_transform, 2 ); } diff --git a/src/engine/pathsys.h b/src/engine/pathsys.h index c76dfed00..65af6d6fa 100644 --- a/src/engine/pathsys.h +++ b/src/engine/pathsys.h @@ -47,9 +47,7 @@ struct _pathname #define f_member part[ 5 ] }; -void path_build( PATHNAME * f, string * file, int binding ); -void path_build1( PATHNAME * f, string * file ); - +void path_build( PATHNAME * f, string * file ); void path_parse( char const * file, PATHNAME * f ); void path_parent( PATHNAME * f ); diff --git a/src/engine/pathunix.c b/src/engine/pathunix.c index 0d54e4487..b6457b498 100644 --- a/src/engine/pathunix.c +++ b/src/engine/pathunix.c @@ -169,7 +169,7 @@ static char as_path_delim( char const c ) * in 'timestamp.c'. */ -void path_build( PATHNAME * f, string * file, int binding ) +void path_build( PATHNAME * f, string * file ) { file_build1( f, file ); @@ -185,8 +185,7 @@ void path_build( PATHNAME * f, string * file, int binding ) { string_append_range( file, f->f_root.ptr, f->f_root.ptr + f->f_root.len ); - /* If 'root' already ends with a path delimeter, do not add yet another - * one. + /* If 'root' already ends with a path delimeter, do not add another one. */ if ( !is_path_delim( f->f_root.ptr[ f->f_root.len - 1 ] ) ) string_push_back( file, as_path_delim( f->f_root.ptr[ f->f_root.len diff --git a/src/engine/regexp.c b/src/engine/regexp.c index b51b85b09..c64201b90 100644 --- a/src/engine/regexp.c +++ b/src/engine/regexp.c @@ -45,10 +45,11 @@ #include "jam.h" #include "regexp.h" + #include #include #ifndef ultrix - #include +# include #endif #include diff --git a/src/engine/regexp.h b/src/engine/regexp.h index fccfb7dff..6898ccdce 100644 --- a/src/engine/regexp.h +++ b/src/engine/regexp.h @@ -5,28 +5,30 @@ * not the System V one. */ #ifndef REGEXP_DWA20011023_H -# define REGEXP_DWA20011023_H +#define REGEXP_DWA20011023_H #define NSUBEXP 10 typedef struct regexp { - const char *startp[NSUBEXP]; - const char *endp[NSUBEXP]; + char const * startp[ NSUBEXP ]; + char const * endp[ NSUBEXP ]; char regstart; /* Internal use only. */ char reganch; /* Internal use only. */ - char *regmust; /* Internal use only. */ + char * regmust; /* Internal use only. */ int regmlen; /* Internal use only. */ - char program[1]; /* Unwarranted chumminess with compiler. */ + char program[ 1 ]; /* Unwarranted chumminess with compiler. */ } regexp; -regexp *regcomp( const char *exp ); -int regexec( regexp *prog, const char *string ); -void regerror( const char *s ); + +regexp * regcomp( char const * exp ); +int regexec( regexp * prog, char const * string ); +void regerror( char const * s ); + /* * The first byte of the regexp internal "program" is actually this magic * number; the start node begins in the second byte. */ -#define MAGIC 0234 +#define MAGIC 0234 #endif diff --git a/src/engine/rules.c b/src/engine/rules.c index 40155af94..aaf9649b9 100644 --- a/src/engine/rules.c +++ b/src/engine/rules.c @@ -32,17 +32,15 @@ #include "hash.h" #include "lists.h" -#include "modules.h" #include "object.h" #include "parse.h" #include "pathsys.h" #include "search.h" -#include "timestamp.h" #include "variable.h" static void set_rule_actions( RULE *, rule_actions * ); -static void set_rule_body ( RULE *, FUNCTION * procedure ); +static void set_rule_body ( RULE *, FUNCTION * ); static struct hash * targethash = 0; @@ -74,9 +72,8 @@ void target_include( TARGET * including, TARGET * included ) static RULE * enter_rule( OBJECT * rulename, module_t * target_module ) { int found; - RULE * r; - - r = (RULE *)hash_insert( demand_rules(target_module), rulename, &found ); + RULE * const r = (RULE *)hash_insert( demand_rules( target_module ), + rulename, &found ); if ( !found ) { r->name = object_copy( rulename ); @@ -129,7 +126,7 @@ void rule_free( RULE * r ) * bindtarget() - return pointer to TARGET, creating it if necessary. */ -TARGET * bindtarget( OBJECT * target_name ) +TARGET * bindtarget( OBJECT * const target_name ) { int found; TARGET * t; @@ -187,9 +184,9 @@ void bind_explicitly_located_targets() * Not entered into the hash table -- for internal nodes. */ -TARGET * copytarget( const TARGET * ot ) +TARGET * copytarget( TARGET const * ot ) { - TARGET * t = (TARGET *)BJAM_MALLOC( sizeof( *t ) ); + TARGET * const t = (TARGET *)BJAM_MALLOC( sizeof( *t ) ); memset( (char *)t, '\0', sizeof( *t ) ); t->name = object_copy( ot->name ); t->boundname = object_copy( t->name ); @@ -202,7 +199,7 @@ TARGET * copytarget( const TARGET * ot ) * touch_target() - mark a target to simulate being new. */ -void touch_target( OBJECT * t ) +void touch_target( OBJECT * const t ) { bindtarget( t )->flags |= T_FLAG_TOUCHED; } diff --git a/src/engine/rules.h b/src/engine/rules.h index 933188162..4230325bc 100644 --- a/src/engine/rules.h +++ b/src/engine/rules.h @@ -29,8 +29,6 @@ #ifndef RULES_DWA_20011020_H #define RULES_DWA_20011020_H -#include "jam.h" - #include "function.h" #include "modules.h" #include "timestamp.h" @@ -217,9 +215,14 @@ struct _target int asynccnt; /* child deps outstanding */ TARGETS * parents; /* used by make1() for completion */ - TARGET * scc_root; /* used by make to resolve cyclic includes */ - TARGET * rescanning; /* used by make0 to mark visited targets when rescanning */ - int depth; /* The depth of the target in the make0 stack. */ + TARGET * scc_root; /* used by make to resolve cyclic includes + */ + TARGET * rescanning; /* used by make0 to mark visited targets + * when rescanning + */ + int depth; /* The depth of the target in the make0 + * stack. + */ char * cmds; /* type-punned command list */ char const * failed; @@ -231,8 +234,8 @@ void action_free ( ACTION * ); ACTIONS * actionlist ( ACTIONS *, ACTION * ); void freeactions ( ACTIONS * ); SETTINGS * addsettings ( SETTINGS *, int flag, OBJECT * symbol, LIST * value ); -void pushsettings ( struct module_t * module, SETTINGS * ); -void popsettings ( struct module_t * module, SETTINGS * ); +void pushsettings ( module_t *, SETTINGS * ); +void popsettings ( module_t *, SETTINGS * ); SETTINGS * copysettings ( SETTINGS * ); void freesettings ( SETTINGS * ); void actions_refer( rule_actions * ); @@ -248,16 +251,17 @@ void rule_free ( RULE * ); /* Target related functions. */ void bind_explicitly_located_targets(); -TARGET * bindtarget ( OBJECT * target_name ); +TARGET * bindtarget ( OBJECT * const ); TARGET * copytarget ( TARGET const * t ); void freetargets ( TARGETS * ); -TARGETS * targetchain ( TARGETS * chain, TARGETS * ); -TARGETS * targetentry ( TARGETS * chain, TARGET * ); -void target_include ( TARGET * including, TARGET * included ); -TARGETS * targetlist ( TARGETS * chain, LIST * target_names ); -void touch_target ( OBJECT * t ); +TARGETS * targetchain ( TARGETS *, TARGETS * ); +TARGETS * targetentry ( TARGETS *, TARGET * ); +void target_include ( TARGET * including, + TARGET * included ); +TARGETS * targetlist ( TARGETS *, LIST * target_names ); +void touch_target ( OBJECT * const ); void clear_includes ( TARGET * ); -TARGET * target_scc ( TARGET * t ); +TARGET * target_scc ( TARGET * ); /* Final module cleanup. */ void rules_done(); diff --git a/src/engine/search.c b/src/engine/search.c index 23790866f..6602ed879 100644 --- a/src/engine/search.c +++ b/src/engine/search.c @@ -119,7 +119,7 @@ OBJECT * search( OBJECT * target, timestamp * const time, f->f_root.ptr = object_str( list_front( varlist ) ); f->f_root.len = strlen( object_str( list_front( varlist ) ) ); - path_build( f, buf, 1 ); + path_build( f, buf ); if ( DEBUG_SEARCH ) printf( "locate %s: %s\n", object_str( target ), buf->value ); @@ -147,7 +147,7 @@ OBJECT * search( OBJECT * target, timestamp * const time, f->f_root.len = strlen( object_str( list_item( iter ) ) ); string_truncate( buf, 0 ); - path_build( f, buf, 1 ); + path_build( f, buf ); if ( DEBUG_SEARCH ) printf( "search %s: %s\n", object_str( target ), buf->value ); @@ -194,7 +194,7 @@ OBJECT * search( OBJECT * target, timestamp * const time, f->f_root.len = 0; string_truncate( buf, 0 ); - path_build( f, buf, 1 ); + path_build( f, buf ); if ( DEBUG_SEARCH ) printf( "search %s: %s\n", object_str( target ), buf->value ); diff --git a/src/engine/timestamp.c b/src/engine/timestamp.c index 551581d46..5b1a26441 100644 --- a/src/engine/timestamp.c +++ b/src/engine/timestamp.c @@ -189,7 +189,7 @@ void timestamp_from_path( timestamp * const time, OBJECT * const path ) f2 = f1; f2.f_grist.len = 0; path_parent( &f2 ); - path_build( &f2, buf, 0 ); + path_build( &f2, buf ); name = object_new( buf->value ); @@ -222,7 +222,7 @@ void timestamp_from_path( timestamp * const time, OBJECT * const path ) f2.f_grist.len = 0; f2.f_member.len = 0; string_truncate( buf, 0 ); - path_build( &f2, buf, 0 ); + path_build( &f2, buf ); name = object_new( buf->value ); diff --git a/src/util/print.jam b/src/util/print.jam index 708d21aba..bd1a8fafc 100644 --- a/src/util/print.jam +++ b/src/util/print.jam @@ -1,8 +1,8 @@ -# Copyright 2003 Douglas Gregor -# Copyright 2002, 2003, 2005 Rene Rivera -# Copyright 2002, 2003, 2004, 2005 Vladimir Prus -# Distributed under the Boost Software License, Version 1.0. -# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) +# Copyright 2003 Douglas Gregor +# Copyright 2002, 2003, 2005 Rene Rivera +# Copyright 2002, 2003, 2004, 2005 Vladimir Prus +# Distributed under the Boost Software License, Version 1.0. +# (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) # Utilities for generating format independent output. Using these # will help in generation of documentation in at minimum plain/console @@ -242,7 +242,7 @@ rule split-at-words ( local t = "" ; # divide s into the first X characters and the rest s = [ MATCH "^($(char-match))(.*)" : $(text) ] ; - + if $(s[2]) { # split the first half at a space @@ -252,12 +252,12 @@ rule split-at-words ( { t = $(s) ; } - + if ! $(t[2]) { t += "" ; } - + text = $(t[2])$(s[2]) ; lines += $(t[1]) ; } @@ -270,9 +270,9 @@ rule split-at-words ( # split them with
. # rule lines ( - text * # The lines of text. - : indent ? # Optional indentation prepended to each line after the first one. - outdent ? # Optional indentation to prepend to the first line. + text * # The lines of text. + : indent ? # Optional indentation prepended to each line after the first. + outdent ? # Optional indentation to prepend to the first line. ) { text ?= "" ; @@ -307,9 +307,10 @@ rule lines ( # output using this rule. # rule text ( - strings * # The strings of text to output. - : overwrite ? # true to overwrite the output (if it is a file) - : prefix-body-suffix ? # Indication to output prefix, body, or suffix (for a file). + strings * # The strings of text to output. + : overwrite ? # True to overwrite the output (if it is a file). + : prefix-body-suffix ? # Indication to output prefix, body, or suffix (for + # a file). ) { prefix-body-suffix ?= body ; @@ -333,7 +334,7 @@ rule text ( $(output-target).text-prefix = ; $(output-target).text-body = ; $(output-target).text-suffix = ; - + nl on $(output-target) = " " ; text-redirect on $(output-target) = ">>" ; @@ -342,7 +343,7 @@ rule text ( text-redirect on $(output-target) = ">" ; } text-content on $(output-target) = ; - + text-action $(output-target) ; if $(overwrite) && $(output-target) != console @@ -412,11 +413,10 @@ rule get-scanner ( ) } -# The following code to update print targets when their contents -# change is a horrible hack. It basically creates a target which -# binds to this file (print.jam) and installs a scanner on it -# which reads the target and compares its contents to the new -# contents that we're writing. +# The following code to update print targets when their contents change is a +# horrible hack. It basically creates a target which binds to this file +# (print.jam) and installs a scanner on it which reads the target and compares +# its contents to the new contents that we are writing. # rule check-for-update ( target ) { @@ -475,7 +475,7 @@ class print-scanner : scanner rule __test__ ( ) { import assert ; - + assert.result one two three : split-at-words one two three : 5 ; assert.result "one two" three : split-at-words one two three : 8 ; assert.result "one two" three : split-at-words one two three : 9 ; diff --git a/test/dependency-test/foo.jam b/test/dependency-test/foo.jam index 1cf44681d..8c284f9e2 100644 --- a/test/dependency-test/foo.jam +++ b/test/dependency-test/foo.jam @@ -3,10 +3,11 @@ # Distributed under the Boost Software License, Version 1.0. # (See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt) -import type ; import generators ; +import modules ; import os ; import print ; +import type ; type.register FOO : foo ; @@ -17,16 +18,14 @@ nl = " rule foo ( targets * : sources * : properties * ) { - # On NT, you need an exported symbol in order to have an - # import lib generated - # We won't really use the symbol defined here, just force - # lib creation. + # On NT, you need an exported symbol in order to have an import library + # generated. We will not really use the symbol defined here, just force the + # import library creation. if ( [ os.name ] = NT || [ modules.peek : OS ] in CYGWIN ) && LIB in $(properties) { .decl = "void __declspec(dllexport) foo(){}" ; } - print.output $(<[1]) ; print.text $(.decl:E="//")$(nl) ; print.output $(<[2]) ;