def parse_django_adminopt_node(env, sig, signode):
"""A copy of sphinx.directives.CmdoptionDesc.parse_signature()"""
option_desc_re = None
# Sphinx >= 1.0 and Sphinx < 1.0, respectively.
for module in ['sphinx.domains.std', 'sphinx.directives.desc']:
try:
mod = import_module(module)
option_desc_re = mod.option_desc_re
except ImportError:
pass
else:
break
count = 0
firstname = ''
for m in option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not firstname:
raise ValueError
return firstname
def handle_signature(self, sig, signode):
"""Transform a C signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
m = c_funcptr_sig_re.match(sig)
if m is None:
m = c_sig_re.match(sig)
if m is None:
raise ValueError('no match')
rettype, name, arglist, const = m.groups()
signode += addnodes.desc_type('', '')
self._parse_type(signode[-1], rettype)
try:
classname, funcname = name.split('::', 1)
classname += '::'
signode += addnodes.desc_addname(classname, classname)
signode += addnodes.desc_name(funcname, funcname)
# name (the full name) is still both parts
except ValueError:
signode += addnodes.desc_name(name, name)
# clean up parentheses from canonical name
m = c_funcptr_name_re.match(name)
if m:
name = m.group(1)
typename = self.env.temp_data.get('c:type')
if self.name == 'c:member' and typename:
fullname = typename + '.' + name
else:
fullname = name
if not arglist:
if self.objtype == 'function':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
if const:
signode += addnodes.desc_addname(const, const)
return fullname
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
args = arglist.split(',')
for arg in args:
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
ctype, argname = arg.rsplit(' ', 1)
except ValueError:
# no argument name given, only the type
self._parse_type(param, arg)
else:
self._parse_type(param, ctype)
# separate by non-breaking space in the output
param += nodes.emphasis(' '+argname, u'\xa0'+argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return fullname
def attach_function(self, node, func):
owner, name = func.name.split_owner()
# Olaf: Never show Class::
owner = None
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
# cast operator is special. in this case the return value
# is reversed.
if isinstance(name, CastOpDefExpr):
node += addnodes.desc_name('operator', 'operator')
node += nodes.Text(u' ')
self.attach_type(node, name.typename)
else:
funcname = unicode(name)
node += addnodes.desc_name(funcname, funcname)
paramlist = addnodes.desc_parameterlist()
for arg in func.signature:
param = addnodes.desc_parameter('', '', noemph=True)
if arg.type is not None:
self.attach_type(param, arg.type)
param += nodes.Text(u' ')
param += nodes.emphasis(unicode(arg.name), unicode(arg.name))
if arg.default is not None:
def_ = u'=' + unicode(arg.default)
param += nodes.emphasis(def_, def_)
paramlist += param
node += paramlist
if func.const:
node += addnodes.desc_addname(' const', ' const')
if func.pure_virtual:
node += addnodes.desc_addname(' = 0', ' = 0')
def parse_django_adminopt_node(env, sig, signode):
"""A copy of sphinx.directives.CmdoptionDesc.parse_signature()"""
from sphinx.domains.std import option_desc_re
count = 0
firstname = ''
for m in option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not count:
for m in simple_option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not firstname:
raise ValueError
return firstname
def add_sig_args(self, signode, arglist, const):
if not arglist:
if self.sphinx_directive.objtype == 'function':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
if const:
signode += addnodes.desc_addname(const, const)
return
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
args = arglist.split(',')
for arg in args:
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
ctype, argname = arg.rsplit(' ', 1)
except ValueError:
# no argument name given, only the type
self.add_cross_ref(param, arg)
else:
self.add_cross_ref(param, ctype)
# separate by non-breaking space in the output
param += nodes.emphasis(' '+argname, u'\xa0'+argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
def handle_signature(self, sig, signode):
"""Transform an option description into RST nodes."""
count = 0
firstname = ''
for potential_option in sig.split(', '):
potential_option = potential_option.strip()
m = option_desc_re.match(potential_option)
if not m:
self.env.warn(
self.env.docname,
'Malformed option description %r, should '
'look like "opt", "-opt args", "--opt args", '
'"/opt args" or "+opt args"' % potential_option,
self.lineno)
continue
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
signode['allnames'] = [optname]
else:
signode['allnames'].append(optname)
count += 1
if not firstname:
raise ValueError
return firstname
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode]
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
member, arglist = sig.split('(', 1)
member = member.strip()
arglist = arglist[:-1].strip()
else:
member = sig
arglist = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('js:object', None)
mod_name = self.env.ref_context.get('js:module')
name = member
try:
member_prefix, member_name = member.rsplit('.', 1)
except ValueError:
member_name = name
member_prefix = ''
finally:
name = member_name
if prefix and member_prefix:
prefix = '.'.join([prefix, member_prefix])
elif prefix is None and member_prefix:
prefix = member_prefix
fullname = name
if prefix:
fullname = '.'.join([prefix, name])
signode['module'] = mod_name
signode['object'] = prefix
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if prefix:
signode += addnodes.desc_addname(prefix + '.', prefix + '.')
elif mod_name:
signode += addnodes.desc_addname(mod_name + '.', mod_name + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, prefix
def parse_c_signature(signode, sig, desctype):
"""Transform a C (or C++) signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
m = c_funcptr_sig_re.match(sig)
if m is None:
m = c_sig_re.match(sig)
if m is None:
raise ValueError('no match')
rettype, name, arglist, const = m.groups()
signode += addnodes.desc_type('', '')
parse_c_type(signode[-1], rettype)
try:
classname, funcname = name.split('::', 1)
classname += '::'
signode += addnodes.desc_addname(classname, classname)
signode += addnodes.desc_name(funcname, funcname)
# name (the full name) is still both parts
except ValueError:
signode += addnodes.desc_name(name, name)
# clean up parentheses from canonical name
m = c_funcptr_name_re.match(name)
if m:
name = m.group(1)
if not arglist:
if desctype == 'cfunction':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
return name
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
args = arglist.split(',')
for arg in args:
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
ctype, argname = arg.rsplit(' ', 1)
except ValueError:
# no argument name given, only the type
parse_c_type(param, arg)
else:
parse_c_type(param, ctype)
param += nodes.emphasis(' '+argname, ' '+argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return name
def handle_signature(self, fqname, signode):
m = fq_classname_pattern.match(fqname)
if m is not None:
package, classname, generics = m.groups()
else:
package, classname, generics = None, fqname, None
if package is not None and self.env.config.java_show_package:
signode += addnodes.desc_addname(package, package)
signode += addnodes.desc_name(classname, classname)
if generics is not None:
signode += addnodes.desc_addname(generics, generics)
if package is not None:
return package + classname
else:
return classname
def parse_option_desc(signode, sig):
"""Transform an option description into RST nodes."""
count = 0
firstname = ''
for m in option_desc_re.finditer(sig):
prefix, optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(prefix+optname, prefix+optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not firstname:
raise ValueError
return firstname
def handle_signature(self, sig, signode):
'''return the name of this object from its signature'''
# Must be able to match these (without preceding def or rdef)
# def macro_name
# def macro_name()
# def macro_name(arg1, arg2)
# rdef macro_name
# cdef("macro_name", "content", "groupname", flags)
m = spec_func_sig_re.match(sig) or spec_macro_sig_re.match(sig)
if m is None:
raise ValueError
arglist = m.groups()
name = arglist[0]
args = []
if len(arglist) > 1:
args = arglist[1:]
if name == 'cdef':
# TODO: need to match complete arg list
# several different signatures are possible (see cdef-examples.mac)
# for now, just get the macro name and ignore the arg list
m = spec_cdef_name_sig_re.match(args[0])
arglist = m.groups()
name = arglist[0].strip('"')
args = ['<<< cdef argument list not handled yet >>>'] # FIXME:
signode += addnodes.desc_name(name, name)
if len(args) > 0:
signode += addnodes.desc_addname(args, args)
return name
def handle_signature(self, sig, signode):
context, name, argstart, arglist, argend, retann = self.parse_signature(sig)
self.context, self.contextsep = self.build_context(context)
self.module = self.options.get('module', self.env.temp_data.get('haka:module'))
self.objtype = self.build_objtype()
self.idxtype = self.options.get('idxtype') or self.options.get('objtype')
self.name = name
self.argstart = argstart
self.arglist = arglist
self.argend = argend
self.retann = retann
add_module = True
fullname = name
signode['module'] = self.module
signode['class'] = self.context
signode['fullname'] = fullname
prefix = "%s " % (self.objtype)
signode += addnodes.desc_annotation(prefix, prefix)
if self.module and self.needs_module():
modname = '%s.' % (self.module)
signode += addnodes.desc_addname(modname, modname)
self.build_signode(signode)
anno = self.options.get('annotation')
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return {'fullname': fullname, 'context': self.context,
'objtype': self.objtype, 'idxctx': self.options.get('idxctx') or ""}
def attach_name(self, signode, full_name):
"""Attaches a fully qualified TypeInfo name to the node tree"""
# Get the previous namespace
# import pdb
# pdb.set_trace()
prev_namespace = self.resolve_previous_namespace()
if prev_namespace:
curr = full_name.fqn()
if full_name.fqn().startswith(prev_namespace) and not full_name.fqn() == prev_namespace:
# print "Partially filled by parent: "
# print "Previous namespace: '{}'".format(prev_namespace)
# print " Cutting from " + full_name.fqn()
new_fqn = full_name.fqn()[len(prev_namespace):]
if new_fqn[0] == ".":
new_fqn = new_fqn[1:]
# print "New fqn is: " + new_fqn
full_name = DefinitionParser.ParseNamespace(new_fqn)
# print " to " + full_name.fqn()
names = full_name.flatten_namespace()
for space in names[:-1]:
signode += addnodes.desc_addname(space, space)
signode += nodes.Text('.')
signode += addnodes.desc_name(names[-1], names[-1])
def attach_name(self, node, name):
owner, name = name.split_owner()
varname = str(name)
if owner is not None:
owner = str(owner) + "::"
node += addnodes.desc_addname(owner, owner)
node += addnodes.desc_name(varname, varname)
def handle_signature(self, sig, signode):
match = re.search('(\w+)', sig)
name = match.groups()[0]
# At this point, we make no attempt to break up the arglist into
# reqired parameters, keywords, optional arguments etc.
# This would be very hard, since we would have to cover the syntax
# of shell, IDL, S-Lang, ...
# For our output all we want is to attach it to the name in
# reasonable formatting.
arglist = sig[len(name):]
anno = self.options.get('annotation')
lang = self.options.get('language')
signode += addnodes.desc_name(name, name)
# addname has a good formatting, even if it is meant for a
# different use in sphinx for python.
# Sphinx expects name + parameterlist, but unfortunately,
# the parameterlist is automatically wrapped in (), so we avoid that
# here.
signode += addnodes.desc_addname(arglist, arglist)
if lang:
signode += addnodes.desc(' ' + lang, ' ' + lang)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return name
def handle_signature(self, sig, signode):
sdkname = self.options.get('sdk', self.env.ref_context.get('qbs:sdk'))
pkgname = self.options.get('package', self.env.ref_context.get('qbs:package'))
modname = self.env.ref_context.get('qbs:module', None)
itemname = self.env.ref_context.get('qbs:item', None)
type, name, value = self.parse(sig)
signode['module'] = modname
signode['package'] = pkgname
signode['item'] = itemname
if self.objtype == 'property':
fullname = self.get_signature_name(objname=(modname or itemname), name=name)
else:
fullname = name
signode['sdk'] = sdkname
signode['fullname'] = fullname
sigprefix = self.get_signature_prefix()
if sigprefix:
signode += addnodes.desc_annotation(sigprefix, sigprefix)
if type:
signode += addnodes.desc_addname(type, type)
if name:
signode += addnodes.desc_name(name, name)
if value:
signode += addnodes.desc_returns(value, value)
return fullname
def handle_signature(self, sig, signode):
#synopsis = unicodedata.normalize('NFD', self.options.get('synopsis'))
synopsis = self.options.get('synopsis')
module = self.env.temp_data.get('nscp:module')
fullname = 'TODO'
if self.objtype == 'query':
fullname = '%s.%s'%(module, sig)
signode['fullname'] = fullname
signode += addnodes.desc_addname(module, module)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_content('')
signode += addnodes.compact_paragraph(synopsis, synopsis)
elif self.objtype == 'option':
command = self.env.temp_data.get('nscp:command')
fullname = '%s.%s:%s'%(module, command, sig)
signode['fullname'] = fullname
ann = ' (%s, %s)'%(module, command)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(ann, ann)
elif self.objtype == 'confpath':
fullname = '%s:%s'%(module, sig)
signode['fullname'] = fullname
ann = ' (%s)'%(module)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(ann, ann)
elif self.objtype == 'confkey':
confpath = self.env.temp_data.get('nscp:confpath', '')
fullname = '%s:%s:%s'%(module, confpath, sig)
signode['fullname'] = fullname
ann = ' (%s, %s)'%(module, confpath)
signode += addnodes.desc_name(sig, sig)
signode += addnodes.desc_annotation(ann, ann)
#print 'handle_signature(%s, %s) => %s'%(sig, signode, fullname)
return fullname, sig
def handle_signature(self, sig, signode):
name, args = parse_directive(sig)
desc_name = '.. %s::' % name
signode += addnodes.desc_name(desc_name, desc_name)
if len(args) > 0:
signode += addnodes.desc_addname(args, args)
return name
def attach_name(self, node, name):
owner, name = name.split_owner()
varname = unicode(name)
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
node += addnodes.desc_name(varname, varname)
def handle_signature(self, sig, signode):
"""Transform an option description into RST nodes."""
starts_with_arg = re.match(r'\s*\*',sig)
options = sig.split("!")
firstname = None
for i in range(len(options)):
o = options[i].strip()
ws = o.split("*")
if not firstname:
firstname = ws[0]
#is_name = not starts_with_arg
is_name = True
is_first_name = True
for x in ws:
if is_name:
n = addnodes.desc_name(x,x)
if is_first_name:
is_first_name = False
if i != 0:
n['classes'].append('duplicate')
signode += n
is_name = not is_name
else:
signode += addnodes.desc_addname(x,x)
is_name = not is_name
return firstname
def handle_signature(self, sig, signode):
"""Transform an option description into RST nodes."""
count = 0
firstname = ''
for m in option_desc_re.finditer(sig):
optname, args = m.groups()
if count:
signode += addnodes.desc_addname(', ', ', ')
signode += addnodes.desc_name(optname, optname)
signode += addnodes.desc_addname(args, args)
if not count:
firstname = optname
count += 1
if not firstname:
raise ValueError
return firstname
def handle_signature(self, sig, signode):
"""
Transform a CFEngine 3 signature into RST nodes.
"""
sig_d = {}
m = cf3_sig_re.match(sig)
try:
sig_d['type'], sig_d['ns'], sig_d['id'], sig_d['args'] = m.groups()
except AttributeError:
raise ValueError
sig_d['ns'] = sig_d['ns'] or self.options.get(
'namespace', self.env.temp_data.get('cf3:namespace')
)
fullname = []
fn_app = fullname.append
fn_app(self.objtype + _FN_SEP)
if self.objtype in ('body', 'bundle'):
tnode = addnodes.desc_type('', '')
tnode += nodes.Text(self.objtype + _SP, self.objtype)
try:
sig_d['type'] = sig_d['type'].strip()
tnode += nodes.Text(sig_d['type'] + _SP, sig_d['type'])
fn_app(sig_d['type'] + _FN_SEP)
except AttributeError:
self.state_machine.reporter.warning(
'invalid %s definition: %s' % (self.objtype, sig),
line=self.lineno
)
signode += tnode
if sig_d['ns'] and sig_d['ns'] != 'default' \
and self.env.config.add_module_names:
signode += addnodes.desc_addname(
sig_d['ns'], sig_d['ns'] + _NS_SEP
)
signode += addnodes.desc_name(sig_d['id'], sig_d['id'])
fn_app(sig_d['id'])
signode['namespace'] = sig_d['ns']
signode['fullname'] = ''.join(fullname)
if self.objtype == 'class':
signode += addnodes.desc_name(_CL_MRK, _CL_MRK)
return ''.join(fullname), sig_d['ns']
if not sig_d['args'] and self.objtype == 'function':
signode += addnodes.desc_parameterlist()
return ''.join(fullname), sig_d['ns']
if sig_d['args']:
paramlist = addnodes.desc_parameterlist()
for arg in sig_d['args'].split(','):
arg = arg.strip()
paramlist += addnodes.desc_parameter(arg, arg)
signode += paramlist
return ''.join(fullname), sig_d['ns']
def handle_signature(self, sig, signode):
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
prefix, arglist = sig.split('(', 1)
prefix = prefix.strip()
arglist = arglist[:-1].strip()
else:
prefix = sig
arglist = None
if '.' in prefix:
nameprefix, name = prefix.rsplit('.', 1)
else:
nameprefix = None
name = prefix
objectname = self.env.temp_data.get('js:object')
if nameprefix:
if objectname:
# someone documenting the method of an attribute
# of the current object? shouldn't happen but
# who knows...
nameprefix = objectname + '.' + nameprefix
fullname = nameprefix + '.' + name
elif objectname:
fullname = objectname + '.' + name
else:
# just a function or constructor
objectname = ''
fullname = name
signode['object'] = objectname
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
if nameprefix:
signode += addnodes.desc_addname(nameprefix + '.',
nameprefix + '.')
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
class_name = self.options.get('outertype')
# object belongs to some class or namespace
if class_name:
# func_desc = function return type + function name
func_desc = fullname.split(' ', 1)
if len(func_desc) > 1:
fullname = func_desc[0] + ' ' + class_name +\
'.' + func_desc[1]
return fullname, nameprefix
def handle_signature(self, sig, signode):
if 'hidden' in self.options:
return sig
path = self.get_display_path()
for x in path:
signode += addnodes.desc_addname(x + '.', x + '.')
signode += addnodes.desc_name(sig, sig)
return sig
def _handle_enum_signature(self, sig, signode, m):
"Transform a Nim enum into RST nodes."
name, values = m.groups()
signode += addnodes.desc_type('enum', 'enum')
signode += addnodes.desc_name(name, name)
signode += addnodes.desc_addname(values, '= ' + values)
return name
def handle_signature(self, sig, signode):
a = (context, name, argstart, arglist, argend, retann) = self.parse_signature(sig)
self.context, self.contextsep = self.build_context(context)
self.module = self.options.get('module', self.env.temp_data.get('lua:module'))
self.clsname = self.options.get('class', self.env.temp_data.get('lua:class'))
self.objtype = self.build_objtype()
self.idxtype = self.options.get('idxtype') or self.options.get('objtype')
self.name = name
self.argstart = argstart
self.arglist = arglist
self.argend = argend
self.retann = retann
# print "context: '%s', name: '%s'" % a[:2]
# print "module: '%s', clsname: '%s', idxtype: '%s'" % (self.module, self.clsname, self.idxtype)
# print "typename: '%s', objtype: '%s'" % (self.typename, self.objtype)
# print "needs_module: '%s', needs_class: '%s'" % (self.needs_class(), self.needs_module())
# print ""
add_module = True
fullname = name
signode['module'] = self.module
signode['class'] = self.context
signode['fullname'] = fullname
prefix = "%s " % (self.objtype)
signode += addnodes.desc_annotation(prefix, prefix)
clsname = ''
if fullname.find('.') != -1 or str(self.typename) == "object":
pass
elif self.clsname and self.needs_class():
sprtr = '.' if str(self.typename) == "data" else ':'
clsname = '%s%s' % (self.clsname, sprtr)
elif self.module and self.needs_module():
clsname = '%s.' % (self.module)
if clsname:
signode += addnodes.desc_addname(clsname, clsname)
# if self.clsname and self.needs_class():
# signode += addnodes.desc_addname(clsname, clsname)
# elif str(self.typename) == "data":
# clsname = '%s:' % (self.clsname)
# signode += addnodes.desc_addname(clsname, clsname)
# elif self.module and self.needs_module():
# modname = '%s.' % (self.module)
# signode += addnodes.desc_addname(modname, modname)
self.build_signode(signode)
anno = self.options.get('annotation')
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return {'fullname': fullname, 'context': self.context,
'objtype': self.objtype, 'idxctx': self.options.get('idxctx') or ""}
def build_signode(self, signode):
if self.type == 'unary':
signode += addnodes.desc_name(self.name, self.name)
context = self.context + self.contextsep
signode += addnodes.desc_addname(context, context)
if self.retann:
signode += addnodes.desc_returns(self.retann, self.retann)
elif self.type == 'binary':
context = self.context + self.contextsep
name = " %s " % (self.name)
signode += addnodes.desc_addname(context, context)
signode += addnodes.desc_name(name, name)
signode += addnodes.desc_addname(context, context)
if self.retann:
signode += addnodes.desc_returns(self.retann, self.retann)
elif self.type == 'index' or self.type == 'newindex':
context = self.context + self.contextsep
signode += addnodes.desc_addname(context, context)
self.build_parameters(signode)
if self.retann:
if self.type == 'newindex':
retann = " = %s" % (self.retann)
signode += addnodes.desc_type(retann, retann)
else:
signode += addnodes.desc_returns(self.retann, self.retann)
elif self.type == 'convert':
context = self.context + self.contextsep
signode += addnodes.desc_name(self.name, self.name)
paramlist = _desc_parameterlist('(', ')')
paramlist.append(addnodes.desc_addname(context, context))
signode.append(paramlist)
if self.retann:
signode += addnodes.desc_returns(self.retann, self.retann)
def handle_signature(self, sig, signode):
m = sig.split()
full = m[0]
short = m[1]
ty = m[2]
signode += addnodes.desc_addname("", ty + " ")
signode += addnodes.desc_name("", short)
return full
def attach_name(self, node, name):
owner, name = name.split_owner()
varname = unicode(name)
# Olaf: Never show Class::
owner = None
if owner is not None:
owner = unicode(owner) + '::'
node += addnodes.desc_addname(owner, owner)
node += addnodes.desc_name(varname, varname)
def handle_signature(self, sig_input, signode):
"""Parses out pieces from construct signatures
Parses out prefix and argument list from construct definition. This is
assuming that the .NET languages this will support will be in a common
format, such as::
Namespace.Class.method(argument, argument, ...)
The namespace and class will be determined by the nesting of rST
directives.
Returns
Altered :py:data:`signode` with attributes corrected for rST
nesting/etc
"""
try:
sig = self.parse_signature(sig_input.strip())
except ValueError:
self.env.warn(self.env.docname,
'Parsing signature failed: "{}"'.format(sig_input),
self.lineno)
raise
prefix = self.env.ref_context.get('dn:prefix', None)
if prefix is not None:
sig.prefix = prefix
signode['object'] = sig.member
signode['prefix'] = sig.prefix
signode['fullname'] = sig.full_name()
# Prefix modifiers
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
for prefix in ['public', 'protected', 'static']:
if prefix in self.options:
signode += addnodes.desc_annotation(prefix + ' ',
prefix + ' ')
# Show prefix only on shorter declarations
if sig.prefix is not None and not self.has_arguments:
signode += addnodes.desc_addname(sig.prefix + '.', sig.prefix + '.')
signode += addnodes.desc_name(sig.member, sig.member)
if self.has_arguments:
if not sig.arguments:
signode += addnodes.desc_parameterlist()
else:
# TODO replace this
_pseudo_parse_arglist(signode, ', '.join(sig.arguments))
if isinstance(self, DotNetObjectNested):
return sig.full_name(), sig.full_name()
return sig.full_name(), sig.prefix
def handle_signature(self, sig, signode):
"""
Transform a PHP signature into RST nodes.
Returns (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = php_sig_re.match(sig)
if m is None:
raise ValueError
visibility, modifiers, name_prefix, name, arglist, retann = m.groups()
if not name_prefix:
name_prefix = ""
# determine module and class name (if applicable), as well as full name
modname = self.options.get('namespace',
self.env.temp_data.get('php:namespace'))
classname = self.env.temp_data.get('php:class')
separator = separators[self.objtype]
# Method declared as Class::methodName
if not classname and '::' in name_prefix:
classname = name_prefix.rstrip('::')
if self.objtype == 'global' or self.objtype == 'function':
add_module = False
modname = None
classname = None
fullname = name
else:
add_module = True
# name_prefix and a non-static method, means the classname was
# repeated. Trim off the <class>::
if name_prefix and self.objtype != 'staticmethod':
if name_prefix.startswith(classname):
name_prefix = name_prefix[len(classname):].rstrip('::')
classname = classname.rstrip('::')
fullname = name_prefix + classname + separator + name
elif name_prefix:
classname = classname.rstrip('::')
fullname = name_prefix + name
# Currently in a class, but not creating another class,
elif classname and not self.objtype in [
'class', 'exception', 'interface', 'trait'
]:
if not self.env.temp_data['php:in_class']:
name_prefix = classname + separator
fullname = classname + separator + name
else:
classname = ''
fullname = name
signode['namespace'] = modname
signode['class'] = self.class_name = classname
signode['fullname'] = fullname
if visibility:
signode += addnodes.desc_annotation(visibility, visibility)
sig_prefix = self.get_signature_prefix(sig)
if modifiers and not (sig_prefix and 'static' in sig_prefix):
signode += addnodes.desc_annotation(modifiers, modifiers)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if name_prefix:
if modname and not self.env.temp_data['php:in_class']:
name_prefix = modname + NS + name_prefix
signode += addnodes.desc_addname(name_prefix, name_prefix)
elif add_module and self.env.config.add_module_names:
if self.objtype == 'global':
nodetext = ''
signode += addnodes.desc_addname(nodetext, nodetext)
else:
modname = self.options.get(
'namespace', self.env.temp_data.get('php:namespace'))
if modname and not self.env.temp_data.get(
'php:in_class', False):
nodetext = modname + NS
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
_pseudo_parse_arglist(signode, arglist)
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
def handle_signature(self, sig, signode):
"""Transform a PSschema signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
name = sig
signode += addnodes.desc_name('', '')
objectname = self.env.temp_data.get('psdom:object')
ot = self.objtype
ws = wsplit_re.split(sig)
if ot == 'db':
sig_prefix = "database "
else:
sig_prefix = ot + " "
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
# for part in filter(None, ws):
# tnode = nodes.Text(part, part)
# pnode = addnodes.pending_xref(
# '', refdomain='psdom', reftype='type', reftarget=part,
# modname=None, classname=None)
# pnode = tnode
# signode += pnode
if len(ws) > 2:
dbname, tablename, columnname = ws
name = columnname
fullname = tablename + "." + columnname
elif len(ws) == 2:
if ot == 'table':
dbname, tablename = ws
dbname += "."
name = tablename
signode['table'] = tablename
signode += addnodes.desc_addname(dbname, dbname)
signode += addnodes.desc_name(tablename, tablename)
# fullname = dbname + "." + tablename
fullname = tablename
if ot == 'column':
tablename, columnname = ws
tablename += " "
signode += addnodes.desc_addname(tablename, tablename)
signode += addnodes.desc_name(columnname, columnname)
signode['table'] = tablename
fullname = tablename + "." + columnname
else:
if ot == 'table':
tablename = ws[0]
signode['table'] = tablename
dbname = self.options.get('db',
self.env.temp_data.get('psdom:db'))
dbname += "."
self.env.temp_data['psdom:table'] = tablename
signode += addnodes.desc_addname(dbname, dbname)
signode += addnodes.desc_name(tablename, tablename)
signode['table'] = tablename
if ot == 'column':
columnname = ws[0]
signode['column'] = columnname
tablename = self.options.get(
'table', self.env.temp_data.get('psdom:table'))
tablename += "."
signode += addnodes.desc_addname(tablename, tablename)
signode += addnodes.desc_name(columnname, columnname)
if ot == 'db':
dbname = ws[0]
signode['db'] = dbname
name = dbname
self.env.temp_data['psdom:db'] = dbname
signode += addnodes.desc_name(dbname, dbname)
fullname = ws[0]
signode['fullname'] = fullname
return fullname
def handle_signature(self, sig, signode):
"""
Transform a Ruby signature into RST nodes.
Returns (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = rb_sig_re.match(sig)
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
if not name_prefix:
name_prefix = ""
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.temp_data.get('rb:module'))
classname = self.env.temp_data.get('rb:class')
if self.objtype == 'global':
add_module = False
modname = None
classname = None
fullname = name
elif classname:
add_module = False
if name_prefix and name_prefix.startswith(classname):
fullname = name_prefix + name
# class name is given again in the signature
name_prefix = name_prefix[len(classname):].lstrip('.')
else:
separator = separators[self.objtype]
fullname = classname + separator + name_prefix + name
else:
add_module = True
if name_prefix:
classname = name_prefix.rstrip('.')
fullname = name_prefix + name
else:
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = self.class_name = classname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if name_prefix:
signode += addnodes.desc_addname(name_prefix, name_prefix)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and self.env.config.add_module_names:
if self.objtype == 'global':
nodetext = ''
signode += addnodes.desc_addname(nodetext, nodetext)
else:
modname = self.options.get('module',
self.env.temp_data.get('rb:module'))
if modname and modname != 'exceptions':
nodetext = modname + separators[self.objtype]
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in rb_paramlist_re.split(arglist):
if token == '[':
opt = addnodes.desc_optional()
stack[-1] += opt
stack.append(opt)
elif token == ']':
try:
stack.pop()
except IndexError:
raise ValueError
elif not token or token == ',' or token.isspace():
pass
else:
token = token.strip()
stack[-1] += addnodes.desc_parameter(token, token)
if len(stack) != 1:
raise ValueError
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname, name_prefix
def handle_signature(self, sig, signode):
"""
Transform a Fortran signature into RST nodes.
Returns (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = f_sig_re.match(sig)
if m is None:
raise ValueError
ftype, objtype, modname, typename, name, arglist = m.groups()
if not typename: typename = ""
# determine module, type, shape and attributes
modname = (modname and modname[:-1]) or self.options.get(
'module', self.env.temp_data.get('f:module'))
if typename:
name = typename[:-1]
attrs = self.options.get('attrs')
shape = parse_shape(self.options.get('shape'))
ftype = ftype or self.options.get('type')
if self.objtype == 'typefield' and not typename:
raise ValueError
#if typename: name = typename+'%'+name
#fullname = name
#if modname:
if self.objtype == 'program':
fullname = name
else:
fullname = (modname or '_') + f_sep + name
signode['module'] = modname
signode['type'] = typename
signode['fullname'] = fullname
# Add "function" or "subroutine" tag
sig_prefix = self.get_signature_prefix(sig)
if objtype or sig_prefix:
objtype = objtype or sig_prefix
signode += addnodes.desc_annotation(objtype + ' ', objtype + ' ')
# Add module
if self.env.config.add_module_names and modname and self.objtype != 'typefield':
nodetext = modname + f_sep
signode += addnodes.desc_addname(nodetext, nodetext)
# Add name
signode += addnodes.desc_name(name, name)
# In the parenthesis
if self.needs_arglist(): # call for functions and subroutines
if arglist: # Calling arguments
_pseudo_parse_arglist(signode, arglist)
elif self.needs_arglist(
): # for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
elif arglist and not shape: # Declare shape instead of arguments (variables)
shape = arglist
# Add remaining
self.add_shape_and_attrs(signode, modname, ftype, shape, attrs)
return fullname, ftype
def handle_signature(self, sig, signode):
print('BsvDecoratorMixin.handle_signature', sig)
ret = super(BsvDecoratorMixin, self).handle_signature(sig, signode)
signode.insert(0, addnodes.desc_addname('@', '@'))
return ret
def make_signature(self, obj, signode):
reg = "reg{} ".format(obj.width)
signode += addnodes.desc_addname(reg, reg)
signode += addnodes.desc_name(obj.name, obj.name)
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode]
ret = super(PyDecoratorMixin,
self).handle_signature(sig, signode) # type: ignore
signode.insert(0, addnodes.desc_addname('@', '@'))
return ret
def handle_signature(self, sig: str, signode: desc_signature) -> Tuple[str, str]:
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
member, arglist = sig.split('(', 1)
member = member.strip()
arglist = arglist[:-1].strip()
else:
member = sig
arglist = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('js:object', None)
mod_name = self.env.ref_context.get('js:module')
name = member
try:
member_prefix, member_name = member.rsplit('.', 1)
except ValueError:
member_name = name
member_prefix = ''
finally:
name = member_name
if prefix and member_prefix:
prefix = '.'.join([prefix, member_prefix])
elif prefix is None and member_prefix:
prefix = member_prefix
fullname = name
if prefix:
fullname = '.'.join([prefix, name])
signode['module'] = mod_name
signode['object'] = prefix
signode['fullname'] = fullname
display_prefix = self.get_display_prefix()
if display_prefix:
signode += addnodes.desc_annotation('', '', *display_prefix)
actual_prefix = None
if prefix:
actual_prefix = prefix
elif mod_name:
actual_prefix = mod_name
if actual_prefix:
addName = addnodes.desc_addname('', '')
for p in actual_prefix.split('.'):
addName += addnodes.desc_sig_name(p, p)
addName += addnodes.desc_sig_punctuation('.', '.')
signode += addName
signode += addnodes.desc_name('', '', addnodes.desc_sig_name(name, name))
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, prefix
def handle_signature(self, sig, signode):
"""Transform a Yacas signature into RST nodes.
Return (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = yacas_sig_re.match(sig)
if m is None:
raise ValueError
syntax, name, arglist = m.groups()
add_module = False
fullname = name
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if add_module and self.env.config.add_module_names:
modname = self.options.get('module',
self.env.temp_data.get('ys:module'))
if modname:
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
anno = self.options.get('annotation')
if syntax == 'prefix':
signode += addnodes.desc_name(name, name)
signode += addnodes.desc_type(arglist, arglist)
return fullname, ''
if syntax == 'infix':
left, right = arglist.split(',')
left = left + ' '
right = ' ' + right
signode += addnodes.desc_type(left, left)
signode += addnodes.desc_name(name, name)
signode += addnodes.desc_type(right, right)
return fullname, ''
if syntax == 'postfix':
signode += addnodes.desc_type(arglist, arglist)
signode += addnodes.desc_name(name, name)
return fullname, ''
signode += addnodes.desc_name(name, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, ''
if (syntax == 'bodied'):
body = arglist.split(',')[0]
arglist = str.join(',', arglist.split(',')[1:])
_pseudo_parse_arglist(signode, arglist)
if (syntax == 'bodied'):
signode += addnodes.desc_type(' ' + body, ' ' + body)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, ''
def handle_signature(self, sig: str,
signode: desc_signature) -> Tuple[str, str]:
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if '(' in sig and sig[-1:] == ')':
member, arglist = sig.split('(', 1)
member = member.strip()
arglist = arglist[:-1].strip()
elif ',' in sig:
# Bit ugly. For subcommands w/ aliases
member, alias = sig.split(',', 1)
member = member.strip()
alias = alias.strip()
else:
member = sig
arglist = None
alias = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('minio:object', None)
mod_name = self.env.ref_context.get('minio:command')
name = member
try:
member_prefix, member_name = member.rsplit('.', 1)
except ValueError:
member_name = name
member_prefix = ''
finally:
name = member_name
if prefix and member_prefix:
prefix = '.'.join([prefix, member_prefix])
elif prefix is None and member_prefix:
prefix = member_prefix
fullname = name
if prefix and self.allow_nesting == False:
fullname = '.'.join([prefix, name])
elif prefix and self.allow_nesting == True:
fullname = ' '.join([prefix, name])
signode['module'] = mod_name
signode['object'] = prefix
signode['fullname'] = fullname
if self.display_prefix:
signode += addnodes.desc_annotation(self.display_prefix,
self.display_prefix)
# In our current usage, we only nest for command/subcommand. So we
# need to split some of the logic here from nesting of YAML or JSON
# So if allow_nesting is true, we should use " " instead of "." for
# the prefix description.
# We also have an exit for the 'subcommand' type so that we don't end
# up building long name strings for subcommands
# Finally for subcommands w/ aliases, need to append the alias name
if prefix and self.allow_nesting == False:
signode += addnodes.desc_addname(prefix + '.', prefix + '.')
elif prefix and self.allow_nesting == True and self.objtype != 'subcommand':
signode += addnodes.desc_addname(prefix + ' ', prefix + ' ')
signode += addnodes.desc_addname(alias + ' ', alias + ' ')
elif mod_name:
signode += addnodes.desc_addname(mod_name + '.', mod_name + '.')
if (alias != None):
signode += addnodes.desc_name(name + ", " + alias,
name + ", " + alias)
else:
signode += addnodes.desc_name(name, name)
if self.has_arguments:
if not arglist:
signode += addnodes.desc_parameterlist()
else:
_pseudo_parse_arglist(signode, arglist)
return fullname, prefix
def handle_signature(self, sig: str,
signode: desc_signature) -> Tuple[str, str]:
ret = super().handle_signature(sig, signode) # type: ignore
signode.insert(0, addnodes.desc_addname('@', '@'))
return ret
def envy_resolve(app, doctree, fromdocname):
objects = app.env.domaindata['envy']['objects']
# add uplink info
for holder in doctree.traverse(uplink_placeholder):
obj = objects[holder.name]
links = []
for sp, pos, name, variants in obj.uplinks:
signode = addnodes.desc_signature('', '')
signode['first'] = False
signode += make_refnode(app.builder, fromdocname, sp.docname, sp.iname + '-' + sp.name, addnodes.desc_addname(sp.name, sp.name), sp.name)
text = ' {}: {}{}'.format(pos.format_offset(), name, pos.format_square())
post = pos.format_post()
if post:
text += ' ({})'.format(', '.join(post))
signode += addnodes.desc_name(text, text)
if variants is not None:
text = ' [{}]'.format(variants)
signode += addnodes.desc_annotation(text, text)
links.append(signode)
holder.replace_self(links)
# add subnode list
for holder in doctree.traverse(sub_placeholder):
obj = objects[holder.name]
add_variant = False
for pos, name, child, variants in obj.subs:
if variants is not None:
add_variant = True
if obj.subs:
table = nodes.table()
headers = [(1, 'Address'), (1, 'Name'), (10, 'Description')]
if add_variant:
headers.insert(1, (1, 'Variants'))
tgroup = nodes.tgroup(cols=len(headers))
table += tgroup
for colwidth, header in headers:
tgroup += nodes.colspec(colwidth=colwidth)
thead = nodes.thead()
tgroup += thead
headrow = nodes.row()
for colwidth, header in headers:
entry = nodes.entry()
para = nodes.paragraph()
entry += para
para += nodes.Text(header, header)
headrow += entry
thead += headrow
tbody = nodes.tbody()
tgroup += tbody
for pos, name, child, variants in obj.subs:
row = nodes.row()
ptext = pos.format_offset()
post = pos.format_post()
if post:
ptext += ' ({})'.format(', '.join(post))
row += wrap_text_entry(ptext)
if add_variant:
row += wrap_text_entry('all' if variants is None else variants)
row += wrap_text_entry(name + pos.format_square())
entry = nodes.entry()
para = nodes.paragraph()
entry += para
para += make_refnode(app.builder, fromdocname, child.docname, child.iname + '-' + child.name, nodes.Text(child.brief, child.brief), child.brief)
row += entry
tbody += row
holder.replace_self([table])
else:
holder.replace_self([])
def handle_signature(self, sig: str,
signode: desc_signature) -> Tuple[str, str]:
"""Breaks down construct signatures
Parses out prefix and argument list from construct definition. The
namespace and class will be determined by the nesting of domain
directives.
"""
sig = sig.strip()
if ',' in sig:
# For subcommands w/ aliases
member, alias = sig.split(',', 1)
member = member.strip()
alias = alias.strip()
elif ' ' in sig:
# For subcommands with spaces
# Need to find a better way of specifying aliases, this is very hacky
member = sig.replace(' ', '-')
alias = None
else:
member = sig
alias = None
# If construct is nested, prefix the current prefix
prefix = self.env.ref_context.get('minio:object', None)
#Grab the top-level command name.
command_name = self.env.ref_context.get('minio:mc').replace("-", " ")
name = member
format_name = member
format_alias = alias
if prefix:
fullname = '-'.join([prefix, name])
else:
fullname = name
if 'option' in self.options:
format_name = "--" + name
if 'option' in self.options and alias != None:
format_alias = "--" + alias
signode['command'] = command_name
signode['object'] = prefix
signode['fullname'] = fullname
if prefix:
signode += addnodes.desc_addname(prefix + '-', ' ')
elif command_name and ('fullpath' in self.options):
signode += addnodes.desc_addname(command_name + '-',
command_name + ' ')
elif command_name:
signode += addnodes.desc_addname(command_name + '-', ' ')
if (alias != None):
signode += addnodes.desc_name(name + ', ' + alias,
format_name + ', ' + format_alias)
elif 'notext' in self.options:
signode += addnodes.desc_name(name, '')
else:
signode += addnodes.desc_name(name, format_name)
return fullname, prefix
def handle_signature(self, sig, signode):
ret = super(PyDecoratorMixin, self).handle_signature(sig, signode)
signode.insert(0, addnodes.desc_addname('@', '@'))
return ret
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> Tuple[unicode, unicode]
"""Transform a Python signature into RST nodes.
Return (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = py_sig_re.match(sig) # type: ignore
if m is None:
raise ValueError
name_prefix, name, arglist, retann = m.groups()
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
classname = self.env.ref_context.get('py:class')
if classname:
add_module = False
if name_prefix and name_prefix.startswith(classname):
fullname = name_prefix + name
# class name is given again in the signature
name_prefix = name_prefix[len(classname):].lstrip('.')
elif name_prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + name_prefix + name
else:
# class name is not given in the signature
fullname = classname + '.' + name
else:
add_module = True
if name_prefix:
classname = name_prefix.rstrip('.')
fullname = name_prefix + name
else:
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = classname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if name_prefix:
signode += addnodes.desc_addname(name_prefix, name_prefix)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and self.env.config.add_module_names:
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
if modname and modname != 'exceptions':
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
anno = self.options.get('annotation')
signode += addnodes.desc_name(name, name)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
_pseudo_parse_arglist(signode, arglist)
if retann:
signode += addnodes.desc_returns(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
def handle_signature(self, sig, signode):
container_class_name = self.env.temp_data.get('swift:class')
# split on : -> first part is class name, second part is superclass list
parts = [x.strip() for x in sig.split(':', 1)]
# if the class name contains a < then there is a generic type attachment
if '<' in parts[0]:
class_name, generic_type = parts[0].split('<')
generic_type = generic_type[:-1]
else:
class_name = parts[0]
generic_type = None
# did we catch a 'where' ?
type_constraint = None
class_parts = None
if ' ' in class_name:
class_parts = class_name.split(' ')
elif '\t' in class_name:
class_parts = class_name.split('\t')
if class_parts:
# if a part starts with `where` then we have a type constraint
for index, p in enumerate(class_parts):
if p == 'where':
type_constraint = " ".join(
class_parts[index:]) + ": " + parts.pop()
class_name = " ".join(class_parts[:index])
break
if class_name.count('.'):
class_name = class_name.split('.')[-1]
# if we have more than one part this class has super classes / protocols
super_classes = None
if len(parts) > 1:
super_classes = [x.strip() for x in parts[1].split(',')]
# if a part starts with `where` then we have a type constraint
for index, sup in enumerate(super_classes):
if sup == 'where':
type_constraint = " ".join(super_classes[index:])
super_classes = super_classes[:index]
break
# Add class name
signode += addnodes.desc_addname(self.objtype, self.objtype + ' ')
signode += addnodes.desc_name(class_name, class_name)
# if we had super classes add annotation
if super_classes:
children = []
for c in super_classes:
prefix = ', ' if c != super_classes[0] else ''
ref = addnodes.pending_xref('',
reftype='type',
refdomain='swift',
reftarget=c,
refwarn=True)
ref += nodes.Text(prefix + c)
children.append(ref)
signode += addnodes.desc_type('', ' : ', *children)
# add type constraint
if type_constraint:
signode += addnodes.desc_type(type_constraint,
' ' + type_constraint)
add_to_index = True
if self.objtype == 'extension' and not super_classes:
add_to_index = False
if container_class_name:
class_name = container_class_name + '.' + class_name
return self.objtype + ' ' + class_name, self.objtype + ' ' + class_name, add_to_index
def handle_signature(self, sig, signode):
"""Transform a Bsv signature into RST nodes.
Return (fully qualified name of the thing, interfacename if any).
If inside a interface, the current interface name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
print('BsvObject.handle_signature', sig)
name_prefix = ''
name = sig
arglist = ''
retann = ''
if self.objtype in ['interface', 'instance', 'typeclass']:
split = sig.split('#', 1)
name = split[0]
if len(split) > 1:
arglist = split[1]
m = bsv_param_re.match(arglist)
if m: arglist = m.group(1)
elif self.objtype in ['subinterface', 'field']:
split = sig.rsplit(' ', 1)
print('rsplit', split)
name = split[-1]
if len(split) > 1:
retann = split[0]
elif self.objtype in ['method', 'function']:
split = sig.split(' ', 1)
retann = split[0]
nameparams = split[1]
split = nameparams.split('(', 1)
name = split[0]
if len(split) > 1:
arglist = split[1][0:-1]
elif self.objtype in ['module']:
split = sig.split('#', 1)
name = split[0]
if len(split) > 1:
depth = 0
paramreturn = split[1]
#print('module', paramreturn, len(paramreturn))
for i in range(0, len(paramreturn)):
c = paramreturn[i]
if c == '(': depth = depth + 1
elif c == ')': depth = depth - 1
#print(i, c, depth)
if depth == 0:
endofparam = i
break
arglist = paramreturn[1:endofparam]
retann = paramreturn[endofparam + 1:-1]
#print(arglist)
#print(endofparam, retann)
# determine package and interface name (if applicable), as well as full name
modname = self.options.get('package',
self.env.temp_data.get('bsv:package'))
interfacename = self.env.temp_data.get('bsv:interface')
if interfacename:
add_package = False
if name_prefix and name_prefix.startswith(interfacename):
fullname = name_prefix + name
# interface name is given again in the signature
name_prefix = name_prefix[len(interfacename):].lstrip('.')
elif name_prefix:
# interface name is given in the signature, but different
# (shouldn't happen)
fullname = interfacename + '.' + name_prefix + name
else:
# interface name is not given in the signature
fullname = interfacename + '.' + name
else:
add_package = True
if name_prefix:
interfacename = name_prefix.rstrip('.')
fullname = name_prefix + name
else:
interfacename = ''
fullname = name
signode['package'] = modname
signode['interface'] = interfacename
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if name_prefix:
signode += addnodes.desc_addname(name_prefix, name_prefix)
# exceptions are a special case, since they are documented in the
# 'exceptions' package.
elif add_package and self.env.config.add_package_names:
modname = self.options.get('package',
self.env.temp_data.get('bsv:package'))
if modname and modname != 'exceptions':
nodetext = modname + '::'
signode += addnodes.desc_addname(nodetext, nodetext)
anno = self.options.get('annotation')
signode += addnodes.desc_name(name, name)
#print('arglist', arglist)
if not arglist:
if self.needs_arglist():
# for callables, add an empty parameter list
if arglist:
signode += addnodes.desc_parameterlist(text=arglist)
elif self.options.get('parameter'):
signode += addnodes.desc_parameterlist(
text=self.options.get('parameter'))
if retann:
signode += addnodes.desc_returns(text=retann)
elif self.options.get('returntype'):
signode += addnodes.desc_returns(
text=self.options.get('returntype'))
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
#print('signode', signode)
return fullname, name_prefix
_pseudo_parse_arglist(signode, arglist)
if retann:
signode += addnodes.desc_returns(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
def make_signature(self, obj, signode):
signode += addnodes.desc_addname(self.objtype + ' ', self.objtype + ' ')
signode += addnodes.desc_name(obj.name, obj.name)
def handle_signature(self, sig, signode):
container_class_name = self.env.temp_data.get('kotlin:class')
container_class_type = self.env.temp_data.get('kotlin:class_type')
# split into method name and rest
first_anglebracket = sig.find('<')
first_paren = sig.find('(')
if first_anglebracket >= 0 and first_paren > first_anglebracket:
split_point = sig.find('>') + 1
else:
first_anglebracket = -1
split_point = first_paren
# calculate generics
if first_anglebracket >= 0:
sp = sig[first_anglebracket:]
np = sp.find('>')
generics = sp[:np + 1]
else:
generics = None
method_name = sig[0:split_point]
# find method specialization
angle_bracket = method_name.find('<')
if angle_bracket >= 0:
method_name = method_name[:angle_bracket]
rest = sig[split_point:]
# split parameter list
parameter_list = None
depth = 0
for i, c in enumerate(rest):
if c == '(':
depth += 1
elif c == ')':
depth -= 1
if depth == 0:
parameter_list = rest[1:i]
rest = rest[i + 1:]
break
parameters = []
if parameter_list:
parameters = self._parse_parameter_list(parameter_list)
# check for return type
return_type = None
# balance_braces = 0
# counter = 0
# for c in reversed(rest):
# counter += 1
# if balance_braces == 0 and c == ':':
# break
#
# if c == ')': balance_braces += 1
# if c == '(': balance_braces -= 1
#
# arrow = len(rest) - counter
arrow = rest.find(':')
if arrow >= 0:
return_type = rest[arrow + 2:].strip()
# build signature and add nodes
signature = ''
if self.objtype == 'static_fun':
signode += addnodes.desc_addname("static", "static fun ")
elif self.objtype == 'class_method':
signode += addnodes.desc_addname("class", "class fun ")
elif self.objtype != 'init':
signode += addnodes.desc_addname("fun", "fun ")
if self.objtype == 'init':
signode += addnodes.desc_name('init', 'init')
signature += 'init('
for p in parameters:
signature += p['name'] + ':'
signature += ')'
else:
signode += addnodes.desc_name(method_name, method_name)
signature += method_name
signature += '('
for p in parameters:
signature += p['name'] + ':'
signature += ')'
if generics:
signode += addnodes.desc_addname(generics, generics)
params = []
sig = ''
for p in parameters:
param = p['name'] + ': ' # + p['type']
sig += p['name'] + ':'
#if p['default']:
# param += ' = ' + p['default']
paramNode = addnodes.desc_parameter(param, param)
paramXref = addnodes.pending_xref('',
refdomain='kotlin',
reftype='type',
reftarget=p['type'])
paramXref += nodes.Text(p['type'], p['type'])
paramNode += paramXref
if p['default']:
paramNode += nodes.Text(' = ' + p['default'],
' = ' + p['default'])
params.append(paramNode)
signode += addnodes.desc_parameterlist(sig, "", *params)
title = signature
if return_type:
paramNode = addnodes.desc_type(' : ', ' : ') #desc_returns('', '')
paramXref = addnodes.pending_xref('',
refdomain='kotlin',
reftype='type',
reftarget=return_type)
paramXref += nodes.Text(return_type, return_type)
paramNode += paramXref
signode += paramNode
# signode += addnodes.desc_returns(return_type, return_type)
signature += '-' + return_type
#if container_class_type == 'interface':
# signature += "-interface"
#if self.objtype == 'static_method':
# signature += '-static'
#elif self.objtype == 'class_method':
# signature += '-class'
if container_class_name:
return (container_class_name + '.' +
title), (container_class_name + '.' + signature), True
return title, signature, True
def _handle_signature(self, cid, lineno, sig, signode):
# type: (str, addnodes.desc_signature) -> Tuple[str, str]
"""Transform a Python signature into RST nodes.
Return (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
This is the xml string result of signode, whitespace is not
equivalent for readability.
<desc_signature
class=""
first="False"
fullname="com.google.fonts/check/all_glyphs_have_codepoints"
module="fontbakery.profiles.cmap"
>
<desc_annotation
xml:space="preserve">FontBakeryCheck </desc_annotation>
<desc_addname
xml:space="preserve">fontbakery.profiles.cmap.</desc_addname>
<desc_name
xml:space="preserve">com_google_fonts_check_all_glyphs_have_codepoints</desc_name>
<desc_parameterlist
xml:space="preserve">
<desc_parameter xml:space="preserve">ttFont</desc_parameter>
</desc_parameterlist>
</desc_signature>
"""
m = py_sig_re.match(sig)
if m is None:
# this is the immediate fail!!!
raise ValueError
prefix, name, arglist, retann = m.groups()
# print('prefix, name, arglist, retann =', prefix, name, arglist, retann)
# > prefix, name, arglist, retann = None com_google_fonts_check_all_glyphs_have_codepoints ttFont None
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
classname = self.env.ref_context.get('py:class')
if classname:
add_module = False
if prefix and (prefix == classname
or prefix.startswith(classname + ".")):
fullname = prefix + name
# class name is given again in the signature
prefix = prefix[len(classname):].lstrip('.')
elif prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + prefix + name
else:
# class name is not given in the signature
fullname = classname + '.' + name
else:
add_module = True
if prefix:
classname = prefix.rstrip('.')
fullname = prefix + name
else:
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = classname
signode['fullname'] = fullname
signode.attributes['lineno'] = lineno
#sig_prefix = self.get_signature_prefix(sig)
#if sig_prefix:
# signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if prefix:
signode += addnodes.desc_addname(prefix, prefix)
elif add_module and self.env.config.add_module_names:
if modname and modname != 'exceptions':
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
#nodetext = modname + ' ID: '
#signode += addnodes.desc_addname(nodetext, nodetext)
pass
signode += addnodes.desc_name(name, cid)
if arglist:
_pseudo_parse_arglist(signode, arglist)
else:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_returns(retann, retann)
anno = self.options.get('annotation')
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return cid, prefix
def parse_py_signature(signode, sig, desctype, module, env):
"""
Transform a python signature into RST nodes.
Return (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = py_sig_re.match(sig)
if m is None:
raise ValueError
classname, name, arglist, retann = m.groups()
if retann:
retann = u' \N{RIGHTWARDS ARROW} ' + retann.strip()[2:]
if env.currclass:
add_module = False
if classname and classname.startswith(env.currclass):
fullname = classname + name
# class name is given again in the signature
classname = classname[len(env.currclass):].lstrip('.')
elif classname:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = env.currclass + '.' + classname + name
else:
# class name is not given in the signature
fullname = env.currclass + '.' + name
else:
add_module = True
fullname = classname and classname + name or name
if desctype == 'staticmethod':
signode += addnodes.desc_annotation('static ', 'static ')
if classname:
signode += addnodes.desc_addname(classname, classname)
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
elif add_module and env.config.add_module_names and \
module and module != 'exceptions':
nodetext = module + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if not arglist:
if desctype in ('function', 'method', 'staticmethod'):
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_type(retann, retann)
return fullname, classname
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
for token in py_paramlist_re.split(arglist):
if token == '[':
opt = addnodes.desc_optional()
stack[-1] += opt
stack.append(opt)
elif token == ']':
try:
stack.pop()
except IndexError:
raise ValueError
elif not token or token == ',' or token.isspace():
pass
else:
token = token.strip()
stack[-1] += addnodes.desc_parameter(token, token)
if len(stack) != 1:
raise ValueError
if retann:
signode += addnodes.desc_type(retann, retann)
return fullname, classname
def handle_signature(self, sig, signode):
"""Parse the signature *sig* into individual nodes and append them to the
*signode*. If ValueError is raises, parsing is aborted and the whole
*sig* string is put into a single desc_name node.
The return value is the value that identifies the object. IOW, it is
the identifier that will be used to reference this object, datum,
attribute, proc, etc. It is a tuple of "fullname" (including module and
class(es)) and the classes. See also :py:meth:`add_target_and_index`.
"""
if self._is_attr_like():
sig_match = chpl_attr_sig_pattern.match(sig)
if sig_match is None:
raise ValueError('Signature does not parse: {0}'.format(sig))
func_prefix, name_prefix, name, retann = sig_match.groups()
arglist = None
else:
sig_match = chpl_sig_pattern.match(sig)
if sig_match is None:
raise ValueError('Signature does not parse: {0}'.format(sig))
func_prefix, name_prefix, name, arglist, retann = \
sig_match.groups()
modname = self.options.get(
'module', self.env.temp_data.get('chpl:module'))
classname = self.env.temp_data.get('chpl:class')
if classname:
if name_prefix and name_prefix.startswith(classname):
fullname = name_prefix + name
# class name is given again in the signature
name_prefix = name_prefix[len(classname):].lstrip('.')
elif name_prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + name_prefix + name
else:
# class name is not given in the signature
fullname = classname + '.' + name
else:
if name_prefix:
classname = name_prefix.rstrip('.')
fullname = name_prefix + name
else:
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = classname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
# if func_prefix:
# signode += addnodes.desc_addname(func_prefix, func_prefix)
if name_prefix:
signode += addnodes.desc_addname(name_prefix, name_prefix)
anno = self.options.get('annotation')
signode += addnodes.desc_name(name, name)
if not arglist:
# If this needs an arglist, and parens were provided in the
# signature, add a parameterlist. Chapel supports paren-less
# functions and methods, which can act as computed properties. If
# arglist is the empty string, the signature included parens. If
# arglist is None, it did not include parens.
if self.needs_arglist() and arglist is not None:
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
signode += addnodes.desc_type(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
self._pseudo_parse_arglist(signode, arglist)
if retann:
signode += addnodes.desc_type(retann, retann)
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, name_prefix
def handle_signature(self, sig, signode):
container_class_name = self.env.temp_data.get('kotlin:class')
# split on : -> first part is class name, second part is superclass list
parts = [x.strip() for x in sig.split(':', 1)]
# if the class name contains a < then there is a generic type attachment
if '<' in parts[0]:
class_name, generic_type = parts[0].split('<')
generic_type = generic_type[:-1]
else:
class_name = parts[0]
generic_type = None
# did we catch a 'where' ?
type_constraint = None
class_parts = None
if ' ' in class_name:
class_parts = class_name.split(' ')
elif '\t' in class_name:
class_parts = class_name.split('\t')
if class_name.count('.'):
class_name = class_name.split('.')[-1]
# if we have more than one part this class has super classes / interfaces
super_classes = None
if len(parts) > 1:
super_classes = [x.strip() for x in parts[1].split(',')]
# Add class name
objTypeFixed = self.objtype.replace('_', ' ')
signode += addnodes.desc_addname(objTypeFixed, objTypeFixed + ' ')
signode += addnodes.desc_name(class_name, class_name)
# if we had super classes add annotation
if super_classes:
children = []
for c in super_classes:
prefix = ', ' if c != super_classes[0] else ''
ref = addnodes.pending_xref('',
reftype='type',
refdomain='kotlin',
reftarget=c,
refwarn=True)
ref += nodes.Text(prefix + c)
children.append(ref)
signode += addnodes.desc_type('', ' : ', *children)
# add type constraint
if type_constraint:
signode += addnodes.desc_type(type_constraint,
' ' + type_constraint)
add_to_index = True
if self.objtype == 'extension' and not super_classes:
add_to_index = False
if container_class_name:
class_name = container_class_name + '.' + class_name
return self.objtype + ' ' + class_name, self.objtype + ' ' + class_name, add_to_index
def handle_signature(self, sig, signode):
# type: (unicode, addnodes.desc_signature) -> unicode
"""Transform a C signature into RST nodes."""
# first try the function pointer signature regex, it's more specific
m = c_funcptr_sig_re.match(sig)
if m is None:
m = c_sig_re.match(sig)
if m is None:
raise ValueError('no match')
rettype, name, arglist, const = m.groups()
desc_type = addnodes.desc_type('', '')
signode += desc_type
self._parse_type(desc_type, rettype)
try:
classname, funcname = name.split('::', 1)
classname += '::'
signode += addnodes.desc_addname(classname, classname)
signode += addnodes.desc_name(funcname, funcname)
# name (the full name) is still both parts
except ValueError:
signode += addnodes.desc_name(name, name)
# clean up parentheses from canonical name
m = c_funcptr_name_re.match(name)
if m:
name = m.group(1)
typename = self.env.ref_context.get('c:type')
if self.name == 'c:member' and typename:
fullname = typename + '.' + name
else:
fullname = name
if not arglist:
if self.objtype == 'function' or \
self.objtype == 'macro' and sig.rstrip().endswith('()'):
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
if const:
signode += addnodes.desc_addname(const, const)
return fullname
paramlist = addnodes.desc_parameterlist()
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
# this messes up function pointer types, but not too badly ;)
for arg in self._parse_arglist(arglist):
arg = arg.strip()
param = addnodes.desc_parameter('', '', noemph=True)
try:
m = c_funcptr_arg_sig_re.match(arg)
if m:
self._parse_type(param, m.group(1) + '(')
param += nodes.emphasis(m.group(2), m.group(2))
self._parse_type(param, ')(' + m.group(3) + ')')
if m.group(4):
param += addnodes.desc_addname(m.group(4), m.group(4))
else:
ctype, argname = arg.rsplit(' ', 1)
self._parse_type(param, ctype)
# separate by non-breaking space in the output
param += nodes.emphasis(' ' + argname, u'\xa0' + argname)
except ValueError:
# no argument name given, only the type
self._parse_type(param, arg)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return fullname
def handle_signature(self, sig, signode):
signode += addnodes.desc_annotation("implementation",
"implementation ")
signode += addnodes.desc_addname(sig, sig)
return sig
def handle_signature(self, sig: str,
signode: desc_signature) -> Tuple[str, str]:
"""Transform a Python signature into RST nodes.
Return (fully qualified name of the thing, classname if any).
If inside a class, the current class name is handled intelligently:
* it is stripped from the displayed name if present
* it is added to the full name (return value) if not present
"""
m = py_sig_re.match(sig)
if m is None:
raise ValueError
prefix, name, arglist, retann = m.groups()
# determine module and class name (if applicable), as well as full name
modname = self.options.get('module',
self.env.ref_context.get('py:module'))
classname = self.env.ref_context.get('py:class')
if classname:
add_module = False
if prefix and (prefix == classname
or prefix.startswith(classname + ".")):
fullname = prefix + name
# class name is given again in the signature
prefix = prefix[len(classname):].lstrip('.')
elif prefix:
# class name is given in the signature, but different
# (shouldn't happen)
fullname = classname + '.' + prefix + name
else:
# class name is not given in the signature
fullname = classname + '.' + name
else:
add_module = True
if prefix:
classname = prefix.rstrip('.')
fullname = prefix + name
else:
classname = ''
fullname = name
signode['module'] = modname
signode['class'] = classname
signode['fullname'] = fullname
sig_prefix = self.get_signature_prefix(sig)
if sig_prefix:
signode += addnodes.desc_annotation(sig_prefix, sig_prefix)
if prefix:
signode += addnodes.desc_addname(prefix, prefix)
elif add_module and self.env.config.add_module_names:
if modname and modname != 'exceptions':
# exceptions are a special case, since they are documented in the
# 'exceptions' module.
nodetext = modname + '.'
signode += addnodes.desc_addname(nodetext, nodetext)
signode += addnodes.desc_name(name, name)
if arglist:
try:
signode += _parse_arglist(arglist)
except SyntaxError:
# fallback to parse arglist original parser.
# it supports to represent optional arguments (ex. "func(foo [, bar])")
_pseudo_parse_arglist(signode, arglist)
except NotImplementedError as exc:
logger.warning("could not parse arglist (%r): %s",
arglist,
exc,
location=signode)
_pseudo_parse_arglist(signode, arglist)
else:
if self.needs_arglist():
# for callables, add an empty parameter list
signode += addnodes.desc_parameterlist()
if retann:
children = _parse_annotation(retann)
signode += addnodes.desc_returns(retann, '', *children)
anno = self.options.get('annotation')
if anno:
signode += addnodes.desc_annotation(' ' + anno, ' ' + anno)
return fullname, prefix
def handle_signature(self, sig, signode):
signode += addnodes.desc_annotation("typedef", "typedef ")
signode += addnodes.desc_addname(sig, sig)
return sig
def handle_signature(self, sig, signode):
signode += addnodes.desc_annotation("entity", "entity ")
signode += addnodes.desc_addname(sig, sig)
return sig
def make_signature(self, obj, signode):
space = "{}-bit space ".format(obj.width)
signode += addnodes.desc_addname(space, space)
signode += addnodes.desc_name(self.name, self.name)
sz = " [{:#x}]".format(obj.size)
signode += addnodes.desc_addname(sz, sz)
def handle_signature(self, sig, signode):
signode += addnodes.desc_addname(sig, sig)
return sig
