Re: Help with generators and variable targets

From: quancta (quancta_at_[hidden])
Date: 2004-03-20 12:13:32

Christopher,

Wow, that's much more than I would expect! Your solution is
much better than my newbie approach with what I learned so
far about generators and BJam in general.

Thanks so much,
Quan 

--- In jamboost_at_[hidden], Christopher Currie <Christopher_at_C...>
wrote:
> Quan,
> 
> I spent a lot of time working on this problem, for the xsd2cpp tool
that 
> also comes with LEIF. I went through a number of different
iterations, 
> and eventually settled on the usage below. It should be adaptable
to 
> wsdl2cpp without much trouble.
> 
> The usage is probably not all you'd like, but it works the best of
all 
> the approaches I've tried. The key is that you have to specify the
names 
> of all the source files that the tool generates, because there
really 
> isn't any way we can expect bjam to deduce them. An example Jamfile 
> would look like:
> 
> # Jamfile
> 
> SOURCES = one two three ;
> 
> schema myschema
> : myschema.xsd
> : $(SOURCES).cpp $(SOURCES).h
> : <ol:config>xsdconfig.xml
> ;
> 
> lib libmyschema : myschema : : <dependency>myschema 
> <implicit-dependency>myschema ;
> 
> # end of Jamfile
> 
> The apparently redundant usage-requirements are necessary to achieve
two 
> goals. The <dependency> property ensures that the schema gets built 
> first, so that sources that use the library's header files will
have 
> them available. The <implicit-dependency> property puts the path to
the 
> generated headers in the include path of dependent main-targets.
> 
> The file that implements the schema rule is below. Adapting it to 
> process wsdl files *should* be trivial, but let me know if you have
trouble.
> 
> Good luck!
> Christopher
> 
> 
> 
> # objectlink.jam
> 
> import "class" : new ;
> import feature ;
> import toolset : flags ;
> import targets ;
> import type ;
> import virtual-target ;
> 
> 
> class xsd-cpp-target-class : basic-target
> {
> import sequence ;
> import regex ;
> import type ;
> import virtual-target ;
> 
> rule __init__ ( name : project : targets * : source :
requirements *
> : default-build * : usage-requirements *
> )
> {
> basic-target.__init__ $(name) : $(project) : $(source)
> : $(requirements) : $(default-build) :
$(usage-requirements)
> ;
> 
> self.targets = $(targets) ;
> self.file-targets = ;
> }
> 
> rule construct ( schema-target : property-set )
> {
> if ! $(self.file-targets)
> {
> for local name in $(self.targets)
> {
> local _t = [ new file-target $(name:S=)
> : [ type.type $(name) ]
> : $(self.project)
> ] ;
> $(_t).suffix = [ regex.match .(.*) :
$(self.name:S) ] ;
> 
> # This is needed so the generators know where to
find
> # the headers but don't complain about unused
sources
> if [ type.is-derived [ type.type $(name) ] H ]
> {
> $(_t).set-itermediate true ;
> }
> 
> virtual-target.register $(_t) ;
> self.file-targets += $(_t) ;
> }
> 
> # This has to be done separately from the for loop
above,
> # because the action must know about ALL the
virtual-targets
> # it generates, and all the virtual-targets must have
the
> # same action
> #
> # Third argument binds action to the schema-compile
rule
> local _a = [ new action $(self.file-targets)
> : $(schema-target)
> : objectlink.schema-compile
> : $(property-set)
> ] ;
> 
> for local name in $(self.file-targets)
> {
> $(name).action $(_a) ;
> }
> }
> return $(self.file-targets) ;
> }
> }
> 
> rule schema ( name
> : source # only one!
> : targets + # the generated sources and headers
> : requirements *
> : default-build *
> : usage-requirements *
> )
> {
> local project = [ CALLER_MODULE ] ;
> 
> return [ targets.main-target-alternative
> [ new xsd-cpp-target-class $(name) : $(project) : $(targets)
> : [ targets.main-target-sources $(source) : $(name) ]
> : [ targets.main-target-requirements $(requirements)
> : $(project) ]
> : [ targets.main-target-default-build $(default-build)
> : $(project) ]
> : [ targets.main-target-usage-requirements
$(usage-requirements)
> : $(project) ]
> ]
> ] ;
> }
> IMPORT $(__name__) : schema : : schema ;
> 
> feature.feature ol:config : : free path incidental ;
> feature.feature ol:docsdir : : free path incidental ;
> feature.feature ol:docs : on off : incidental ;
> feature.feature ol:make : on off : incidental ;
> 
> # Note "flags" don't work, because it's not a "toolset"
> 
> rule schema-compile
> {
> _ on $(targets) = " " ;
> 
> CONFIG on $(targets) = [ feature.get-values <ol:config>
> : $(properties) ] ;
> 
> if off in [ feature.get-values <ol:docs> : $(properties) ]
> {
> OPTIONS on $(targets) += "-nohtml" ;
> }
> else
> {
> DOCSDIR on $(targets) = [ feature.get-values <ol:docsdir>
> : $(properties) ] ;
> }
> 
> if off in [ feature.get-values <ol:make> : $(properties) ]
> {
> OPTIONS on $(targets) += "-nomake" ;
> }
> }
> 
> # xsd2cpp doesn't touch files if they don't need to change, which
mucks
> # up dependency tracking, causing bjam to rebuild the schema every
time
> actions schema-compile
> {
> xsd2cpp -outdir "$(<[1]:D)" "-config$(_)$(CONFIG)" \
> "-docsdir$(_)$(DOCSDIR)" $(OPTIONS) "$(>)" && touch "$(<)"
> }
> 
> 
> 
> quancta wrote:
> > Hi BJam'ers,
> > 
> > I am working on a project that use RogueWave LEIF tool to generate
> > C++ code from a webservice schema with this command:
> > wsdl2cpp.bat [options] webservice.wsdl
> > which produces a bunches of CPP files that need to be compiled
into
> > a library. Hope someone can help me with the target spec; how
can
> > I tell bjam that the targets is all the *.cpp files generated ?
> > 
> > I have this module - test.jam as follow:
> > #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > type.register WSDL : wsdl ;
> > generators.register-standard test.wsdl : WSDL : CPP H ;
> > 
> > rule wsdl ( targets * : sources * : properties * )
> > {
> > .leif_dir = C:/RogueWave/LEIF ;
> > .leif_wsdl2cpp = $(.leif_dir)/bin/wsdl2cpp.bat -noserver
-nosample
> > -nossl -nohtml -SourcePro ;
> > }
> > 
> > actions wsdl
> > {
> > del /Q $(<[1]:D)\\*.cpp $(<[1]:D)\\*.h
> > $(.leif_wsdl2cpp) -outdir $(<[1]:D) $(>)
> > }
> > #++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> > 
> > Then in my Jamfile:
> > lib webservice : webservice.wsdl ;
> > 
> > but that will only get me webservice.cpp into the build. I've
trying
> > with glob, etc., but haven't figured out anything that work.
> > 
> > TIA,
> > Quan