witine/linphone-ios
1
0
Fork 0
forked from mirrors/linphone-iphone
Code Pull requests Activity

Fix references

Browse source
This commit is contained in:
François Grisez 2018-03-01 17:07:47 +01:00
parent 08837c74fa
commit 7f9636f953
5 changed files with 157 additions and 159 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

33
coreapi/help/doc/sphinx/class_page.mustache
View file

@ -1,13 +1,13 @@
{{#hasNamespaceDeclarator}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{namespace}}}
{{#isJava}}
:noindex:
{{/isJava}}
{{/hasNamespaceDeclarator}}
{{#make_chapter}}{{{className}}} class{{/make_chapter}}
{{#isNotJava}}
.. {{#write_declarator}}class{{/write_declarator}}:: {{{fullClassName}}}
{{/isNotJava}}
{{#isJava}}
.. java:package:: {{{namespace}}}
.. java:type:: public interface {{{className}}};
{{/isJava}}
.. {{#write_declarator}}class{{/write_declarator}}:: {{{classDeclaration}}}
{{#briefDoc}}
{{#lines}}
@ -24,6 +24,14 @@
{{{selector}}}
{{#hasNamespaceDeclarator}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
{{#isJava}}
:noindex:
{{/isJava}}
{{/hasNamespaceDeclarator}}
Summary
=======
@ -63,6 +71,9 @@ Properties
{{#hasNamespaceDeclarator}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
{{#isJava}}
:noindex:
{{/isJava}}
{{/hasNamespaceDeclarator}}
{{#getter}}
@ -110,6 +121,9 @@ Public methods
{{#hasNamespaceDeclarator}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
{{#isJava}}
:noindex:
{{/isJava}}
{{/hasNamespaceDeclarator}}
{{#methods}}
@ -138,6 +152,9 @@ Class methods
{{#hasNamespaceDeclarator}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{fullClassName}}}
{{#isJava}}
:noindex:
{{/isJava}}
{{/hasNamespaceDeclarator}}
{{#classMethods}}

20
coreapi/help/doc/sphinx/enums_page.mustache
View file

@ -1,7 +1,19 @@
{{#namespace}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{namespace}}}
{{#isJava}}
:noindex:
{{/isJava}}
{{/namespace}}
{{#enums}}
{{{sectionName}}}
.. {{#write_declarator}}enum{{/write_declarator}}:: {{{fullName}}}
{{#isNotJava}}
.. {{#write_declarator}}enum{{/write_declarator}}:: {{{fullName}}}
{{/isNotJava}}
{{#isJava}}
.. java:type:: public enum {{{name}}};
{{/isJava}}
{{#briefDesc}}
{{#lines}}
@ -11,10 +23,7 @@
{{{selector}}}
{{#hasNamespaceDeclarator}}
.. {{#write_declarator}}namespace{{/write_declarator}}:: {{{namespace}}}
{{/hasNamespaceDeclarator}}
{{#isNotJava}}
{{#enumerators}}
.. {{#write_declarator}}enumerator{{/write_declarator}}:: {{{name}}}{{#value}} = {{{value}}}{{/value}}
@ -27,4 +36,5 @@
{{{selector}}}
{{/enumerators}}
{{/isNotJava}}
{{/enums}}

44
coreapi/help/doc/sphinx/gendoc.py
View file

@ -162,6 +162,14 @@ class SphinxPage(object):
@property
def docTranslator(self):
return self.lang.docTranslator
@property
def isJava(self):
return self.lang.langCode == 'Java'
@property
def isNotJava(self):
return not self.isJava
def make_chapter(self):
return lambda text: RstTools.make_chapter(pystache.render(text, self))
@ -193,9 +201,7 @@ class SphinxPage(object):
link = lang.displayName
else:
link = ref.translate(lang.docTranslator, label=lang.displayName)
links.append(link)
return ' '.join(links)
@staticmethod
@ -213,9 +219,10 @@ class IndexPage(SphinxPage):
class EnumsPage(SphinxPage):
def __init__(self, lang, langs, enums):
def __init__(self, lang, langs, api):
SphinxPage.__init__(self, lang, langs, 'enums.rst')
self._translate_enums(enums)
self.namespace = api.namespace.name.translate(lang.nameTranslator) if lang.langCode != 'C' else None
self._translate_enums(api.namespace.enums)
def _translate_enums(self, enums):
self.enums = []
@ -227,7 +234,6 @@ class EnumsPage(SphinxPage):
'enumerators' : self._translate_enum_values(enum),
'selector' : self._make_selector(enum)
}
translatedEnum['namespace'] = self._get_translated_namespace(enum) if self.lang.langCode == 'Cpp' else translatedEnum['fullName']
translatedEnum['sectionName'] = RstTools.make_section(translatedEnum['name'])
self.enums.append(translatedEnum)
@ -249,7 +255,8 @@ class ClassPage(SphinxPage):
def __init__(self, _class, lang, langs):
filename = SphinxPage._classname_to_filename(_class.name)
SphinxPage.__init__(self, lang, langs, filename)
self.namespace = self._get_translated_namespace(_class)
namespace = _class.find_first_ancestor_by_type(abstractapi.Namespace)
self.namespace = namespace.name.translate(self.lang.nameTranslator, recursive=True)
self.className = _class.name.translate(self.lang.nameTranslator)
self.fullClassName = _class.name.translate(self.lang.nameTranslator, recursive=True)
self.briefDoc = _class.briefDescription.translate(self.docTranslator)
@ -258,6 +265,10 @@ class ClassPage(SphinxPage):
self.methods = self._translate_methods(_class.instanceMethods)
self.classMethods = self._translate_methods(_class.classMethods)
self.selector = self._make_selector(_class)
@property
def classDeclaration(self):
return 'public interface {0}'.format(self.className) if self.lang.langCode == 'Java' else self.className
@property
def hasMethods(self):
@ -276,11 +287,12 @@ class ClassPage(SphinxPage):
for property_ in properties:
propertyAttr = {
'name' : property_.name.translate(self.lang.nameTranslator),
'ref_label' : '{0}_{1}'.format(self.lang.langCode, property_.name.to_snake_case(fullName=True)),
'getter' : self._translate_method(property_.getter) if property_.getter is not None else None,
'setter' : self._translate_method(property_.setter) if property_.setter is not None else None
}
propertyAttr['title'] = RstTools.make_subsubsection(propertyAttr['name'])
propertyAttr['ref_label'] = (self.lang.langCode + '_')
propertyAttr['ref_label'] += (property_.getter.name.to_snake_case(fullName=True) if property_.getter is not None else property_.setter.name.to_snake_case(fullName=True))
translatedProperties.append(propertyAttr)
return translatedProperties
@ -291,18 +303,16 @@ class ClassPage(SphinxPage):
return translatedMethods
def _translate_method(self, method):
prototypeParams = {}
if self.lang.langCode == 'Cpp':
prototypeParams['showStdNs'] = True
namespace = method.find_first_ancestor_by_type(abstractapi.Class)
methAttr = {
'prototype' : method.translate_as_prototype(self.lang.langTranslator, **prototypeParams),
'prototype' : method.translate_as_prototype(self.lang.langTranslator, namespace=namespace),
'briefDoc' : method.briefDescription.translate(self.docTranslator),
'detailedDoc' : method.detailedDescription.translate(self.docTranslator),
'selector' : self._make_selector(method)
}
reference = metadoc.FunctionReference(None)
reference.relatedObject = method
methAttr['link'] = reference.translate(self.lang.docTranslator)
methAttr['link'] = reference.translate(self.lang.docTranslator, namespace=method.find_first_ancestor_by_type(abstractapi.Class, abstractapi.Interface))
return methAttr
@property
@ -331,14 +341,6 @@ class ClassPage(SphinxPage):
table.addrow([method['link'], briefDoc])
return table
@property
def isJava(self):
return self.lang.langCode == 'Java'
@property
def isNotJava(self):
return not self.isJava
class DocGenerator:
def __init__(self, api):
@ -357,7 +359,7 @@ class DocGenerator:
if not os.path.exists(directory):
os.mkdir(directory)
enumsPage = EnumsPage(lang, self.languages, self.api.namespace.enums)
enumsPage = EnumsPage(lang, self.languages, self.api)
enumsPage.write(directory)
indexPage = IndexPage(lang, self.languages)

192
tools/abstractapi.py
View file

@ -949,15 +949,12 @@ class Translator:
except KeyError:
raise ValueError("Invalid language code: '{0}'".format(langCode))
def _get_object_name(self, obj):
return obj.desc.name if isinstance(obj, (EnumType, ClassType)) else obj.name
def _compute_namespace_name(self, namespace, obj):
if namespace is not None:
return namespace.name if namespace is not GlobalNs else None
else:
namespace = obj.find_first_ancestor_by_type(Enum, Class, Namespace, Interface)
return metaname.Name.find_common_parent(self._get_object_name(obj), namespace.name)
@staticmethod
def _namespace_to_name_translator_params(namespace):
return {
'recursive': True,
'topAncestor': namespace.name if namespace is not None else None
}
class CLikeLangTranslator(Translator):
@ -971,8 +968,11 @@ class CLikeLangTranslator(Translator):
else:
raise TypeError('invalid enumerator value type: {0}'.format(value))
def translate_argument(self, argument, **kargs):
return '{0} {1}'.format(argument.type.translate(self, **kargs), argument.name.translate(self.nameTranslator))
def translate_argument(self, argument, hideArgName=False, namespace=None):
ret = argument.type.translate(self, namespace=namespace)
if not hideArgName:
ret += (' ' + argument.name.translate(self.nameTranslator))
return ret
class CLangTranslator(CLikeLangTranslator):
@ -982,19 +982,19 @@ class CLangTranslator(CLikeLangTranslator):
self.falseConstantToken = 'FALSE'
self.trueConstantToken = 'TRUE'
def translate_base_type(self, _type):
def translate_base_type(self, _type, **kargs):
return _type.cDecl
def translate_enum_type(self, _type):
def translate_enum_type(self, _type, **kargs):
return _type.cDecl
def translate_class_type(self, _type):
def translate_class_type(self, _type, **kargs):
return _type.cDecl
def translate_list_type(self, _type):
def translate_list_type(self, _type, **kargs):
return _type.cDecl
def translate_enumerator_value(self, value):
def translate_enumerator_value(self, value, **kargs):
if value is None:
return None
elif isinstance(value, int):
@ -1004,19 +1004,20 @@ class CLangTranslator(CLikeLangTranslator):
else:
raise TypeError('invalid enumerator value type: {0}'.format(value))
def translate_method_as_prototype(self, method, **params):
def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
_class = method.find_first_ancestor_by_type(Class)
params = '{const}{className} *obj'.format(
className=_class.name.to_c(),
const='const ' if method.isconst else ''
)
for arg in method.args:
params += (', ' + arg.translate(self))
return '{returnType} {name}({params})'.format(
returnType=method.returnType.translate(self),
params = []
if not hideArguments:
params.append('{const}{className} *obj'.format(
className=_class.name.to_c(),
const='const ' if method.isconst and not stripDeclarators else ''
))
for arg in method.args:
params.append(arg.translate(self, hideArgName=hideArgNames))
return '{returnType}{name}({params})'.format(
returnType=(method.returnType.translate(self) + ' ') if not hideReturnType else '',
name=method.name.translate(self.nameTranslator),
params=params
params=', '.join(params)
)
@ -1028,7 +1029,7 @@ class CppLangTranslator(CLikeLangTranslator):
self.trueConstantToken = 'true'
self.ambigousTypes = []
def translate_base_type(self, _type, showStdNs=True, namespace=None):
def translate_base_type(self, _type, namespace=None):
if _type.name == 'void':
if _type.isref:
return 'void *'
@ -1058,14 +1059,11 @@ class CppLangTranslator(CLikeLangTranslator):
elif _type.name == 'status':
res = 'linphone::Status'
elif _type.name == 'string':
res = CppLangTranslator.prepend_std('string', showStdNs)
res = 'std::string'
if type(_type.parent) is Argument:
res += ' &'
elif _type.name == 'string_array':
res = '{0}<{1}>'.format(
CppLangTranslator.prepend_std('list', showStdNs),
CppLangTranslator.prepend_std('string', showStdNs)
)
res = 'std::list<std::string>'
if type(_type.parent) is Argument:
res += ' &'
else:
@ -1085,81 +1083,50 @@ class CppLangTranslator(CLikeLangTranslator):
res += ' *'
return res
def translate_enum_type(self, type_, showStdNs=True, namespace=None):
def translate_enum_type(self, type_, namespace=None):
if type_.desc is None:
raise TranslationError('{0} has not been fixed'.format(type_.name))
nsName = self._compute_namespace_name(namespace, type_)
return type_.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
return type_.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
def translate_class_type(self, type_, showStdNs=True, namespace=None):
def translate_class_type(self, type_, namespace=None):
if type_.desc is None:
raise TranslationError('{0} has not been fixed'.format(type_.name))
nsName = self._compute_namespace_name(namespace, type_)
res = type_.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
res = type_.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
if type_.desc.refcountable:
if type_.isconst:
res = 'const ' + res
if type(type_.parent) is Argument:
return 'const {0}<{1}> &'.format(
CppLangTranslator.prepend_std('shared_ptr', showStdNs),
res
)
return 'const std::shared_ptr<{0}> &'.format(res)
else:
return '{0}<{1}>'.format(
CppLangTranslator.prepend_std('shared_ptr', showStdNs),
res
)
return 'std::shared_ptr<{0}>'.format(res)
else:
if type(type_.parent) is Argument:
return 'const {0} &'.format(res)
else:
return '{0}'.format(res)
def translate_list_type(self, _type, showStdNs=True, namespace=None):
def translate_list_type(self, _type, namespace=None):
if _type.containedTypeDesc is None:
raise TranslationError('{0} has not been fixed'.format(_type.containedTypeName))
elif isinstance(_type.containedTypeDesc, BaseType):
res = _type.containedTypeDesc.translate(self)
else:
res = _type.containedTypeDesc.translate(self, showStdNs=showStdNs, namespace=namespace)
res = _type.containedTypeDesc.translate(self, namespace=namespace)
if type(_type.parent) is Argument:
return 'const {0}<{1} > &'.format(
CppLangTranslator.prepend_std('list', showStdNs),
res
)
return 'const std::list<{0}> &'.format(res)
else:
return '{0}<{1} >'.format(
CppLangTranslator.prepend_std('list', showStdNs),
res
)
return 'std::list<{0}>'.format(res)
def translate_method_as_prototype(self, method, showStdNs=True, namespace=None):
nsName = self._compute_namespace_name(namespace, method)
argsString = ''
argStrings = []
for arg in method.args:
argStrings.append(arg.translate(self, showStdNs=showStdNs, namespace=namespace))
argsString = ', '.join(argStrings)
return '{_return} {name}({args}){const}'.format(
_return=method.returnType.translate(self, ),
name=method.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName),
args=argsString,
const=' const' if method.isconst else ''
def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
argsAsString = ', '.join([arg.translate(self, hideArgName=hideArgNames, namespace=namespace) for arg in method.args]) if not hideArguments else ''
return '{return_}{name}({args}){const}'.format(
return_=(method.returnType.translate(self, namespace=namespace) + ' ') if not hideReturnType else '',
name=method.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace)),
args=argsAsString,
const=' const' if method.isconst and not stripDeclarators else ''
)
@staticmethod
def prepend_std(string, prepend):
return 'std::' + string if prepend else string
def _compute_namespace_name(self, namespace, obj):
nsName = Translator._compute_namespace_name(self, namespace, obj)
if self._get_object_name(obj).to_c() in self.ambigousTypes:
nsName = None
return nsName
class JavaLangTranslator(CLikeLangTranslator):
@ -1226,14 +1193,12 @@ class JavaLangTranslator(CLikeLangTranslator):
elif jni:
return 'jint'
else:
nsName = self._compute_namespace_name(namespace, _type)
return _type.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
return _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
def translate_class_type(self, _type, native=False, jni=False, isReturn=False, namespace=None):
if jni:
return 'jobject'
nsName = self._compute_namespace_name(namespace, _type)
return _type.desc.name.translate(self.nameTranslator, recursive=True, topAncestor=nsName)
return _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
def translate_list_type(self, _type, native=False, jni=False, isReturn=False, namespace=None):
if jni:
@ -1259,14 +1224,18 @@ class JavaLangTranslator(CLikeLangTranslator):
raise Error('translation of bctbx_list_t of unknow type !')
return ptrtype + '[]'
def translate_argument(self, arg, native=False, jni=False):
return '{0} {1}'.format(arg.type.translate(self, native=native, jni=jni), arg.name.translate(self.nameTranslator))
def translate_argument(self, arg, native=False, jni=False, hideArgName=False, namespace=None):
res = arg.type.translate(self, native=native, jni=jni, namespace=None)
if not hideArgName:
res += (' ' + arg.name.translate(self.nameTranslator))
return res
def translate_method_as_prototype(self, method, namespace=None):
return 'public {returnType} {methodName}({arguments})'.format(
returnType=method.returnType.translate(self),
methodName=method.name.translate(self.nameTranslator),
arguments=', '.join([arg.translate(self) for arg in method.args])
def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
return '{public}{returnType}{methodName}({arguments})'.format(
public='public ' if not stripDeclarators else '',
returnType=(method.returnType.translate(self, isReturn=True, namespace=namespace) + ' ') if not hideReturnType else '',
methodName=method.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace)),
arguments=', '.join([arg.translate(self, hideArgName=hideArgNames, namespace=namespace) for arg in method.args]) if not hideArguments else ''
)
@ -1277,7 +1246,7 @@ class CSharpLangTranslator(CLikeLangTranslator):
self.falseConstantToken = 'false'
self.trueConstantToken = 'true'
def translate_base_type(self, _type, dllImport=True):
def translate_base_type(self, _type, dllImport=True, namespace=None):
if _type.name == 'void':
if _type.isref:
return 'IntPtr'
@ -1326,16 +1295,16 @@ class CSharpLangTranslator(CLikeLangTranslator):
return res
def translate_enum_type(self, _type, dllImport=True):
def translate_enum_type(self, _type, dllImport=True, namespace=None):
if dllImport and type(_type.parent) is Argument:
return 'int'
else:
return _type.desc.name.translate(self.nameTranslator)
return _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
def translate_class_type(self, _type, dllImport=True):
return "IntPtr" if dllImport else _type.desc.name.translate(self.nameTranslator)
def translate_class_type(self, _type, dllImport=True, namespace=None):
return "IntPtr" if dllImport else _type.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
def translate_list_type(self, _type, dllImport=True):
def translate_list_type(self, _type, dllImport=True, namespace=None):
if dllImport:
return 'IntPtr'
else:
@ -1345,7 +1314,7 @@ class CSharpLangTranslator(CLikeLangTranslator):
else:
raise TranslationError('translation of bctbx_list_t of basic C types is not supported')
elif type(_type.containedTypeDesc) is ClassType:
ptrType = _type.containedTypeDesc.desc.name.translate(self.nameTranslator)
ptrType = _type.containedTypeDesc.desc.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace))
return 'IEnumerable<' + ptrType + '>'
else:
if _type.containedTypeDesc:
@ -1353,22 +1322,17 @@ class CSharpLangTranslator(CLikeLangTranslator):
else:
raise TranslationError('translation of bctbx_list_t of unknow type !')
def translate_argument(self, arg, dllImport=True):
def translate_argument(self, arg, dllImport=True, namespace=None):
return '{0} {1}'.format(
arg.type.translate(self, dllImport=dllImport),
arg.type.translate(self, dllImport=dllImport, namespace=None),
arg.name.translate(self.nameTranslator)
)
def translate_method_as_prototype(self, method):
kargs = {
'static' : 'static ' if method.type == Method.Type.Class else '',
'override' : 'override ' if method.name.translate(self.nameTranslator) == 'ToString' else '',
'returnType' : method.returnType.translate(self, dllImport=False),
'name' : method.name.translate(self.nameTranslator),
'args' : ''
}
for arg in method.args:
if kargs['args'] != '':
kargs['args'] += ', '
kargs['args'] += arg.translate(self, dllImport=False)
return '{static}{override}{returnType} {name}({args})'.format(**kargs)
def translate_method_as_prototype(self, method, hideArguments=False, hideArgNames=False, hideReturnType=False, stripDeclarators=False, namespace=None):
return '{static}{override}{returnType}{name}({args})'.format(
static = 'static ' if method.type == Method.Type.Class and not stripDeclarators else '',
override = 'override ' if method.name.translate(self.nameTranslator) == 'ToString' and not stripDeclarators else '',
returnType = (method.returnType.translate(self, dllImport=False, namespace=namespace) + ' ') if not hideReturnType else '',
name = method.name.translate(self.nameTranslator, **Translator._namespace_to_name_translator_params(namespace)),
args = ', '.join([arg.translate(self, dllImport=False, namespace=namespace) for arg in method.args]) if not hideArguments else ''
)

27
tools/metadoc.py
View file

@ -435,12 +435,11 @@ class Translator:
else:
if namespace is None:
description = ref.find_root()
namespaceObj = description.relatedObject.find_first_ancestor_by_type(abstractapi.Namespace, abstractapi.Class)
namespace = namespaceObj.name
if namespace.is_prefix_of(ref.relatedObject.name):
commonName = namespace
namespace = description.relatedObject.find_first_ancestor_by_type(abstractapi.Namespace, abstractapi.Class)
if namespace.name.is_prefix_of(ref.relatedObject.name):
commonName = namespace.name
else:
commonName = metaname.Name.find_common_parent(ref.relatedObject.name, namespace)
commonName = metaname.Name.find_common_parent(ref.relatedObject.name, namespace.name)
return ref.relatedObject.name.translate(self.nameTranslator, recursive=True, topAncestor=commonName)
def translate_keyword(self, keyword):
@ -617,15 +616,21 @@ class SphinxTranslator(Translator):
ref=Translator.translate_reference(self, ref, absName=True)
)
def translate_function_reference(self, ref, label=None, namespace=None):
paramTypes = []
if self.domain != 'c':
for arg in ref.relatedObject.args:
paramTypes.append(arg._type.translate(self.langTranslator))
def translate_function_reference(self, ref, label=None, useNamespace=True, namespace=None):
if self.domain == 'csharp':
refStr = ref.relatedObject.name.translate(self.nameTranslator, **abstractapi.Translator._namespace_to_name_translator_params(namespace))
else:
refStr = ref.relatedObject.translate_as_prototype(self.langTranslator,
hideArguments=self.domain != 'java',
hideArgNames=self.domain == 'java',
hideReturnType=True,
stripDeclarators=True,
namespace=namespace
)
return ':{tag}:`{label} <{ref}>`'.format(
tag=self._sphinx_ref_tag(ref),
label=label if label is not None else '{0}()'.format(Translator.translate_reference(self, ref, namespace=namespace)),
ref='{0}({1})'.format(Translator.translate_reference(self, ref, absName=True), ', '.join(paramTypes))
ref=refStr
)
def translate_keyword(self, keyword):