boost/build
2
0
Fork 0
mirror of https://github.com/boostorg/build.git synced 2026-02-21 02:52:12 +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

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