Skip to content

HTTPS clone URL

Subversion checkout URL

You can clone with HTTPS or Subversion.

Download ZIP
Fetching contributors…

Cannot retrieve contributors at this time

757 lines (667 sloc) 30.456 kb
/*
* Copyright (C) 2005-2012 Team XBMC
* http://www.xbmc.org
*
* This Program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This Program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with XBMC; see the file COPYING. If not, write to
* the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.
* http://www.gnu.org/copyleft/gpl.html
*
*/
import groovy.xml.XmlUtil
import org.apache.commons.lang.StringEscapeUtils
import groovy.text.SimpleTemplateEngine
import groovy.text.SimpleTemplateEngine
import java.util.regex.Pattern
/**
* This class contains a series of helper methods for parsing a xbmc addon spec xml file. It is intended to be
* used from a bindings template.
*
* @author jim
*
*/
public class Helper
{
private static List classes
private static Map outTypemap = [:]
private static def defaultOutTypeConversion = null
private static Map inTypemap = [:]
private static def defaultInTypeConversion = null
private static def doxygenXmlDir = null
public static String newline = System.getProperty("line.separator");
/**
* In order to use any of the typemap helper features, the Helper class needs to be initialized with
* this information.
* @param pclasses is the list of all class nodes from the module
* @param poutTypemap is the typemap table for output return values to the scripting language
* @param defaultOutTypemap is the default typemap to use when the type conversion is unknown
* @param pinTypemap is the typemap table for input parameters from the scripting language
* @param defaultInTypemap is the default typemap for the input parameters from the scripting language
*/
public static void setup(List pclasses, Map poutTypemap, def defaultOutTypemap,
Map pinTypemap, def defaultInTypemap)
{
classes = pclasses ? pclasses : []
if (poutTypemap) outTypemap.putAll(poutTypemap)
if (defaultOutTypemap) defaultOutTypeConversion = defaultOutTypemap
if (pinTypemap) inTypemap.putAll(pinTypemap)
if (defaultInTypemap) defaultInTypeConversion = defaultInTypemap
}
public static class Sequence
{
private long cur = 0;
public long increment() { return ++cur }
}
private static ThreadLocal<Sequence> curSequence = new ThreadLocal<Sequence>();
public static void setDoxygenXmlDir(File dir) { doxygenXmlDir = dir }
private static String retrieveDocStringFromDoxygen(Node methodOrClass)
{
if (doxygenXmlDir == null)
return null
Node doc = null
def ret = ''
// make the class name or namespave
String doxygenId = findFullClassName(methodOrClass,'_1_1')
boolean isInClass = doxygenId != null
if (!doxygenId)
doxygenId = findNamespace(methodOrClass,'_1_1',false)
doxygenId = (isInClass ? 'class' : 'namespace') + doxygenId
String doxygenFilename = doxygenId + '.xml'
File doxygenXmlFile = new File(doxygenXmlDir,doxygenFilename)
if (! doxygenXmlFile.exists())
{
System.out.println("WARNING: Cannot find doxygen file for ${methodOrClass.toString()} which should be \"${doxygenXmlFile}\"")
return null
}
Node docspec = (new XmlParser().parse(doxygenXmlFile))
if (methodOrClass.name() == 'class')
doc = docspec.compounddef[0].detaileddescription[0]
else // it's a method of some sort ... or it better be
{
Node memberdef = docspec.depthFirst().find {
return ((it.name() == 'memberdef' && it.@kind == 'function' && it.@id.startsWith(doxygenId)) &&
(it.name != null && it.name.text().trim() == methodOrClass.@sym_name))
}
doc = memberdef != null ? memberdef.detaileddescription[0] : null
}
if (doc != null)
{
def indent = ' '
def curIndent = ''
def prevIndent = ''
def handleDoc
handleDoc = {
if (it instanceof String)
ret += it
else // it's a Node
{
if (it.name() == 'detaileddescription')
it.children().each handleDoc
else if (it.name() == 'para')
{
it.children().each handleDoc
ret += (it.parent()?.name() == 'listitem') ? newline : (newline + newline)
}
else if (it.name() == 'ref' || it.name() == "ulink")
ret += (it.text() + ' ')
else if (it.name() == 'verbatim')
ret += it.text().denormalize()
else if (it.name() == 'itemizedlist')
{
ret += newline
prevIndent = curIndent
curIndent += indent
it.children().each handleDoc
curIndent = prevIndent
}
else if (it.name() == 'listitem')
{
ret += (curIndent + '- ')
it.children().each handleDoc
}
else if (it.name() == 'linebreak')
ret += newline
else if (it.name() == 'ndash')
ret += "--"
else
System.out.println("WARNING: Cannot parse the following as part of the doxygen processing:" + XmlUtil.serialize(it))
}
}
doc.children().each handleDoc
}
return ret.denormalize()
}
/**
* <p>This method uses the previously set outTypemap and defaultOutTypemap to produce the chunk of code
* that will be used to return the method invocation result to the scripting language. For example, in
* python, if the return type from the method is a long, then the OutConversion could look something like:</p>
* <code>
* result = PyInt_FromLong(thingReturnedFromMethod);
* </code>
* <p>This could have resulted from a mini-template stored as the way to handle 'long's in the outTypemap:</p>
* <code>
* ${result} = PyInt_FromLong(${api});
* </code>
* @param apiType - is the Swig typecode that describes the return type from the native method
* @param method - is the node from the module xml that contains the method description
* @return the code chunk as a string ready to be placed into the generated code.
*/
public static String getOutConversion(String apiType, String apiName, Node method, Map overrideBindings = null, boolean recurse = true)
{
def convertTemplate = outTypemap[apiType]
// String apiLType = SwigTypeParser.convertTypeToLType(apiType)
// if (convertTemplate == null) convertTemplate = outTypemap[apiLType]
// is the returns a pointer to a known class
Node classNode = null
if (convertTemplate == null && apiType.startsWith('p.'))
{
classNode = findClassNodeByName(parents(method)[0], SwigTypeParser.getRootType(apiType),method)
if (classNode) convertTemplate = defaultOutTypeConversion
}
if (convertTemplate == null)
{
// Look for Pattern for keys that might fit
convertTemplate = outTypemap.find({ key, value -> (key instanceof Pattern && key.matcher(apiType).matches()) })?.value
}
if (!convertTemplate)
{
if (recurse)
return getOutConversion(SwigTypeParser.SwigType_ltype(apiType),apiName,method,overrideBindings,false)
else
throw new RuntimeException("WARNING: Cannot convert the return value of swig type ${apiType} for the call ${Helper.findFullClassName(method) + '::' + Helper.callingName(method)}")
}
boolean seqSetHere = false
Sequence seq = curSequence.get()
if (seq == null)
{
seqSetHere = true
seq = new Sequence()
curSequence.set(seq)
}
Map bindings = ['result' : apiName, 'api' : 'apiResult', 'type' : "${apiType}",
'method' : method, 'helper' : Helper.class,
'swigTypeParser' : SwigTypeParser.class,
'sequence' : seq ]
if (classNode) bindings['classnode'] = classNode
if (overrideBindings) bindings.putAll(overrideBindings)
if (convertTemplate instanceof List) /// then we expect the template string/file to be the first entry
{
Map additionalBindings = convertTemplate.size() > 1 ? convertTemplate[1] : [:]
bindings.putAll(additionalBindings)
convertTemplate = convertTemplate[0]
}
if (seqSetHere) curSequence.set(null)
return new SimpleTemplateEngine().createTemplate(convertTemplate).make(bindings).toString()
}
/**
* <p>This method uses the previously set inTypemap and defaultInTypemap to produce the chunk of code
* that will be used to convert input parameters from the scripting language to the native method invocation
* parameters. For example, if the native call takes a 'String' then the InConversion could look something like:</p>
* <code>
* if (pythonStringArgument) PyXBMCGetUnicodeString(cArgument,pythonStringArgument,"cArgumentName");
* </code>
* <p>This could have resulted from a mini-template stored as the way to handle 'long's in the outTypemap:</p>
* <code>
* if (${slarg}) PyXBMCGetUnicodeString(${api},${slarg},"${api}");
* </code>
* @param apiType - is the Swig typecode that describes the parameter type from the native method
* @param apiName - is the name of the parameter from the method parameter list in the api
* @param slName - is the name of the varialbe that holds the parameter from the scripting language
* @param method - is the node from the module xml that contains the method description
* @return the code chunk as a string ready to be placed into the generated code.
*/
public static String getInConversion(String apiType, String apiName, String slName, Node method, Map overrideBindings = null)
{
return getInConversion(apiType, apiName, apiName, slName, method, overrideBindings);
}
/**
* <p>This method uses the previously set inTypemap and defaultInTypemap to produce the chunk of code
* that will be used to convert input parameters from the scripting language to the native method invocation
* parameters. For example, if the native call takes a 'String' then the InConversion could look something like:</p>
* <code>
* if (pythonStringArgument) PyXBMCGetUnicodeString(cArgument,pythonStringArgument,"cArgumentName");
* </code>
* <p>This could have resulted from a mini-template stored as the way to handle 'long's in the outTypemap:</p>
* <code>
* if (${slarg}) PyXBMCGetUnicodeString(${api},${slarg},"${api}");
* </code>
* @param apiType - is the Swig typecode that describes the parameter type from the native method
* @param apiName - is the name of the varialbe that holds the api parameter
* @param paramName - is the name of the parameter from the method parameter list in the api
* @param slName - is the name of the varialbe that holds the parameter from the scripting language
* @param method - is the node from the module xml that contains the method description
* @return the code chunk as a string ready to be placed into the generated code.
*/
public static String getInConversion(String apiType, String apiName, String paramName, String slName, Node method, Map overrideBindings = null)
{
def convertTemplate = inTypemap[apiType]
String apiLType = SwigTypeParser.convertTypeToLTypeForParam(apiType)
if (convertTemplate == null) convertTemplate = inTypemap[apiLType]
// is the returns a pointer to a known class
if (convertTemplate == null && apiType.startsWith('p.'))
{
// strip off rval qualifiers
String thisNamespace = Helper.findNamespace(method)
Node clazz = classes.find { Helper.findFullClassName(it) == apiLType.substring(2) ||
(it.@sym_name == apiLType.substring(2) && thisNamespace == Helper.findNamespace(it)) }
if (clazz != null) convertTemplate = defaultInTypeConversion
}
// Look for Pattern for keys that might fit
if (convertTemplate == null)
convertTemplate = inTypemap.find({ key, value -> (key instanceof Pattern && key.matcher(apiType).matches()) })?.value
// Try the LType
if (convertTemplate == null)
convertTemplate = inTypemap.find({ key, value -> (key instanceof Pattern && key.matcher(apiLType).matches()) })?.value
if (!convertTemplate){
// it's ok if this is a known type
if (!isKnownApiType(apiType,method) && !isKnownApiType(apiLType,method))
System.out.println("WARNING: Unknown parameter type: ${apiType} (or ${apiLType}) for the call ${Helper.findFullClassName(method) + '::' + Helper.callingName(method)}")
convertTemplate = defaultInTypeConversion
}
if (convertTemplate)
{
boolean seqSetHere = false
Sequence seq = curSequence.get()
if (seq == null)
{
seqSetHere = true
seq = new Sequence()
curSequence.set(seq)
}
Map bindings = [
'type': "${apiType}", 'ltype': "${apiLType}",
'slarg' : "${slName}", 'api' : "${apiName}",
'param' : "${paramName}",
'method' : method, 'helper' : Helper.class,
'swigTypeParser' : SwigTypeParser.class,
'sequence' : seq
]
if (overrideBindings) bindings.putAll(overrideBindings)
if (convertTemplate instanceof List) /// then we expect the template string/file to be the first entry
{
Map additionalBindings = convertTemplate.size() > 1 ? convertTemplate[1] : [:]
bindings.putAll(additionalBindings)
convertTemplate = convertTemplate[0]
}
if (seqSetHere) curSequence.set(null);
return new SimpleTemplateEngine().createTemplate(convertTemplate).make(bindings).toString()
}
return ''
}
static def ignoreAttributes = ['classes', 'symtab', 'sym_symtab',
'sym_overname', 'options', 'sym_nextSibling', 'csym_nextSibling',
'sym_previousSibling' ]
/**
* <p>Transform a Swig generated xml file into something more manageable. For the most part this method will:</p>
*
* <li>1) Make all pertinent 'attributelist' elements actually be attributes of the parent element while
* an attribute with the name 'name' will become that parent element name.</li>
* <li>2) Filter out unused attributes</li>
* <li>3) Filter out the automatically included 'swig'swg'</li>
* <li>4) Flatten out the remaining 'include' elements</li>
* <li>5) Removes extraneous default argument function/method Node</li>
* <li>6) Converts all type tables to a single entry under the main module node removing all 1-1 mappings.</li>
* <li>7) Removes all non-public non-constructor methods.</li>
* @param swigxml is the raw swig output xml document
* @return the transformed document
*/
public static Node transformSwigXml(Node swigxml)
{
Node node = transform(swigxml,
{
// do not include the 'include' entry that references the default swig.swg file.
!(it.name() == 'include' &&
// needs to also contain an attribute list with an attribute 'name' that matches the swig.swg file
it.find {
it.name() == 'attributelist' && it.find {
it.name() == 'attribute' && it.@name == 'name' && it.@value =~ /swig\.swg$/
}
} ||
// also don't include any typescope entries
it.name() == 'typescopesitem' || it.name() == 'typetabsitem'
)
},{ key, value -> !ignoreAttributes.contains(key) })
// now make sure the outer most node is an include and there's only one
assert node.include?.size() == 1 && node.include[0].module?.size() == 1 && node.include[0].module[0]?.@name != null,
"Invalid xml doc result. Expected a single child node of the root node call 'include' with a single 'module' child node but got " + XmlUtil.serialize(node)
// create an outermost 'module' node with the correct name
Node ret = new Node(null, 'module', [ 'name':node.include[0].module[0].@name] )
node.include[0].children().each { if (it.name() != 'module') ret.append(it) }
// flatten out all other 'include' elements, parmlists, and typescopes
flatten(ret,['include', 'parmlist', 'typescope' ])
// remove any function nodes with default arguments
List tmpl = []
tmpl.addAll(ret.depthFirst())
for (Node cur : tmpl)
{
if ((cur.name() == 'function' || cur.name() == 'constructor') && cur.@defaultargs != null)
cur.parent().remove(cur)
}
// now validate that no other methods are overloaded since we can't handle those right now.
functionNodesByOverloads(ret).each { key, value -> assert value.size() == 1, "Cannot handle overloaded methods unless simply using defaulting: " + value }
// now gather up all of the typetabs and add a nice single
// typetab entry with a better format in the main module
List allTypetabs = ret.depthFirst().findAll { it.name() == 'typetab' }
Node typenode = new Node(ret,'typetab')
allTypetabs.each {
it.attributes().each { key, value ->
if (key != 'id' && key != value)
{
Node typeentry = new Node(null,'entry')
String namespace = findNamespace(it)
typeentry.@namespace = namespace != null ? namespace.trim() : ''
typeentry.@type = key
typeentry.@basetype = value
if (typenode.find({ it.@basetype == typeentry.@basetype && it.@namespace == typeentry.@namespace }) == null)
typenode.append(typeentry)
}
}
it.parent().remove(it)
}
// now remove all non-public methods, but leave constructors
List allMethods = ret.depthFirst().findAll({ it.name() == 'function' || it.name() == 'destructor' || it.name() == 'constructor'})
allMethods.each {
if (it.@access != null && it.@access != 'public' && it.name() != 'constructor')
it.parent().remove(it)
else
{
def doc = retrieveDocStringFromDoxygen(it)
if (doc != null && doc != '' && doc.trim() != ' ')
new Node(it,'doc',['value' : doc])
}
}
// add the doc string to the classes
List allClasses = ret.depthFirst().findAll({ it.name() == 'class'})
allClasses.each {
def doc = retrieveDocStringFromDoxygen(it)
if (doc != null && doc != '' && doc.trim() != ' ')
new Node(it,'doc',['value' : doc])
}
return ret
}
/**
* @return true if the class node has a defined constructor. false otherwise.
*/
public static boolean hasDefinedConstructor(Node clazz)
{
return (clazz.constructor != null && clazz.constructor.size() > 0)
}
/**
* @return true id this Node has a docstring associated with it.
*/
public static boolean hasDoc(Node methodOrClass)
{
return methodOrClass.doc != null && methodOrClass.doc[0] != null && methodOrClass.doc[0].@value != null
}
/**
* @return true of the class node has a constructor but it's hidden (not 'public'). false otherwise.
*/
public static boolean hasHiddenConstructor(Node clazz)
{
return (hasDefinedConstructor(clazz) && clazz.constructor[0].@access != null && clazz.constructor[0].@access != 'public')
}
/**
* <p>This will look through the entire module and look up a class node by name. It will return null if
* that class node isn't found. It's meant to be used to look up base classes from a base class list
* so it's fairly robust. It goes through the following rules:</p>
*
* <li>Does the FULL classname (considering the namespace) match the name provided.</li>
* <li>Does the FULL classname match the reference nodes namespace + '::' + the provided classname.</li>
* <li>Does the class node's name (which may contain the full classname) match the classname provided.</li>
*
* <p>Note, this method is not likely to find the classnode if you just pass a simple name and
* no referenceNode in the case where namespaces are used extensively.</p>
*/
public static Node findClassNodeByName(Node module, String classname, Node referenceNode = null)
{
return module.depthFirst().findAll({ it.name() == 'class' }).find {
// first check to see if this FULL class name matches
if (findFullClassName(it).trim() == classname.trim()) return true
// now check to see if it matches the straight name considering the reference node
if (referenceNode != null && (findNamespace(referenceNode) + classname) == findFullClassName(it)) return true
// now just see if it matches the straight name
if (it.@name == classname) return true
return false
}
}
/**
* Find me the class node that this node either is, or is within.
* If this node is not within a class node then it will return null.
*/
public static Node findClassNode(Node node)
{
if (node.name() == 'class') return node
return node.parent() == null ? null : findClassNode(node.parent())
}
/**
* If this node is a class node, or a child of a class name (for example, a method) then
* the full classname, with the namespace will be returned. Otherwise, null.
*/
public static String findFullClassName(Node node, String separator = '::')
{
String ret = null
List rents = parents(node, { it.name() == 'class' })
if (node.name() == 'class') rents.add(node)
rents.each {
if (ret == null)
ret = it.@sym_name
else
ret += separator + it.@sym_name
}
return ret ? findNamespace(node,separator) + ret : null
}
/**
* Given the Node this method looks to see if it occurs within namespace and returns
* the namespace as a String. It includes the trailing '::'
*/
public static String findNamespace(Node node, String separator = '::', boolean endingSeparator = true)
{
String ret = null
parents(node, { it.name() == 'namespace' }).each {
if (ret == null)
ret = it.@name
else
ret += separator + it.@name
}
return ret == null ? '' : (ret + (endingSeparator ? separator : ''))
}
/**
* Gather up all of the parent nodes in a list ordered from the top node, down to the
* node that's passed as a parameter.
*/
public static List parents(Node node, Closure filter = null, List ret = null)
{
Node parent = node.parent()
if (parent != null)
{
ret = parents(parent,filter,ret)
if (filter == null || filter.call(parent))
ret += parent
}
else if (ret == null)
ret = []
return ret
}
/**
* Group together overloaded methods into a map keyed by the first method's id. Each
* entry in this map contains a list of nodes that represent overloaded versions of
* the same method.
*/
public static Map functionNodesByOverloads(Node module)
{
// find function nodes
Map ret = [:]
module.depthFirst().each {
if (it.name() == 'function' || it.name() == 'constructor' || it.name() == 'destructor')
{
String id = it.@sym_overloaded != null ? it.@sym_overloaded : it.@id
if (ret[id] == null) ret[id] = [it]
else ret[id] += it
}
}
return ret
}
/**
* Because the return type is a combination of the function 'decl' and the
* function 'type,' this method will construct a valid Swig typestring from
* the two.
*/
public static String getReturnSwigType(Node method)
{
// we're going to take a shortcut here because it appears only the pointer indicator
// ends up attached to the decl.
String prefix = (method.@decl != null && method.@decl.endsWith('.p.')) ? 'p.' : ''
return method.@type != null ? prefix + method.@type : 'void'
}
/**
* Given the method node this will produce the actual name of the method as if
* it's being called. In the case of a constructor it will do a 'new.' In the
* case of a destructor it will produce a 'delete.'
*/
public static String callingName(Node method)
{
// if we're not in a class we need the fully qualified name
String clazz = findFullClassName(method)
// if we're in a class then we are going to assume we have a 'self' pointer
// that we are going to invoke this on.
if (clazz == null)
return method.@name
if (method.name() == 'constructor')
return "new ${findNamespace(method)}${method.@sym_name}"
if (method.name() == 'destructor')
return 'delete'
// otherwise it's just a call on a class being invoked on an instance
return method.@name
}
/**
* Swig has 'insert' nodes in it's parse tree that contain code chunks that are
* meant to be inserted into various positions in the generated code. This method
* will extract the nodes that refer to the specific section asked for. See the
* Swig documentation for more information.
*/
public static List getInsertNodes(Node module, String section)
{
return module.insert.findAll { section == it.@section || (section == 'header' && it.@section == null) }
}
public static String unescape(Node insertSection) { return unescape(insertSection.@code) }
public static String unescape(String insertSection) { return StringEscapeUtils.unescapeHtml(insertSection) }
public static boolean isDirector(Node method)
{
Node clazz = findClassNode(method)
if (!clazz || !clazz.@feature_director)
return false
if (method.name() == 'destructor')
return false
if (method.name() == 'constructor')
return false
return method.@storage && method.@storage == 'virtual'
}
/**
* This method will search from the 'searchFrom' Node up to the root
* looking for a %feature("knownbasetypes") declaration that the given 'type' is
* known for 'searchFrom' Node.
*/
public static boolean isKnownBaseType(String type, Node searchFrom)
{
return hasFeatureSetting(type,searchFrom,'feature_knownbasetypes',{ it.split(',').find({ it == type }) != null })
}
/**
* This method will search from the 'searchFrom' Node up to the root
* looking for a %feature("knownapitypes") declaration that the given 'type' is
* known for 'searchFrom' Node.
*/
public static boolean isKnownApiType(String type, Node searchFrom)
{
String rootType = SwigTypeParser.getRootType(type)
return hasFeatureSetting(type,searchFrom,'feature_knownapitypes',{ it.split(',').find({ it == rootType }) != null })
}
private static boolean hasFeatureSetting(String type, Node searchFrom, String feature, Closure test)
{
if (!searchFrom)
return false
if (searchFrom.attribute(feature) && test.call(searchFrom.attribute(feature)))
return true
return hasFeatureSetting(type,searchFrom.parent(),feature,test)
}
private static void flatten(Node node, List elementsToRemove)
{
for (boolean done = false; !done;)
{
done = true
for (Node child : node.breadthFirst())
{
if (elementsToRemove.contains(child.name()))
{
Node parent = child.parent()
parent.remove(child)
child.each { parent.append(it) }
done = false
break
}
}
}
}
private static Node transform(Node node, Closure nodeFilter, Closure attributeFilter)
{
// need to create a map and a list of nodes (which will be children) from the
// attribute list.
Map attributes = [:]
List nodes = []
node.each {
if (nodeFilter == null || nodeFilter.call(it) == true)
{
if (it.name() == 'attributelist')
{
Tuple results = transformSwigAttributeList(it)
attributes.putAll(results[0].findAll(attributeFilter))
List childNodes = results[1]
childNodes.each {
if (nodeFilter != null && nodeFilter.call(it) == true)
nodes.add(transform(it,nodeFilter,attributeFilter))
}
}
else
nodes.add(transform(it,nodeFilter,attributeFilter))
}
}
// transfer the addr attribute from the original node over to the 'id' attribute of the
// new node by adding it to the attributes map
if (node.@addr)
{
// copy over the other attributes
node.attributes().findAll { key,value -> if (key != 'addr' && key != 'id') attributes[key] = value }
attributes['id'] = node.@addr
}
// In the case when the Node is a cdecl, we really want to replace the node name
// with the 'kind' attribute value.
Node ret
if (node.name() == 'cdecl' && attributes.containsKey('kind'))
ret = new Node(null, attributes['kind'], attributes.findAll({key, value -> key != 'kind' } ))
else
ret = new Node(null, node.name(), attributes)
nodes.each { ret.append(it) }
return ret
}
private static Tuple transformSwigAttributeList(Node attributeList)
{
Map attributes = [:]
List nodes = []
attributeList.each {
if (it.name() == 'attribute')
attributes[it.@name] = it.@value
else
nodes.add(it)
}
return [attributes, nodes]
}
}
Jump to Line
Something went wrong with that request. Please try again.