Boost logo

Boost-Commit :

From: jurko.gospodnetic_at_[hidden]
Date: 2008-01-05 13:29:37


Author: jurko
Date: 2008-01-05 13:29:36 EST (Sat, 05 Jan 2008)
New Revision: 42492
URL: http://svn.boost.org/trac/boost/changeset/42492

Log:
Removed trailing spaces and some empty lines.
Text files modified:
   trunk/tools/build/v2/kernel/modules.jam | 78 ++++++++++++++++++++--------------------
   trunk/tools/jam/src/builtins.c | 5 +-
   trunk/tools/jam/src/modules/property-set.c | 33 ++++++++--------
   trunk/tools/jam/src/native.c | 10 ++---
   4 files changed, 61 insertions(+), 65 deletions(-)

Modified: trunk/tools/build/v2/kernel/modules.jam
==============================================================================
--- trunk/tools/build/v2/kernel/modules.jam (original)
+++ trunk/tools/build/v2/kernel/modules.jam 2008-01-05 13:29:36 EST (Sat, 05 Jan 2008)
@@ -1,7 +1,7 @@
-# Copyright 2003 Dave Abrahams
-# Copyright 2003, 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 2003, 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)
 
 # Essentially an include guard; ensures that no module is loaded multiple times
 .loaded ?= ;
@@ -76,7 +76,7 @@
     local module-rule = [ MATCH (.*)\\.(.*) : $(qualified-rule-name) ] ;
     local rule-name = $(module-rule[2]) ;
     rule-name ?= $(qualified-rule-name) ;
- return [
+ return [
       call-in $(module-rule[1])
         : $(rule-name) $(args) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9)
     ] ;
