boost/build
2
0
Fork 0
mirror of https://github.com/boostorg/build.git synced 2026-02-01 20:32:17 +00:00
Code Issues Projects Releases Wiki Activity

Allow a generator's 'run' method to return additional usage requirements

Browse Source 
as the first elements of result. Those usage requirements will be combined
with explicitly specified for the main target.

This is yet another step towards making 'main target classes' unnecessary.

* build/generators.jam
  (try-one-generator): Check if generator returned usage requirements or not.
  (construct): Make sure first element of result is always property set.
  (many other methods): Induced changes

* tools/builtin.jam
  (exe-target-class, lib-target-class): Remove.
  (linking-generator, seached-lib-generator): Compute usage requirements.
  (archiving-generator): New class


[SVN r26192]
This commit is contained in:
Vladimir Prus
2004-11-12 08:11:14 +00:00
parent db35bd11a1
commit 40a504ed4f
14 changed files with 196 additions and 181 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
src/build/alias.jam
View File

@@ -30,6 +30,7 @@ import errors : error ;
import type : type ;
import regex ;
import project ;
import property-set ;
class alias-target-class : basic-target
{
@@ -42,7 +43,7 @@ class alias-target-class : basic-target
rule construct ( source-targets * : property-set )
{
return $(source-targets) ;
return [ property-set.empty ] $(source-targets) ;
}
# This check makes no sense for 'alias', so just

63
src/build/generators.jam
View File

@@ -46,6 +46,7 @@ import utility : str equal ;
import set sequence ;
import assert ;
import virtual-target ;
import property-set ;
if "--debug-generators" in [ modules.peek : ARGV ]
{
@@ -84,7 +85,8 @@ local rule decrease-indent ( )
# regardless of their order.
rule normalize-target-list ( targets )
{
$(targets).sort ;
local v = [ $(targets).get ] ;
$(targets).set $(v[1]) [ sequence.insertion-sort $(v[2-]) : utility.less ] ;
}
# Creates a generator
@@ -478,7 +480,8 @@ class generator
# its best to convert everything to the required type.
# There's no need to rerun it on targets of different types.
for local t in $(transformed)
# NOTE: ignoring usage requirements
for local t in $(transformed[2-])
{
if [ $(t).type ] in $(missing-types)
{
@@ -696,7 +699,7 @@ rule base-to-derived-type-conversion ( targets * : target-types +
}
# Returns usage requirements + list of created targets
local rule try-one-generator ( project name ? : generator multiple ? :
target-type : property-set : sources * )
{
@@ -711,7 +714,18 @@ local rule try-one-generator ( project name ? : generator multiple ? :
local result ;
# Generated target of other types.
local extra ;
local usage-requirements ;
if $(targets) && [ class.is-a $(targets[1]) : property-set ]
{
usage-requirements = $(targets[1]) ;
targets = $(targets[2-]) ;
}
else
{
usage-requirements = [ property-set.empty ] ;
}
base-to-derived-type-conversion $(targets) : $(target-type)
: result extra ;
@@ -729,8 +743,8 @@ local rule try-one-generator ( project name ? : generator multiple ? :
:
: $(property-set)
: $(e) ] ;
result += $(try2) ;
usage-requirements = [ $(usage-requirements).add $(try2[1]) ] ;
result += $(try2[2-]) ;
}
}
else
@@ -739,6 +753,10 @@ local rule try-one-generator ( project name ? : generator multiple ? :
}
generators.dout [ indent ] " generator" [ $(generator).id ] " spawned " ;
generators.dout [ indent ] " " $(result) -- $(extra2) ;
if $(targets)
{
result = $(usage-requirements) $(result) ;
}
return $(result) $(extra2) ;
}
@@ -747,13 +765,15 @@ rule construct-types ( project name ? : target-types + : multiple ? :
{
local result ;
local matched-types ;
local usage-requirements = [ property-set.empty ] ;
for local t in $(target-types)
{
local r = [ construct $(project) $(name) : $(t) $(multiple) : $(property-set) :
$(sources) ] ;
if $(r)
{
result += $(r) ;
usage-requirements = [ $(usage-requirements).add $(r[1]) ] ;
result += $(r[2-]) ;
matched-types += $(t) ;
}
}
@@ -767,11 +787,11 @@ rule construct-types ( project name ? : target-types + : multiple ? :
# imply that, contrary to the behaviour.
if $(result)
{
return $(result) ;
return $(usage-requirements) $(result) ;
}
else
{
return $(sources) ;
return $(usage-requirements) $(sources) ;
}
}
@@ -887,7 +907,8 @@ local rule select-dependency-graph ( options )
for local r in [ $(options).get ]
{
normalize-target-list $(r) ;
generators.dout $(r) ;
local v = [ $(r).get ] ;
generators.dout $(v[2-]) ;
}
# One note why we can compare object names directly,
@@ -897,10 +918,14 @@ local rule select-dependency-graph ( options )
# So, two elements can only be equivalent, if they are just
# the same object.
local f = [ $(options).at 1 ] ;
f = [ $(f).get ] ;
f = $(f[2-]) ;
local mismatch ;
for local r in [ $(results).get ]
for local r in [ $(options).get ]
{
if [ $(r).get ] != [ $(f).get ]
local v = [ $(r).get ] ;
v = $(v[2-]) ;
if $(f) != $(v)
{
mismatch = true ;
}
@@ -908,7 +933,8 @@ local rule select-dependency-graph ( options )
if ! $(mismatch)
{
return [ $(f).get ] ;
local v = [ $(options).at 1 ] ;
return [ $(v).get ] ;
}
else
{
@@ -954,8 +980,9 @@ local rule construct-with-caching (
# Substitute the real source name in the transformation template.
if $(cresult)
{
result += $(cresult[1]) ;
generators.dout [ indent ] "*** putting to cache?" ;
for local c in $(cresult)
for local c in $(cresult[2-])
{
generators.dout [ indent ] "*** cloning " $(c) ;
local cc = [ virtual-target.clone-template $(c) : $(t) : $(project) ] ;
@@ -1075,11 +1102,17 @@ rule construct ( project name ? : target-type multiple ? : property-set * : sour
result += $(intermediate) ;
}
if $(result)
{
assert.true class.is-a $(result[1]) : property-set ;
}
# For all targets of 'allowed-type', reset the 'intermediate' attribute.
if ! $(.construct-stack) && $(allowed-type) != * # This is first invocation in stack
{
local result2 ;
for local t in $(result)
for local t in $(result[2-])
{
local type = [ $(t).type ] ;
# Return only targets of the requested type, unless 'return-all'

4
src/build/targets.jam
View File

@@ -1022,11 +1022,15 @@ class basic-target : abstract-target
local result =
[ construct $(source-targets) : $(rproperties) ] ;
local gur = $(result[1]) ;
result = $(result[2-]) ;
local s = [ create-subvariant $(result) : $(property-set) : $(source-targets)
: $(rproperties) : $(usage-requirements) ] ;
local ur = [ compute-usage-requirements $(s) ] ;
ur = [ $(ur).add $(gur) ] ;
$(s).set-usage-requirements $(ur) ;
self.generated.$(property-set) = $(ur) $(result) ;

2
src/tools/borland.jam
View File

@@ -48,7 +48,7 @@ type.register BORLAND.TDS : tds ;
generators.register-linker borland.link : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : EXE RSP : <toolset>borland ;
generators.register-linker borland.link.dll : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : SHARED_LIB IMPORT_LIB RSP : <toolset>borland ;
generators.register-composing borland.archive : OBJ : STATIC_LIB : <toolset>borland ;
generators.register-archiver borland.archive : OBJ : STATIC_LIB : <toolset>borland ;
generators.register-c-compiler borland.compile.c++ : CPP : OBJ : <toolset>borland ;
generators.register-c-compiler borland.compile.c : C : OBJ : <toolset>borland ;

271
src/tools/builtin.jam
View File

@@ -261,8 +261,8 @@ declare-type : SHARED_LIB : so : LIB : main ;
declare-type : SEARCHED_LIB : : LIB : main ;
declare-type NT CYGWIN : EXE : exe : : ;
declare-type : EXE : : : ;
declare-type NT CYGWIN : EXE : exe : : main ;
declare-type : EXE : : : main ;
declare-type : PYTHON_EXTENSION : : SHARED_LIB : main ;
# We can't give "dll" suffix to PYTHON_EXTENSION, because
@@ -338,21 +338,18 @@ type.register H : h ;
type.register HPP : hpp : H ;
type.register C : c ;
class lib-target-class : basic-target
# The generator class for libraries (target type LIB). Depending on properties it will
# request building of the approapriate specific type -- SHARED_LIB, STATIC_LIB or
# SHARED_LIB.
class lib-generator : generator
{
import generators : construct : generators.construct ;
import type ;
import path ;
rule __init__ ( name : project
: sources * : requirements * : default-build * : usage-requirements * )
{
basic-target.__init__ $(name) : $(project)
: $(sources) : $(requirements) : $(default-build) : $(usage-requirements) ;
rule __init__ ( * : * )
{
generator.__init__ $(1) : $(2) : $(3) : $(4) : $(5) : $(6) : $(7) : $(8) : $(9) ;
}
rule construct ( source-targets * : property-set )
{
rule run ( project name ? : property-set : sources * : multiple ? )
{
local properties = [ $(property-set).raw ] ;
# Determine the needed target type
local actual-type ;
@@ -375,67 +372,17 @@ class lib-target-class : basic-target
}
property-set = [ $(property-set).add-raw <main-target-type>LIB ] ;
# Construct the target.
return [ generators.construct $(self.project) $(self.name) : $(actual-type)
: $(property-set) : $(source-targets) : LIB ] ;
}
rule compute-usage-requirements ( subvariant )
{
local rproperties = [ $(subvariant).build-properties ] ;
local created-targets = [ $(subvariant).created-targets ] ;
local result = [ basic-target.compute-usage-requirements $(subvariant) ] ;
# For lib targets with <search>, add the value of <search> as <library-path>
# usage requirement.
local search = [ $(rproperties).get <search> ] ;
if $(search)
{
result = [ $(result).add [
property-set.create $(search:G=<library-path>) ] ] ;
}
# Add appropricate <xdll-path> usage requirements.
local raw = [ $(rproperties).raw ] ;
if <link>shared in $(raw)
{
local paths ;
local pwd = [ path.pwd ] ;
for local t in $(created-targets)
{
if [ type.is-derived [ $(t).type ] SHARED_LIB ]
{
paths += [ path.root [ path.make [ $(t).path ] ] $(pwd) ] ;
}
}
if $(paths)
{
result = [ $(result).add
[ property-set.create $(paths:G=<xdll-path>) ] ] ;
}
}
# Pass <xdll-path> features that we've got from sources.
local u = [ $(subvariant).sources-usage-requirements ] ;
local values = [ $(u).get <xdll-path> ] ;
result = [ $(result).add-raw $(values:G=<xdll-path>) ] ;
# For libraries that we've failed to consume, we need to
# pass <library-path> usage requirements, if any.
# We look at all generated target, and if they are created in different
# subvariant, we add usage requirements.
for local t in [ $(subvariant).created-targets ]
{
local s = [ $(t).creating-subvariant ] ;
if $(s) != $(subvariant)
{
result = [ $(result).add [ $(s).usage-requirements ] ] ;
}
}
return $(result) ;
}
return [ generators.construct $(project) $(name) : $(actual-type)
: $(property-set) : $(sources) : LIB ] ;
}
}
generators.register [ new lib-generator builtin.lib-generator : : LIB ] ;
# The implementation of the 'lib' rule. Beyond standard syntax that rule allows
# simplified:
# lib a b c ;
# so we need to write code to handle that syntax.
rule lib ( names + : sources * : requirements * : default-build *
: usage-requirements * )
{
@@ -452,7 +399,7 @@ rule lib ( names + : sources * : requirements * : default-build *
{
result += [
targets.main-target-alternative
[ new lib-target-class $(name) : $(project)
[ new typed-target $(name) : $(project) : LIB
:
: [ targets.main-target-requirements $(requirements) <name>$(name) :
$(project) ]
@@ -471,7 +418,7 @@ rule lib ( names + : sources * : requirements * : default-build *
local name = $(names[1]) ;
result = [ targets.main-target-alternative
[ new lib-target-class $(name) : $(project)
[ new typed-target $(name) : $(project) : LIB
: [ targets.main-target-sources $(sources) : $(name) ]
: [ targets.main-target-requirements $(requirements) : $(project) ]
: [ targets.main-target-default-build $(default-build) : $(project) ]
@@ -482,73 +429,10 @@ rule lib ( names + : sources * : requirements * : default-build *
}
IMPORT $(__name__) : lib : : lib ;
class exe-target-class : typed-target
{
import type ;
rule __init__ ( name : project
: sources * : requirements * : default-build * : usage-requirements * )
{
typed-target.__init__ $(name) : $(project) : EXE
: $(sources) : $(requirements) : $(default-build) : $(usage-requirements) ;
}
rule compute-usage-requirements ( subvariant )
{
local result = [ typed-target.compute-usage-requirements $(subvariant) ] ;
local p = [ $(subvariant).build-properties ] ;
local xdll-paths = [ $(p).get <xdll-path> ] ;
if $(xdll-paths)
{
result = [ $(result).add-raw $(xdll-paths:G=<xdll-path>) ] ;
}
return $(result) ;
}
rule check-for-unused-sources ( result * : sources * )
{
# For exes, we typically don't consume ignore DLL on windows.
# We also handle searched libraries via special properties
# on actions, so should not check for search libraries.
# As the result, we don't check for unused LIB sources
# at all.
local sources-to-check ;
for local s in $(sources)
{
if ! [ type.is-derived [ $(s).type ] LIB ]
{
sources-to-check += $(s) ;
}
}
basic-target.check-for-unused-sources $(result) : $(sources-to-check) ;
}
}
rule exe ( name : sources * : requirements * : default-build *
: usage-requirements * )
{
local project = [ project.current ] ;
# This is a circular module dependency, so it must be imported here
import targets ;
targets.main-target-alternative
[ new exe-target-class $(name) : $(project)
: [ targets.main-target-sources $(sources) : $(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__) : exe : : exe ;
class searched-lib-generator : generator
{
import property-set ;
rule __init__ ( )
{
# The requirements cause the generators to be tried *only* when we're building
@@ -584,9 +468,19 @@ class searched-lib-generator : generator
# lib png : z : <name>png ;
# the 'z' target should be returned, so that apps linking to
# 'png' will link to 'z', too.
return [ virtual-target.register $(t) ] $(sources) ;
return [ extra-usage-requirements $(property-set) ] [ virtual-target.register $(t) ] $(sources) ;
}
}
rule extra-usage-requirements ( property-set )
{
# Add the value of <search> as <library-path>
# usage requirement.
local search = [ $(property-set).get <search> ] ;
search = $(search:G=<library-path>) ;
return [ property-set.create $(search) ] ;
}
}
generators.register [ new searched-lib-generator ] ;
@@ -609,9 +503,6 @@ generators.register
[ new prebuilt-lib-generator builtin.prebuilt : : LIB : <file> ] ;
class compile-action : action
{
import sequence ;
@@ -620,7 +511,7 @@ class compile-action : action
{
action.__init__ $(targets) : $(sources) : $(action-name) : $(properties) ;
}
# For all virtual targets for the same dependency graph as self,
# i.e. which belong to the same main target, add their directories
@@ -664,6 +555,7 @@ rule register-c-compiler ( id : source-types + : target-types + :
# register all generators as "generator.some-rule", not with "some-module.some-rule".)
IMPORT $(__name__) : register-c-compiler : : generators.register-c-compiler ;
# The generator class for handling EXE and SHARED_LIB creation.
class linking-generator : generator
{
import property-set ;
@@ -719,9 +611,48 @@ class linking-generator : generator
local result = [ generator.run $(project) $(name) : $(property-set)
: $(sources) : $(multiple) ] ;
return $(result) ;
return [ extra-usage-requirements $(result) : $(property-set) ] $(result) ;
}
rule extra-usage-requirements ( created-targets * : property-set )
{
local result = [ property-set.empty ] ;
local extra ;
# Add appropricate <xdll-path> usage requirements.
local raw = [ $(property-set).raw ] ;
if <link>shared in $(raw)
{
local paths ;
local pwd = [ path.pwd ] ;
for local t in $(created-targets)
{
if [ type.is-derived [ $(t).type ] SHARED_LIB ]
{
paths += [ path.root [ path.make [ $(t).path ] ] $(pwd) ] ;
}
}
extra += $(paths:G=<xdll-path>) ;
}
# We need to pass <xdll-path> features that we've got from sources,
# because if shared library is built, exe which uses it must know paths
# to other shared libraries this one depends on, to be able to find them
# all at runtime.
# Just pass all features in property-set, it's theorically possible
# that we'll propagate <xdll-path> features explicitly specified by
# the user, but then the user's to blaim for using internal feature.
local values = [ $(property-set).get <xdll-path> ] ;
extra += $(values:G=<xdll-path>) ;
if $(extra)
{
result = [ property-set.create $(extra) ] ;
}
return $(result) ;
}
rule generated-targets ( sources + : property-set : project name ? )
{
local sources2 ; # sources to pass to inherited rule
@@ -772,7 +703,51 @@ rule register-linker ( id composing ? : source-types + : target-types + :
generators.register $(g) ;
}
IMPORT $(__name__) : register-linker : : generators.register-linker ;
# The generator class for handling STATIC_LIB creation.
class archive-generator : generator
{
import property-set ;
rule __init__ ( id composing ? : source-types + : target-types + :
requirements * )
{
composing ?= true ;
generator.__init__ $(id) $(composing) : $(source-types) : $(target-types) :
$(requirements) ;
}
rule run ( project name ? : property-set : sources + : multiple ? )
{
local result = [ generator.run $(project) $(name) : $(property-set)
: $(sources) : $(multiple) ] ;
# Compute additional usage requirements.
# For static linkinking any source libraries are no linked in but are bypassed.
# We also must pass the <library-path> usage requirements we've got from those
# sources, so that dependents can find them.
# Just pass all <library-path> properties. We might pass
# <library-path> properties which did not come from dependencies, but
# were specified in requirements, but I don't think that's a problem.
local values = [ $(property-set).get <library-path> ] ;
local usage-requirements = [ property-set.create $(values:G=<library-path>) ] ;
return $(usage-requirements) $(result) ;
}
}
rule register-archiver ( id composing ? : source-types + : target-types + :
requirements * )
{
local g = [ new archive-generator $(id) $(composing) : $(source-types)
: $(target-types) : $(requirements) ] ;
generators.register $(g) ;
}
IMPORT $(__name__) : register-linker register-archiver
: : generators.register-linker generators.register-archiver ;
declare-type : RSP : rsp ;

2
src/tools/como-win.jam
View File

@@ -46,7 +46,7 @@ generators.register-linker como-win.link
: <toolset>como <toolset-como:platform>win ;
# Note that status of shared libraries support is not clear, so we don't
# define the link.dll generator.
generators.register-composing como-winc.archive
generators.register-archiver como-winc.archive
: OBJ : STATIC_LIB RSP
: <toolset>como <toolset-como:platform>win ;

2
src/tools/cw.jam
View File

@@ -110,7 +110,7 @@ generators.register-linker cw.link.dll
: <toolset>cw
;
generators.register-composing cw.archive
generators.register-archiver cw.archive
: OBJ
: STATIC_LIB RSP
: <toolset>cw

2
src/tools/make.jam
View File

@@ -36,7 +36,7 @@ class make-target-class : basic-target
local a = [ new action $(t) : $(source-targets) : $(self.make-rule)
: $(property-set) ] ;
$(t).action $(a) ;
return [ virtual-target.register $(t) ] ;
return [ property-set.empty ] [ virtual-target.register $(t) ] ;
}
}

2
src/tools/msvc.jam
View File

@@ -224,7 +224,7 @@ rule default-paths ( version ? )
generators.register-linker msvc.link : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : EXE RSP : <toolset>msvc ;
generators.register-linker msvc.link.dll : OBJ SEARCHED_LIB STATIC_LIB IMPORT_LIB : SHARED_LIB IMPORT_LIB RSP : <toolset>msvc ;
generators.register-composing msvc.archive : OBJ : STATIC_LIB RSP : <toolset>msvc ;
generators.register-archiver msvc.archive : OBJ : STATIC_LIB RSP : <toolset>msvc ;
generators.register-c-compiler msvc.compile.c++ : CPP : OBJ : <toolset>msvc ;
generators.register-c-compiler msvc.compile.c : C : OBJ : <toolset>msvc ;
generators.register-standard msvc.compile.rc : RC : OBJ(%_res) : <toolset>msvc ;

5
src/tools/stage.jam
View File

@@ -57,6 +57,7 @@ import regex ;
import generators ;
import feature ;
import project ;
import property-set ;
feature.feature <traverse-dependencies> : off on : incidental ;
feature.feature <include-type> : : free incidental ;
@@ -93,7 +94,7 @@ class stage-target-class : basic-target
local targets = [ generators.construct $(self.project) : $(type) :
$(property-set) : $(source) : * ] ;
return $(targets) ;
return $(targets[2-]) ;
}
# Constructs the targets of types for which there is no STAGED_* type.
@@ -189,7 +190,7 @@ class stage-target-class : basic-target
}
}
return $(result) ;
return [ property-set.empty ] $(result) ;
}
rule select-included ( source-targets * : types-to-include * )

4
src/tools/symlink.jam
View File

@@ -6,7 +6,7 @@
# Defines the "symlink" special target. 'symlink' targets make symbolic links
# to the sources.
import targets modules path class os feature project ;
import targets modules path class os feature project property-set ;
.count = 0 ;
@@ -70,7 +70,7 @@ class symlink-targets : basic-target
self.virtual-targets += $(vt) ;
i = [ numbers.increment $(i) ] ;
}
return $(self.virtual-targets) ;
return [ property-set.empty ] $(self.virtual-targets) ;
}
}

12
src/tools/unix.jam
View File

@@ -40,7 +40,7 @@ class unix-linking-generator : linking-generator
local result = [ linking-generator.run $(project) $(name) : $(property-set)
: $(sources) : $(multiple) ] ;
unix.set-library-order $(sources) : $(property-set) : $(result) ;
unix.set-library-order $(sources) : $(property-set) : $(result[2-]) ;
return $(result) ;
}
@@ -69,7 +69,7 @@ class unix-linking-generator : linking-generator
}
class unix-archive-generator : generator
class unix-archive-generator : archive-generator
{
import unix ;
@@ -77,16 +77,16 @@ class unix-archive-generator : generator
requirements * )
{
composing ?= true ;
generator.__init__ $(id) $(composing) : $(source-types) : $(target-types) :
archive-generator.__init__ $(id) $(composing) : $(source-types) : $(target-types) :
$(requirements) ;
}
rule run ( project name ? : property-set : sources + : multiple ? )
{
local result = [ generator.run $(project) $(name) : $(property-set)
local result = [ archive-generator.run $(project) $(name) : $(property-set)
: $(sources) : $(multiple) ] ;
unix.set-library-order $(sources) : $(property-set) : $(result) ;
unix.set-library-order $(sources) : $(property-set) : $(result[2-]) ;
return $(result) ;
@@ -112,7 +112,7 @@ class unix-searched-lib-generator : searched-lib-generator
local result = [ searched-lib-generator.run $(project) $(name)
: $(property-set) : $(sources) : $(multiple) ] ;
unix.set-library-order $(sources) : $(property-set) : $(result) ;
unix.set-library-order $(sources) : $(property-set) : $(result[2-]) ;
return $(result) ;
}

3
src/util/container.jam
View File

@@ -22,7 +22,7 @@ class node
# Set the value of this node, passing nothing will clear it.
#
rule set ( value ? )
rule set ( value * )
{
self.value = $(value) ;
}
@@ -214,6 +214,7 @@ class vector : node
# Sorts the vector inplace, calling 'utility.less' for
# comparisons.
# NOTE: this rule is unused at the moment.
rule sort ( )
{
self.value =

2
test/generators-test/project-root.jam
View File

@@ -60,7 +60,7 @@ class nm::target::cpp-obj-generator : generator
local converted = [ generators.construct $(project) : NM.TARGET.CPP : $(properties) : $(source) ] ;
if $(converted[1])
{
local result = [ generators.construct $(project) : OBJ : $(properties) : $(converted[1]) ] ;
local result = [ generators.construct $(project) : OBJ : $(properties) : $(converted[2]) ] ;
return $(result) ;
}
else