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 _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_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 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 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 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 _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