@@ -93,23 +93,23 @@
     if ! ( $(module-name) in $(.loaded) )
     {
         filename ?= $(module-name).jam ;
-
+
         # Mark the module loaded so we don't try to load it recursively
         .loaded += $(module-name) ;
-
- # suppress tests if any module loads are already in progress.
+
+ # suppress tests if any module loads are already in progress.
         local suppress-test = $(.loading[1]) ;
-
+
         # Push this module on the loading stack
         .loading += $(module-name) ;
-
+
         # Remember that it's untested
- .untested += $(module-name) ;
-
+ .untested += $(module-name) ;
+
         # Insert the new module's __name__ and __file__ globals
         poke $(module-name) : __name__ : $(module-name) ;
         poke $(module-name) : __file__ : $(filename) ;
-
+
         module $(module-name)
         {
             # Prepare a default behavior, in case no __test__ is defined.
@@ -117,14 +117,14 @@
 
             # Add some grist so that the module will have a unique target name
             local module-target = $(__file__:G=module@) ;
-
+
             local search = $(3) ;
             search ?= [ modules.peek : BOOST_BUILD_PATH ] ;
             SEARCH on $(module-target) = $(search) ;
             BINDRULE on $(module-target) = modules.record-binding ;
-
+
             include $(module-target) ;
-
+
             # Allow the module to see its own names with full qualification
             local rules = [ RULENAMES $(__name__) ] ;
             IMPORT $(__name__) : $(rules) : $(__name__) : $(__name__).$(rules) ;
@@ -135,10 +135,10 @@
             import errors ;
             errors.error "couldn't find module" $(module-name) in $(search) ;
         }
-
+
         # Pop the loading stack. Must happen before testing or we'll find a circular loading dependency
         .loading = $(.loading[1--2]) ;
-
+
         # Run any pending tests if this is an outer load
         if ! $(suppress-test)
         {
@@ -153,20 +153,20 @@
                     {
                         ECHO testing module $(m)... ;
                     }
-
+
                     # Import m's rules into __test-$(m)__ for easy access
                     IMPORT $(m) : [ RULENAMES $(m) ] : __test-$(m)__ : [ RULENAMES $(m) ] ;
-
+
                     # execute the module's __test__ rule in its own module to
                     # eliminate the inadvertent effects of testing
                     # module dependencies (such as assert) on the module itself.
                     IMPORT $(m) : __test__ : __test-$(m)__ : __test__ : LOCALIZE ;
-
+
                     module __test-$(m)__
                     {
                         # set up the name of the module we're testing
                         # so that no-test-defined can find it.
- __module__ = $(1) ;
+ __module__ = $(1) ;
                         __test__ ;
                     }
                 }
@@ -218,51 +218,51 @@
 # elements as rules-opt.
 rule import ( module-names + : rules-opt * : rename-opt * )
 {
- if $(rules-opt) = * || ! $(rules-opt)
+ if $(rules-opt) = * || ! $(rules-opt)
     {
         if $(rename-opt)
         {
             errors.error "rule aliasing is only available for explicit imports." ;
         }
     }
-
+
     if $(module-names[2]) && ( $(rules-opt) || $(rename-opt) )
     {
         errors.error when loading multiple modules, no specific rules or renaming is allowed ;
     }
-
- local caller = [ CALLER_MODULE ] ;
-
+
+ local caller = [ CALLER_MODULE ] ;
+
     # Import each specified module
     for local m in $(module-names)
     {
         if ! $(m) in $(.loaded)
- {
+ {
             # if the importing module isn't already in the BOOST_BUILD_PATH,
             # prepend it to the path. We don't want to invert the search
             # order of modules that are already there.
-
- local caller-location ;
+
+ local caller-location ;
             if $(caller)
             {
                 caller-location = [ binding $(caller) ] ;
                 caller-location = $(caller-location:D) ;
                 caller-location = [ normalize-raw-paths $(caller-location:R=$(.cwd)) ] ;
             }
-
+
             local search = [ peek : BOOST_BUILD_PATH ] ;
             search = [ normalize-raw-paths $(search:R=$(.cwd)) ] ;
-
+
             if $(caller-location) && ! $(caller-location) in $(search)
             {
                 search = $(caller-location) $(search) ;
             }
-
+
             load $(m) : : $(search) ;
         }
-
+
         IMPORT_MODULE $(m) : $(caller) ;
-
+
         if $(rules-opt)
         {
             local source-names ;
@@ -288,11 +288,11 @@
 # were defined originally in $(target-module).
 rule clone-rules (
     source-module
- target-module
+ target-module
     )
 {
     local rules = [ RULENAMES $(source-module) ] ;
-
+
     IMPORT $(source-module) : $(rules) : $(target-module) : $(rules) : LOCALIZE ;
     EXPORT $(target-module) : $(rules) ;
     IMPORT $(target-module) : $(rules) : : $(target-module).$(rules) ;
@@ -307,12 +307,12 @@
 {
     import assert ;
     import modules : normalize-raw-paths ;
-
+
     module modules.__test__
     {
         foo = bar ;
     }
-
+
     assert.result bar : peek modules.__test__ : foo ;
     poke modules.__test__ : foo : bar baz ;
     assert.result bar baz : peek modules.__test__ : foo ;

Modified: trunk/tools/jam/src/builtins.c
==============================================================================
--- trunk/tools/jam/src/builtins.c (original)
+++ trunk/tools/jam/src/builtins.c 2008-01-05 13:29:36 EST (Sat, 05 Jan 2008)
@@ -1087,15 +1087,14 @@
 
     module_t* m = bindmodule( module_list ? module_list->string : 0 );
     
-
     for ( ; rules; rules = list_next( rules ) )
     {
         RULE r_, *r = &r_;
         r_.name = rules->string;
-
+
         if ( !m->rules || !hashcheck( m->rules, (HASHDATA**)&r ) )
             unknown_rule( frame, "EXPORT", m->name, r_.name );
-
+
         r->exported = 1;
     }
     return L0;

Modified: trunk/tools/jam/src/modules/property-set.c
==============================================================================
--- trunk/tools/jam/src/modules/property-set.c (original)
+++ trunk/tools/jam/src/modules/property-set.c 2008-01-05 13:29:36 EST (Sat, 05 Jan 2008)
@@ -15,12 +15,12 @@
     char* end = strchr(f, '>');
     string s[1];
     LIST* result;
-
+
     string_new(s);
 
     string_append_range(s, f, end+1);
     result = list_new(0, newstr(s->value));
-
+
     string_free(s);
     return result;
 }
@@ -28,22 +28,22 @@
 /*
 rule create ( raw-properties * )
 {
- raw-properties = [ sequence.unique
+ raw-properties = [ sequence.unique
         [ sequence.insertion-sort $(raw-properties) ] ] ;
-
+
     local key = $(raw-properties:J=-:E=) ;
-
- if ! $(.ps.$(key))
+
+ if ! $(.ps.$(key))
     {
         .ps.$(key) = [ new property-set $(raw-properties) ] ;
     }
- return $(.ps.$(key)) ;
+ return $(.ps.$(key)) ;
 }
 */
 
 LIST *property_set_create( PARSE *parse, FRAME *frame )
 {
- LIST* properties = lol_get( frame->args, 0 );
+ LIST* properties = lol_get( frame->args, 0 );
     LIST* sorted = 0;
     LIST* order_sensitive = 0;
     LIST* unique;
@@ -63,7 +63,7 @@
         }
         list_free(att);
     }
-
+
     sorted = list_sort(sorted);
     sorted = list_append(sorted, order_sensitive);
     unique = list_unique(sorted);
@@ -73,24 +73,24 @@
 
     string_new(var);
     string_append(var, ".ps.");
-
+
     for(tmp = unique; tmp; tmp = tmp->next) {
         string_append(var, tmp->string);
         string_push_back(var, '-');
     }
     val = var_get(var->value);
- if (val == 0)
- {
- val = call_rule("new", frame,
- list_append(list_new(0, "property-set"), unique), 0);
-
+ if (val == 0)
+ {
+ val = call_rule("new", frame,
+ list_append(list_new(0, "property-set"), unique), 0);
+
         var_set(newstr(var->value), list_copy(0, val), VAR_SET);
     }
     else
     {
         val = list_copy(0, val);
     }
-
+
     string_free(var);
     /* The 'unique' variable is freed in 'call_rule'. */
     list_free(sorted);
@@ -105,5 +105,4 @@
         char* args[] = { "raw-properties", "*", 0 };
         declare_native_rule("property-set", "create", args, property_set_create, 1);
     }
-
 }

Modified: trunk/tools/jam/src/native.c
==============================================================================
--- trunk/tools/jam/src/native.c (original)
+++ trunk/tools/jam/src/native.c 2008-01-05 13:29:36 EST (Sat, 05 Jan 2008)
@@ -9,15 +9,14 @@
 # define C0 (char *)0
 
 
-void declare_native_rule(char* module, char* rule, char** args,
+void declare_native_rule(char* module, char* rule, char** args,
                          LIST*(*f)(PARSE*, FRAME*), int version)
-
 {
     module_t* m = bindmodule(module);
     if (m->native_rules == 0) {
         m->native_rules = hashinit( sizeof( native_rule_t ), "native rules");
     }
-
+
     {
         native_rule_t n, *np = &n;
         n.name = rule;
@@ -25,14 +24,13 @@
         {
             n.arguments = args_new();
             lol_build( n.arguments->data, args );
- }
+ }
         else
         {
             n.arguments = 0;
         }
- n.procedure = parse_make( f, P0, P0, P0, C0, C0, 0 );
+ n.procedure = parse_make( f, P0, P0, P0, C0, C0, 0 );
         n.version = version;
         hashenter(m->native_rules, (HASHDATA**)&np);
     }
 }
-


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk