boost/build
2
0
Fork 0
mirror of https://github.com/boostorg/build.git synced 2026-02-09 23:12:23 +00:00
Code Issues Projects Releases Wiki Activity

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).

Browse Source 
[SVN r79569]
This commit is contained in:
Jurko Gospodnetić
2012-07-17 08:56:49 +00:00
parent 145ce56f80
commit c16ae1c68a
21 changed files with 526 additions and 490 deletions
Download Patch File Download Diff File Expand all files Collapse all files

145
src/build/scanner.jam
View File

@@ -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 ;

42
src/build/virtual-target.jam
View File

@@ -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 <implcit-dependecy> properties. For all targets of type
# referred by <implicit-dependecy> 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.
#

85
src/engine/builtins.c
View File

@@ -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 )

36
src/engine/class.c
View File

@@ -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 );

101
src/engine/compile.c
View File

@@ -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 <assert.h>
# include <string.h>
# include <stdarg.h>
/*
* compile.c - compile parsed jam statements
*
* External routines:
*
* compile_append() - append list results of two statements
* compile_eval() - evaluate if to determine which leg to compile
* compile_foreach() - compile the "for x in y" statement
@@ -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 <assert.h>
#include <stdarg.h>
#include <string.h>
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] = ">>>>|>>>>|>>>>|>>>>|>>>>|>>>>|>>>>|";

66
src/engine/filent.c
View File

@@ -38,7 +38,6 @@
# include <dos.h>
# 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 );
}

2
src/engine/fileunix.c
View File

@@ -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 );

2
src/engine/function.c
View File

@@ -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 );

179
src/engine/modules/order.c
View File

@@ -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 );
}
}

122
src/engine/modules/property-set.c
View File

@@ -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 <string.h>
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
);
}

90
src/engine/modules/regex.c
View File

@@ -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 );
}

4
src/engine/pathsys.h
View File

@@ -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 );

5
src/engine/pathunix.c
View File

@@ -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

3
src/engine/regexp.c
View File

@@ -45,10 +45,11 @@
#include "jam.h"
#include "regexp.h"
#include <stdio.h>
#include <ctype.h>
#ifndef ultrix
#include <stdlib.h>
# include <stdlib.h>
#endif
#include <string.h>

20
src/engine/regexp.h
View File

@@ -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

17
src/engine/rules.c
View File

@@ -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;
}

32
src/engine/rules.h
View File

@@ -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();

6
src/engine/search.c
View File

@@ -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 );

4
src/engine/timestamp.c
View File

@@ -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 );

44
src/util/print.jam
View File

@@ -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 <br>.
#
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 ;

11
test/dependency-test/foo.jam
View File

@@ -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 )
&& <main-target-type>LIB in $(properties)
{
.decl = "void __declspec(dllexport) foo(){}" ;
}
print.output $(<[1]) ;
print.text $(.decl:E="//")$(nl) ;
print.output $(<[2]) ;