def render_atom(token, signode, noemph=True):
"add syntax hi-lighting to interesting atoms"
if token.startswith("&") or token.startswith(":"):
signode.append(addnodes.desc_parameter(token, token))
else:
signode.append(addnodes.desc_parameter(token, token))
def _get_column_node(m):
if m.group('name'):
node = addnodes.desc_parameter()
if m.group('key'):
node += nodes.Text("#", "#")
key = nodes.strong(m.group('name'), m.group('name'))
key['classes'].append('arg-key')
node += key
if m.group('type'):
node += nodes.Text(" : ", " : ")
value = nodes.inline(m.group('type'), m.group('type'))
value['classes'].append('arg-value') # FIXME: should vbe arg type probably
node += value
if m.group('optional'):
node += nodes.Text("? ", "?") # FIXME: find a better type
if m.group('reference'):
value = nodes.inline(m.group('reference'), m.group('reference'))
value['classes'].append('arg-value') # FIXME: should vbe arg type probably
node += value
return node
else:
return addnodes.desc_parameter(m.group(0), m.group(0))
def _get_param_node(m,optional):
if m.group('flag'):
node = addnodes.desc_parameter()
flag = nodes.strong(m.group('flag'), m.group('flag'))
if optional:
flag['classes'].append('arg-flag-optional')
else:
flag['classes'].append('arg-flag')
node += flag
return flag
else:
return addnodes.desc_parameter(m.group(0), m.group(0))
def handle_signature(self, sig, signode):
method = self.method.upper() + " "
signode += addnodes.desc_name(method, method)
offset = 0
path = None
for match in http_sig_param_re.finditer(sig):
path = sig[offset : match.start()]
signode += addnodes.desc_name(path, path)
params = addnodes.desc_parameterlist()
typ = match.group("type")
if typ:
typ += ": "
params += addnodes.desc_annotation(typ, typ)
name = match.group("name")
params += addnodes.desc_parameter(name, name)
signode += params
offset = match.end()
if offset < len(sig):
path = sig[offset : len(sig)]
signode += addnodes.desc_name(path, path)
if path is None:
assert False, "no matches for sig: %s" % sig
fullname = self.method.upper() + " " + path
signode["method"] = self.method
signode["path"] = sig
signode["fullname"] = fullname
return (fullname, self.method, sig)
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):
m = sig_pattern.match(sig)
if m is None:
raise ValueError()
return_type, method_name, arglist = m.groups()
arguments = []
if arglist:
for arg in arglist.split(","):
m = arg_pattern.match(arg)
if m is None:
raise ValueError()
arguments.append(m.groups())
class_name = self.env.temp_data.get("java:class")
if not class_name:
self.env.warn(
self.env.docname, "Java method description of %s outside of class is not supported" % sig, self.lineno
)
raise ValueError()
if return_type is not None: # will be absent for constructors
self._parse_type(return_type, signode)
signode += nodes.Text(" ", " ")
signode += addnodes.desc_name(method_name, method_name)
signode += addnodes.desc_parameterlist()
for type, name in arguments:
signode[-1] += addnodes.desc_parameter("", "", noemph=True)
self._parse_type(type, signode[-1][-1])
signode[-1][-1] += nodes.Text(" ", " ")
signode[-1][-1] += nodes.emphasis(name, name)
return "%s#%s(%s)" % (class_name, method_name, ", ".join(type for type, name in arguments))
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 handle_signature(self, sig, signode):
cache = _APP_CACHES.get(self.env.app, {})
key = CursorKind.MACRO_DEFINITION, (sig, )
if key in cache:
node, comment, start, end, _ = cache[key]
signode += addnodes.desc_name(node.displayname, node.displayname)
# There is unfortunately no API to get the parameters of a macro,
# so we identify them by looking at the tokens.
tokens = list(node.get_tokens())
if (
tokens[1].kind is TokenKind.PUNCTUATION and
tokens[1].spelling == '('
):
paramlist = addnodes.desc_parameterlist()
for token in tokens[2:]:
if (
token.kind is TokenKind.PUNCTUATION and
token.spelling == ')'
):
break
elif token.kind is TokenKind.IDENTIFIER:
paramlist += addnodes.desc_parameter(token.spelling, token.spelling)
signode += paramlist
self.content = ViewList()
for lineno, line in enumerate(comment.splitlines(), start[0]):
self.content.append(line, '<unknown>', lineno)
return sig
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 handle_constructor_signature(self, sig, signode):
try:
member = javalang.parse.parse_constructor_signature(sig)
except javalang.parser.JavaSyntaxError:
raise self.error("syntax error in constructor signature")
if not isinstance(member, javalang.tree.ConstructorDeclaration):
raise self.error("expected constructor declaration")
mods = formatter.output_modifiers(member.modifiers).build()
signode += nodes.Text(mods + ' ', mods + ' ')
signode += addnodes.desc_name(member.name, member.name)
paramlist = addnodes.desc_parameterlist()
for parameter in member.parameters:
param = addnodes.desc_parameter('', '', noemph=True)
param += self._build_type_node(parameter.type)
if parameter.varargs:
param += nodes.Text('...', '')
param += nodes.emphasis(' ' + parameter.name, ' ' + parameter.name)
paramlist += param
signode += paramlist
param_reprs = [formatter.output_type(param.type, with_generics=False).build() for param in member.parameters]
return '%s(%s)' % (member.name, ', '.join(param_reprs))
def handle_signature(self, sig, signode):
method = self.method.upper() + ' '
signode += addnodes.desc_name(method, method)
offset = 0
path = None
for match in http_sig_param_re.finditer(sig):
path = sig[offset:match.start()]
signode += addnodes.desc_name(path, path)
params = addnodes.desc_parameterlist()
typ = match.group('type')
if typ:
typ += ': '
params += addnodes.desc_annotation(typ, typ)
name = match.group('name')
params += addnodes.desc_parameter(name, name)
signode += params
offset = match.end()
if offset < len(sig):
path = sig[offset:len(sig)]
signode += addnodes.desc_name(path, path)
assert path is not None, 'no matches for sig: %s' % sig
fullname = self.method.upper() + ' ' + path
signode['method'] = self.method
signode['path'] = sig
signode['fullname'] = fullname
return (fullname, self.method, sig)
def run(self):
#no good
# node = nodes.paragraph('', 'Hi there!',
# ids=['foo'],
# names = ['foobar']
# )
#works
# node = nodes.section(names=['foobar'])
# self.state.document.note_explicit_target(node)
# node.append(nodes.paragraph('', "foo foo"))
#no good
# node = nodes.admonition(names=['foobar'])
# self.state.document.note_explicit_target(node)
# node.append(nodes.paragraph('', "foo foo"))
# node = nodes.paragraph('', 'foo foo', names=['foobar'])
# self.state.document.note_explicit_target(node)
#This doesn't properly render
desc = addnodes.desc('',
addnodes.desc_signature('',
addnodes.desc_name('', 'namename'),
addnodes.desc_parameterlist('',
addnodes.desc_parameter('', 'def')
),
names=['namename'], fullname="namename", ids=['namename'], module=None, first=False),
desctype="function", domain="py", objtype='objtype')
#no link (because didn't properly render?)
self.state.document.note_explicit_target(desc)
return [desc]
def _pseudo_parse_arglist(signode, arglist):
# type: (addnodes.desc_signature, str) -> None
""""Parse" a list of arguments separated by commas.
Arguments can have "optional" annotations given by enclosing them in
brackets. Currently, this will split at any comma, even if it's inside a
string literal (e.g. default argument value).
"""
paramlist = addnodes.desc_parameterlist()
stack = [paramlist] # type: List[nodes.Element]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']') and not argument.endswith('[]'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
paramlist = addnodes.desc_parameterlist()
paramlist += addnodes.desc_parameter(arglist, arglist)
signode += paramlist
else:
signode += paramlist
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 _pseudo_parse_arglist(signode, arglist):
""""Parse" a list of arguments separated by commas.
Arguments can have "optional" annotations given by enclosing them in
brackets. Currently, this will split at any comma, even if it's inside a
string literal (e.g. default argument value).
"""
paramlist = addnodes.desc_parameterlist()
stack = [paramlist]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
signode += addnodes.desc_parameterlist()
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def make_desc_parameters(params):
for p in params:
if '.' in p.name:
continue
node = addnodes.desc_parameter(p.name, p.name)
if p.optional:
node = addnodes.desc_optional('', '', node)
yield node
def make_desc_parameters(params):
for p in params:
if '.' in p.name:
continue
node = addnodes.desc_parameter(p.name, p.name)
if p.optional:
node = addnodes.desc_optional('', '', node)
yield node
def _pseudo_parse_arglist(signode, arglist):
"""Parse list of comma separated arguments.
Arguments can have optional types.
"""
paramlist = addnodes.desc_parameterlist()
stack = [paramlist]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = 0
ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']') and not argument.endswith('[]'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# If there are too few or too many elements on the stack, just give
# up and treat the whole argument list as one argument, discarding
# the already partially populated paramlist node.
signode += addnodes.desc_parameterlist()
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def parse_arglist(self, signode, arglist):
"""parses argument lists
largely imported from sphinx.domains.python,
changes are mainly to make it work with space-separated
argument lists and to make it look so"""
paramlist = self._fix_paramlist(addnodes.desc_parameterlist())
stack = [paramlist]
try:
for argument in arglist.split(" "):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith("["):
stack.append(self._fix_paramlist(addnodes.desc_optional(), False))
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith("]"):
stack.pop()
argument = argument[1:].strip()
while argument.endswith("]"):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith("["):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(self._fix_paramlist(addnodes.desc_optional(), False))
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
signode += self._fix_paramlist(addnodes.desc_parameterlist())
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
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 split_id(env, sig, signode):
names = sig.split(" ")
signode += addnodes.desc_name(names[0], names[0])
plist = addnodes.desc_parameterlist()
for arg in names[1:]:
if not arg:
continue
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return names[0]
def parse_opcode_signature(signode, sig):
"""Transform an opcode signature into RST nodes."""
m = opcode_sig_re.match(sig)
if m is None: raise ValueError
opname, arglist = m.groups()
signode += addnodes.desc_name(opname, opname)
paramlist = addnodes.desc_parameterlist()
signode += paramlist
paramlist += addnodes.desc_parameter(arglist, arglist)
return opname.strip()
def parse_opcode_signature(signode, sig):
"""Transform an opcode signature into RST nodes."""
m = opcode_sig_re.match(sig)
if m is None: raise ValueError
opname, arglist = m.groups()
signode += addnodes.desc_name(opname, opname)
paramlist = addnodes.desc_parameterlist()
signode += paramlist
paramlist += addnodes.desc_parameter(arglist, arglist)
return opname.strip()
def parse_macro_arguments(signode, args):
plist = DescRPCArgumentList()
args = args.split(',')
for pos, arg in enumerate(args):
arg = arg.strip()
if pos < len(args) - 1:
arg += ','
x = DescRPCArgument()
x += addnodes.desc_parameter(arg, arg)
plist += x
signode += plist
def _parse_parameter_list(params):
"""Parse a SpeedCrunch parameter list into nodes."""
paramlist = sc_parameterlist()
stack = deque([paramlist])
for param in params.split(';'):
param = param.strip()
if param and param[-1] in '[]':
p = param[:-1].strip()
stack[-1] += addnodes.desc_parameter(p, p)
else:
stack[-1] += addnodes.desc_parameter(param, param)
if param.endswith('['):
node = addnodes.desc_optional()
stack[-1] += node
stack.append(node)
elif param.endswith(']'):
stack.pop()
return paramlist
def _parse_parameter_list(params):
"""Parse a SpeedCrunch parameter list into nodes."""
paramlist = sc_parameterlist()
stack = deque([paramlist])
for param in params.split(';'):
param = param.strip()
if param and param[-1] in '[]':
p = param[:-1].strip()
stack[-1] += addnodes.desc_parameter(p, p)
else:
stack[-1] += addnodes.desc_parameter(param, param)
if param.endswith('['):
node = addnodes.desc_optional()
stack[-1] += node
stack.append(node)
elif param.endswith(']'):
stack.pop()
return paramlist
def parse_macro_arguments(signode, args):
plist = DescRPCArgumentList()
args = args.split(',')
for pos, arg in enumerate(args):
arg = arg.strip()
if pos < len(args) - 1:
arg += ','
x = DescRPCArgument()
x += addnodes.desc_parameter(arg, arg)
plist += x
signode += plist
def append_parameters(self, node, params):
pnodes = addnodes.desc_parameterlist()
for param in params:
pnode = addnodes.desc_parameter('', '', noemph=True)
self.append_type(pnode, param.type)
pnode += nodes.Text(u' ')
pnode += nodes.emphasis(param.name, param.name)
if param.default is not None:
default = u' = ' + param.default
pnode += nodes.emphasis(default, default)
pnodes += pnode
node += pnodes
def make_process_header(self, slug, typ, version, source_uri, description,
inputs):
"""Generate a process definition header.
:param str slug: process' slug
:param str typ: process' type
:param str version: process' version
:param str source_uri: url to the process definition
:param str description: process' description
:param dict inputs: process' inputs
"""
node = addnodes.desc()
signode = addnodes.desc_signature(slug, "")
node.append(signode)
node["objtype"] = node["desctype"] = typ
signode += addnodes.desc_annotation(typ, typ, classes=["process-type"])
signode += addnodes.desc_addname("", "")
signode += addnodes.desc_name(slug + " ", slug + " ")
paramlist = addnodes.desc_parameterlist()
for field_schema, _, _ in iterate_schema({}, inputs, ""):
field_type = field_schema["type"]
field_name = field_schema["name"]
field_default = field_schema.get("default", None)
field_default = "" if field_default is None else "={}".format(
field_default)
param = addnodes.desc_parameter("", "", noemph=True)
param += nodes.emphasis(field_type,
field_type,
classes=["process-type"])
# separate by non-breaking space in the output
param += nodes.strong(text="\xa0\xa0" + field_name)
paramlist += param
signode += paramlist
signode += nodes.reference(
"",
nodes.Text("[Source: v{}]".format(version)),
refuri=source_uri,
classes=["viewcode-link"],
)
desc = nodes.paragraph()
desc += nodes.Text(description, description)
return [node, desc]
def parse_signature(self, sig, signode):
"""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('', '')
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)
if not arglist:
if self.desctype == 'cfunction':
# for functions, add an empty parameter list
signode += addnodes.desc_parameterlist()
if const:
signode += addnodes.desc_addname(const, const)
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
self._parse_type(param, arg)
else:
self._parse_type(param, ctype)
param += nodes.emphasis(' ' + argname, ' ' + argname)
paramlist += param
signode += paramlist
if const:
signode += addnodes.desc_addname(const, const)
return name
def parse_event(env, sig, signode):
m = event_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(','):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
def _parse_arglist(arglist: str) -> addnodes.desc_parameterlist:
"""Parse a list of arguments using AST parser"""
params = addnodes.desc_parameterlist(arglist)
sig = signature_from_str('(%s)' % arglist)
last_kind = None
for param in sig.parameters.values():
if param.kind != param.POSITIONAL_ONLY and last_kind == param.POSITIONAL_ONLY:
# PEP-570: Separator for Positional Only Parameter: /
params += addnodes.desc_parameter('', nodes.Text('/'))
if param.kind == param.KEYWORD_ONLY and last_kind in (param.POSITIONAL_OR_KEYWORD,
param.POSITIONAL_ONLY,
None):
# PEP-3102: Separator for Keyword Only Parameter: *
params += addnodes.desc_parameter('', nodes.Text('*'))
node = addnodes.desc_parameter()
if param.kind == param.VAR_POSITIONAL:
node += nodes.Text('*' + param.name)
elif param.kind == param.VAR_KEYWORD:
node += nodes.Text('**' + param.name)
else:
node += nodes.Text(param.name)
if param.annotation is not param.empty:
node += nodes.Text(': ' + param.annotation)
if param.default is not param.empty:
if param.annotation is not param.empty:
node += nodes.Text(' = ' + str(param.default))
else:
node += nodes.Text('=' + str(param.default))
params += node
last_kind = param.kind
if last_kind == Parameter.POSITIONAL_ONLY:
# PEP-570: Separator for Positional Only Parameter: /
params += addnodes.desc_parameter('', nodes.Text('/'))
return params
def _construct_nodes(self, signode):
sigdata = self.erl_sigdata
env_object = self.erl_env_object
# emulate erlang directives, like '-type', '-record', etc.
if self.objtype not in ('function', 'clause'):
objtype_part = '-%s' % (self.objtype, )
signode += addnodes.desc_annotation(objtype_part, objtype_part)
signode += nodes.inline(' ', ' ')
modname_part = '%s:' % (sigdata.modname, )
signode += addnodes.desc_addname(modname_part, modname_part)
name_part = sigdata.to_desc_name()
signode += addnodes.desc_name(name_part, name_part)
if sigdata.arg_list is not None:
paramlist_node = addnodes.desc_parameterlist()
signode += paramlist_node
last_node = paramlist_node
for (req, txt) in sigdata.arg_list:
if req == 'mandatory':
last_node += addnodes.desc_parameter(txt, txt)
else:
opt = addnodes.desc_optional()
opt += addnodes.desc_parameter(txt, txt)
last_node += opt
last_node = opt
if sigdata.explicit_flavor:
flavor_text = ' @%s' % (sigdata.flavor, )
signode += nodes.inline(flavor_text, flavor_text)
if sigdata.when_text is not None:
when_text = ' when %s' % (sigdata.when_text, )
signode += nodes.emphasis(when_text, when_text)
if sigdata.ret_ann:
signode += addnodes.desc_returns(sigdata.ret_ann, sigdata.ret_ann)
def parse_event(env, sig, signode):
m = event_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(','):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
def make_process_header(self, slug, typ, version, source_uri, description,
inputs):
"""Generate a process definition header.
:param str slug: process' slug
:param str typ: process' type
:param str version: process' version
:param str source_uri: url to the process definition
:param str description: process' description
:param dict inputs: process' inputs
"""
node = addnodes.desc()
signode = addnodes.desc_signature(slug, '')
node.append(signode)
node['objtype'] = node['desctype'] = typ
signode += addnodes.desc_annotation(typ, typ, classes=['process-type'])
signode += addnodes.desc_addname('', '')
signode += addnodes.desc_name(slug + ' ', slug + ' ')
paramlist = addnodes.desc_parameterlist()
for field_schema, _, _ in iterate_schema({}, inputs, ''):
field_type = field_schema['type']
field_name = field_schema['name']
field_default = field_schema.get('default', None)
field_default = '' if field_default is None else '={}'.format(
field_default)
param = addnodes.desc_parameter('', '', noemph=True)
param += nodes.emphasis(field_type,
field_type,
classes=['process-type'])
# separate by non-breaking space in the output
param += nodes.strong(text='\xa0\xa0' + field_name)
paramlist += param
signode += paramlist
signode += nodes.reference('',
nodes.Text('[Source: v{}]'.format(version)),
refuri=source_uri,
classes=['viewcode-link'])
desc = nodes.paragraph()
desc += nodes.Text(description, description)
return [node, desc]
def parse_event(env, sig, signode):
event_sig_re = re.compile(r"([a-zA-Z-]+)\s*\((.*)\)")
m = event_sig_re.match(sig)
if not m:
signode += addnodes.desc_name(sig, sig)
return sig
name, args = m.groups()
signode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
for arg in args.split(","):
arg = arg.strip()
plist += addnodes.desc_parameter(arg, arg)
signode += plist
return name
def _handle_function_signature(self, sig, signode):
m = ada_func_sig_re.match(sig)
if m is None:
print "m did not match the function"
raise ValueError
modname, name, dummy, arglist, returntype, abstract = m.groups()
print "DEBUG: modname %s name %s arglist %s" % (modname, name, arglist)
fullname = self._resolve_module_name(signode, modname, name)
print "DEBUG: fullname %s" % fullname
if not arglist:
if self.needs_arglist():
# for functions and procedures, add an empty parameter list
new_node = addnodes.desc_parameterlist()
new_node.child_text_separator = '; '
signode += new_node
if returntype:
signode += addnodes.desc_returns(returntype, returntype)
return fullname
signode += nodes.Text(' ')
new_node = addnodes.desc_parameterlist()
new_node.child_text_separator = '; '
signode += new_node
stack = [signode[-1]]
counters = [0, 0]
for token in string.split(arglist, ';'):
pieces = string.split(token, ':')
name = pieces[0].strip()
stack[-1] += addnodes.desc_parameter(
name, name + " : " + pieces[1].strip())
if len(stack) == 1:
counters[0] += 1
else:
counters[1] += 1
if len(stack) != 1:
raise ValueError
if not counters[1]:
fullname = '%s/%d' % (fullname, counters[0])
else:
fullname = '%s/%d..%d' % (fullname, counters[0], sum(counters))
if returntype:
signode += addnodes.desc_returns(returntype, returntype)
return fullname
def parse_ystaticattr(env,attr,attrnode):
m=re.match(r'([a-zA-Z0-9_]+)\.(.*)\(=(.*)\)',attr)
if not m:
print 100*'@'+' Static attribute %s not matched'%attr
attrnode+=addnodes.desc_name(attr,attr)
klass,name,default=m.groups()
#attrnode+=addnodes.desc_type('static','static')
attrnode+=addnodes.desc_name(name,name)
plist=addnodes.desc_parameterlist()
if default=='': default='unspecified'
plist+=addnodes.desc_parameter('='+default,'='+default)
attrnode+=plist
attrnode+=addnodes.desc_annotation(' [static]',' [static]')
return klass+'.'+name
def parse_ystaticattr(env, attr, attrnode):
m = re.match(r'([a-zA-Z0-9_]+)\.(.*)\(=(.*)\)', attr)
if not m:
print 100 * '@' + ' Static attribute %s not matched' % attr
attrnode += addnodes.desc_name(attr, attr)
klass, name, default = m.groups()
#attrnode+=addnodes.desc_type('static','static')
attrnode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
if default == '': default = 'unspecified'
plist += addnodes.desc_parameter('=' + default, '=' + default)
attrnode += plist
attrnode += addnodes.desc_annotation(' [static]', ' [static]')
return klass + '.' + name
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 parse_arg(plist, e):
type_ = parser.ast_type(e)
if type_ == "list":
head = e and e[0]
mode = None
if head == "?":
paramlist = addnodes.desc_optional()
paramlist.child_text_separator = ' '
for arg in e[1:]:
parse_arg(paramlist, arg)
plist += paramlist
elif head == "<splice>":
print "YES"
for arg in e[1:]:
parse_arg(plist, arg)
elif head == "|":
for i, arg in enumerate(e[1:]):
if i > 0:
plist += addnodes.desc_parameter("|",
" | ",
noemph=True)
parse_arg(plist, arg)
else:
paramlist = addnodes.desc_parameterlist()
paramlist.child_text_separator = ' '
for arg in e:
parse_arg(paramlist, arg)
plist += paramlist
elif type_ == "symbol":
if e.startswith('_:'):
e = e[2:]
plist += addnodes.desc_name(e, " " + e + " ")
else:
plist += addnodes.desc_parameter(e, " " + e + " ")
else:
e = repr(e)
plist += addnodes.desc_parameter(e, e)
def _make_index_section(self, obj, title, id):
section = self._make_section(title)
subobjs = obj.filter_by_id(id)
kwargs = {
'refdomain': 'cpp',
'refexplicit': False,
}
if subobjs:
lst = addnodes.desc()
lst['objtype'] = 'function function-index'
for obj in subobjs:
desc = addnodes.desc_signature()
span = nodes.inline()
try:
kwargs['reftype'] = 'func'
if obj.rv is not None:
span += addnodes.desc_type(text=str(obj.rv))
except AttributeError:
kwargs['reftype'] = 'member'
span += addnodes.desc_type(text=str(obj.typename))
desc += span
desc += nodes.Text(u' ')
name = unicode(obj.name)
kwargs['reftarget'] = unicode(obj.get_name())
name = name.split('::')[-1]
desc_name = addnodes.desc_name()
refnode = addnodes.pending_xref('', **kwargs)
innernode = nodes.literal(text=name)
innernode.attributes['classes'].extend(['xref', 'cpp', 'cpp-func'])
refnode += innernode
desc_name += refnode
desc += desc_name
try:
paramlist = addnodes.desc_parameterlist()
for param_obj in obj.signature:
param = addnodes.desc_parameter('', '', noemph=True)
if param_obj.type is not None:
param += nodes.Text(str(param_obj.type) + ' ')
param += nodes.emphasis(text=str(param_obj.name))
paramlist += param
desc += paramlist
if obj.const:
desc += nodes.Text(u' const')
except AttributeError:
pass
lst += desc
section += lst
return section
return None
def _handle_function_signature(self, sig, signode):
m = ada_func_sig_re.match(sig)
if m is None:
print "m did not match the function"
raise ValueError
modname, name, dummy, arglist, returntype, abstract = m.groups()
print "DEBUG: modname %s name %s arglist %s" % (modname, name, arglist)
fullname = self._resolve_module_name(signode, modname, name)
print "DEBUG: fullname %s" % fullname
if not arglist:
if self.needs_arglist():
# for functions and procedures, add an empty parameter list
new_node = addnodes.desc_parameterlist()
new_node.child_text_separator = '; '
signode += new_node
if returntype:
signode += addnodes.desc_returns(returntype, returntype)
return fullname
signode += nodes.Text(' ')
new_node = addnodes.desc_parameterlist()
new_node.child_text_separator = '; '
signode += new_node
stack = [signode[-1]]
counters = [0, 0]
for token in string.split(arglist, ';'):
pieces = string.split(token, ':')
name = pieces[0].strip()
stack[-1] += addnodes.desc_parameter(name, name + " : " + pieces[1].strip())
if len(stack) == 1:
counters[0] += 1
else:
counters[1] += 1
if len(stack) != 1:
raise ValueError
if not counters[1]:
fullname = '%s/%d' % (fullname, counters[0])
else:
fullname = '%s/%d..%d' % (fullname, counters[0], sum(counters))
if returntype:
signode += addnodes.desc_returns(returntype,returntype)
return fullname
def _handle_function_signature(self, sig, signode):
m = erl_func_sig_re.match(sig)
if m is None:
raise ValueError
modname, name, arglist, retann = m.groups()
fullname = self._resolve_module_name(signode, modname, 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 self.objtype == 'function':
return fullname + '/0'
return fullname
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
counters = [0, 0]
for token in erl_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:
counters[0] += 1
else:
counters[1] += 1
if len(stack) != 1:
raise ValueError
if not counters[1]:
fullname = '%s/%d' % (fullname, counters[0])
else:
fullname = '%s/%d..%d' % (fullname, counters[0], sum(counters))
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname
def _handle_function_signature(self, sig, signode):
# extract parts of the signature.
m = mat_func_sig_re.match(sig)
if m is None:
raise ValueError
retann, toolbox, name, arglist = m.groups()
# resolve full function name.
fullname = self._resolve_toolbox_name(signode, toolbox, name)
# handle (absence of) arguments list.
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 self.objtype == 'function':
return fullname + '/0'
return fullname
signode += addnodes.desc_parameterlist()
stack = [signode[-1]]
counters = [0, 0]
for token in mat_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:
counters[0] += 1
else:
counters[1] += 1
if len(stack) != 1:
raise ValueError
if not counters[1]:
fullname = '%s/%d' % (fullname, counters[0])
else:
fullname = '%s/%d..%d' % (fullname, counters[0], sum(counters))
if retann:
signode += addnodes.desc_returns(retann, retann)
return fullname
def handle_signature(self, sig, signode):
name = self.options['name']
parameters = json.loads(self.options['parameters']
) if 'parameters' in self.options else []
return_v = json.loads(
self.options['return']) if 'return' in self.options else ("", "")
prefix = self.options['prefix'] if 'prefix' in self.options else ""
if not ('parameters' in self.options) or not ('return'
in self.options):
print("WARNING: No parameters or return set for '" + name + "'")
signode += nodes.Text(prefix + ' ', prefix + u'\xa0')
xref = addnodes.pending_xref(':ref:`' + return_v[1] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(
' ', return_v[1].lower()),
refexplicit=False)
xref += nodes.Text(return_v[0], return_v[0])
signode += xref
signode += nodes.Text(' ', u'\xa0')
signode += addnodes.desc_name(name, name)
paramlist = addnodes.desc_parameterlist()
for tn in parameters:
param = addnodes.desc_parameter('', '', noemph=True)
prefix = ''
if len(tn) > 3 and tn[3] == "True":
prefix += "ref "
if len(tn) > 4 and tn[4] == "True":
prefix += "out "
if prefix != "":
param += nodes.Text(prefix + ' ', prefix + u'\xa0')
xref = addnodes.pending_xref(':ref:`' + tn[2] + '`',
refdomain='std',
reftype='ref',
reftarget=ws_re.sub(
' ', tn[2].lower()),
refexplicit=False)
xref += nodes.Text(tn[0], tn[0])
param += xref
param += nodes.emphasis(' ' + tn[1], u'\xa0' + tn[1])
paramlist += param
signode += paramlist
return name, ""
def _pseudo_parse_arglist(signode, arglist):
paramlist = addnodes.desc_parameterlist()
stack = [paramlist]
try:
for argument in arglist.split(','):
argument = argument.strip()
ends_open = ends_close = 0
while argument.startswith('['):
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
argument = argument[1:].strip()
while argument.startswith(']'):
stack.pop()
argument = argument[1:].strip()
while argument.endswith(']') and not argument.endswith('[]'):
ends_close += 1
argument = argument[:-1].strip()
while argument.endswith('['):
ends_open += 1
argument = argument[:-1].strip()
if argument:
stack[-1] += addnodes.desc_parameter(argument, argument)
while ends_open:
stack.append(addnodes.desc_optional())
stack[-2] += stack[-1]
ends_open -= 1
while ends_close:
stack.pop()
ends_close -= 1
if len(stack) != 1:
raise IndexError
except IndexError:
signode += addnodes.desc_parameterlist()
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def parse_ystaticattr(env, attr, attrnode):
m = re.match(r"([a-zA-Z0-9_]+)\.(.*)\(=(.*)\)", attr)
if not m:
print 100 * "@" + " Static attribute %s not matched" % attr
attrnode += addnodes.desc_name(attr, attr)
klass, name, default = m.groups()
# attrnode+=addnodes.desc_type('static','static')
attrnode += addnodes.desc_name(name, name)
plist = addnodes.desc_parameterlist()
if default == "":
default = "unspecified"
plist += addnodes.desc_parameter("=" + default, "=" + default)
attrnode += plist
attrnode += addnodes.desc_annotation(" [static]", " [static]")
return klass + "." + name
def append_parameters(self, node, params):
pnodes = addnodes.desc_parameterlist()
for param in params:
pnode = addnodes.desc_parameter('', '', noemph=True)
self.append_modifiers(pnode, param.modifiers)
self.append_type(pnode, param.typ)
pnode += nodes.Text(u' ')
pnode += nodes.emphasis(param.name, param.name)
if param.default is not None:
default = u' = ' + param.default
pnode += nodes.emphasis(default, default)
pnodes += pnode
node += pnodes
def _get_param_node(m):
if m.group('key'):
node = addnodes.desc_parameter()
key = nodes.strong(m.group('key'), m.group('key'))
key['classes'].append('arg-key')
node += key
node += nodes.Text(" ", " ")
value = nodes.inline(m.group('value'), m.group('value'))
value['classes'].append('arg-value')
node += value
return node
elif m.group('flag'):
node = addnodes.desc_parameter()
flag = nodes.strong(m.group('flag'), m.group('flag'))
flag['classes'].append('arg-flag')
node += flag
return flag
else:
return addnodes.desc_parameter(m.group(0), m.group(0))
def _get_param_node(m):
if m.group('key'):
node = addnodes.desc_parameter()
key = nodes.strong(m.group('key'), m.group('key'))
key['classes'].append('arg-key')
node += key
node += nodes.Text(" ", " ")
value = nodes.inline(m.group('value'), m.group('value'))
value['classes'].append('arg-value')
node += value
return node
elif m.group('flag'):
node = addnodes.desc_parameter()
flag = nodes.strong(m.group('flag'), m.group('flag'))
flag['classes'].append('arg-flag')
node += flag
return flag
else:
return addnodes.desc_parameter(m.group(0), m.group(0))
def handle_signature(self, sig, signode):
name = self.options["name"]
parameters = json.loads(self.options["parameters"]) if "parameters" in self.options else []
return_v = json.loads(self.options["return"]) if "return" in self.options else ("", "")
prefix = self.options["prefix"] if "prefix" in self.options else ""
if not ("parameters" in self.options) or not ("return" in self.options):
print("WARNING: No parameters or return set for '" + name + "'")
signode += nodes.Text(prefix + " ", prefix + u"\xa0")
xref = addnodes.pending_xref(
":ref:`" + return_v[1] + "`",
refdomain="std",
reftype="ref",
reftarget=ws_re.sub(" ", return_v[1].lower()),
refexplicit=False,
)
xref += nodes.Text(return_v[0], return_v[0])
signode += xref
signode += nodes.Text(" ", u"\xa0")
signode += addnodes.desc_name(name, name)
paramlist = addnodes.desc_parameterlist()
for tn in parameters:
param = addnodes.desc_parameter("", "", noemph=True)
prefix = ""
if len(tn) > 3 and tn[3] == "True":
prefix += "ref "
if len(tn) > 4 and tn[4] == "True":
prefix += "out "
if prefix != "":
param += nodes.Text(prefix + " ", prefix + u"\xa0")
xref = addnodes.pending_xref(
":ref:`" + tn[2] + "`",
refdomain="std",
reftype="ref",
reftarget=ws_re.sub(" ", tn[2].lower()),
refexplicit=False,
)
xref += nodes.Text(tn[0], tn[0])
param += xref
param += nodes.emphasis(" " + tn[1], u"\xa0" + tn[1])
paramlist += param
signode += paramlist
return name, ""
def format_parameters(self, parameters):
params = addnodes.desc_parameterlist()
for param in parameters:
node = n.container()
if param["required"]:
node += addnodes.desc_parameter(param["name"], param["name"])
else:
node += addnodes.desc_optional(param["name"], param["name"])
node += n.strong(text=" type: %s " % param["dataType"])
allowableValues = param.get("allowableValues")
if allowableValues:
allowableValues.pop("valueType", None)
node += n.emphasis(text=" %s" % allowableValues)
params += node
return params
def format_parameters(self, parameters):
params = addnodes.desc_parameterlist()
for param in parameters:
node = n.container()
if param['required']:
node += addnodes.desc_parameter(param['name'], param['name'])
else:
node += addnodes.desc_optional(param['name'], param['name'])
node += n.strong(text=' type: %s ' % param['dataType'])
allowableValues = param.get('allowableValues')
if allowableValues:
allowableValues.pop('valueType', None)
node += n.emphasis(text=' %s' % allowableValues)
params += node
return params
def format_parameters(self, parameters):
params = addnodes.desc_parameterlist()
for param in parameters:
node = n.container()
if param['required']:
node += addnodes.desc_parameter(param['name'], param['name'])
else:
node += addnodes.desc_optional(param['name'], param['name'])
node += n.strong(text=' type: %s ' % param['dataType'])
allowableValues = param.get('allowableValues')
if allowableValues:
allowableValues.pop('valueType', None)
node += n.emphasis(text=' %s' % allowableValues)
params += node
return params
def _pseudo_parse_arglist(signode, arglist):
""""Parse" a list of TeX arguments.
Arguments surrounded by brackets instead of braces are considered
"optional".
"""
paramlist = desc_texparameterlist()
have_optional = False
arguments = arglist
try:
while arguments.strip():
arguments = arguments.strip()
if arguments[0] == '[':
closing = ']'
nodetype = desc_texoptionalparameter
elif arguments[0] == '{':
closing = '}'
nodetype = desc_texparameter
elif arguments[0] == '*':
paramlist += desc_texfreeparameter('*', '*')
arguments = arguments[1:].strip()
continue
else:
raise AssertionError
# Find closing bracket
end = arguments.find(closing)
if end == -1:
raise AssertionError
argument = arguments[1:end]
arguments = arguments[end + 1:].strip()
argument = argument.strip()
paramlist += nodetype(argument, argument)
except AssertionError:
# if there are too few or too many elements on the stack, just give up
# and treat the whole argument list as one argument, discarding the
# already partially populated paramlist node
signode += desc_texparameterlist()
# Use an addnodes desc_paramter as that won't wrap it into {}
signode[-1] += addnodes.desc_parameter(arglist, arglist)
else:
signode += paramlist
def handle_signature(self, sig, signode):
if sig.startswith("("):
sig = sig[1:]
if sig.endswith(")"):
sig = sig[:-1]
name, args = sig.split(" ", 1)
params = addnodes.desc_parameterlist()
params.child_text_separator = " "
if args:
params += addnodes.desc_name(name, name + " ")
else:
params += addnodes.desc_name(name, name)
for arg in args.split():
params += addnodes.desc_parameter(name, name)
signode += params
return name
def handle_signature(self, sig, signode):
"""
handle the signature of the directive
"""
sig_match = rust_function_sig_re.match(sig)
name = sig_match.group("name")
mods = sig_match.group("mods")
args = sig_match.group("args")
ret = sig_match.group("return")
# formatted_mods = formatter.output_modifiers(mods).build()
signode += nodes.Text(mods + ' ', mods + ' ')
signode += nodes.Text('fn ', 'fn ')
# function name
signode += addnodes.desc_name(name, name)
# function arguments
paramlist = addnodes.desc_parameterlist()
if args is not None:
args = [x.strip() for x in args.split(',')]
for arg in args:
param = addnodes.desc_parameter('', '', noemph=True)
arg_match = rust_arg_re.match(arg)
typ = arg_match.group("type")
var = arg_match.group("var")
param += nodes.emphasis(var, var)
param += nodes.Text(': ', ': ')
param += self._build_type_node(typ)
print('just build type node')
paramlist += param
signode += paramlist
# return value
if ret is not None:
rnode = addnodes.desc_type('', '')
rnode += self._build_type_node(ret)
signode += nodes.Text(' -> ', ' -> ')
signode += rnode
return name
def handle_signature(self, sig: str,
signode: addnodes.desc_signature) -> Tuple[str, str]:
"""Transform a signature/object into RST nodes."""
try:
self.obj = BlarkSphinxCache.instance().find_by_name(sig)
except KeyError:
self.obj = MissingDeclaration(sig)
logger.error("Could not find object: %r (signatures unsupported)",
sig)
raise ValueError(f"Code object not found: {sig!r}")
self.env.ref_context["bk:function"] = self.obj
signode["ids"] = [sig]
signode["docname"] = self.env.docname
signode["qualified_name"] = sig
domain_data = self.env.domaindata["bk"][self.signature_prefix.lower()]
domain_data.setdefault(sig, []).append(signode)
sig_prefix = self.get_signature_prefix(sig)
signode += addnodes.desc_annotation(str(sig_prefix), '', *sig_prefix)
signode += addnodes.desc_name(self.obj.name, self.obj.name)
paramlist = addnodes.desc_parameterlist("paramlist")
for block in ("VAR_INPUT", "VAR_IN_OUT", "VAR_OUTPUT", "STRUCT"):
decls = self.obj.declarations_by_block.get(block, {})
for variable, decl in decls.items():
node = addnodes.desc_parameter()
# node += addnodes.desc_sig_operator('', '*')
node += addnodes.desc_type("", decl.type)
node += addnodes.desc_sig_space()
node += addnodes.desc_sig_name("", variable)
if block == "VAR_OUTPUT":
node += addnodes.desc_sig_punctuation(text="=>")
paramlist += node
signode += paramlist
if getattr(self.obj, "return_type", None) is not None:
signode += addnodes.desc_returns()
signode += addnodes.desc_type(text=self.obj.return_type)
prefix = ""
return sig, prefix
def handle_func_like_macro(self, sig, signode):
u"""Handles signatures of function-like macros.
If the objtype is 'function' and the the signature ``sig`` is a
function-like macro, the name of the macro is returned. Otherwise
``False`` is returned. """
global namespace
if not self.objtype == 'function':
return False
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, fullname, arglist, _const = m.groups()
arglist = arglist.strip()
if rettype or not arglist:
return False
arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup
arglist = [a.strip() for a in arglist.split(",")]
# has the first argument a type?
if len(arglist[0].split(" ")) > 1:
return False
# This is a function-like macro, it's arguments are typeless!
signode += addnodes.desc_name(fullname, fullname)
paramlist = addnodes.desc_parameterlist()
signode += paramlist
for argname in arglist:
param = addnodes.desc_parameter('', '', noemph=True)
# separate by non-breaking space in the output
param += nodes.emphasis(argname, argname)
paramlist += param
if namespace:
fullname = namespace + "." + fullname
return fullname
