def handle_signature(self, sig, signode): mod, typ, name, generic, inherits = self.parse_signature(sig) signode += addnodes.desc_type( text='{}'.format(mod if mod else 'private')) signode += nodes.Text(' ') signode += addnodes.desc_type(text='{}'.format(typ)) signode += nodes.Text(' ') signode += addnodes.desc_name(text=name) if generic: signode += nodes.Text('<{}>'.format(generic)) if inherits: signode += nodes.Text(' : ') inherit_types = split_sig(inherits) i = 1 for t in inherit_types: self.append_ref_signature(t, signode) if i < len(inherit_types): signode += nodes.Text(', ') i += 1 opt_parent = self.options[ 'parent'] if 'parent' in self.options else None form = '{}.{}' if self.has_parent() and opt_parent else '{}{}' parent = form.format(self.get_parent() if self.has_parent() else '', opt_parent if opt_parent else '') self.env.ref_context[CSharpObject.PARENT_TYPE_NAME] = self.ParentType( parent=parent, name=name, type=typ, override=opt_parent) if opt_parent: self.env.ref_context[self.PARENT_ATTR_NAME] = parent return self.get_fullname(name)
def handle_subprogram_decl(self, decl, node, signode, annotations): # type: (lal.BasicSubpDecl, N.desc, N.desc_signature) -> None subp_spec = decl.p_subp_spec_or_null().cast(lal.SubpSpec) ret_type = subp_spec.p_returns kind = 'function' if ret_type else 'procedure' name = decl.p_defining_name.text node['objtype'] = node['desctype'] = kind signode += N.desc_annotation(kind + ' ', kind + ' ') signode += N.desc_name(name, name) params = subp_spec.p_params if params: signode += nodes.Text(' ') param_list = N.desc_parameterlist() param_list.child_text_separator = '' signode += param_list for i, param in enumerate(params): assert isinstance(param, lal.ParamSpec) if i > 0: param_list += nodes.Text('; ') name = param.f_ids.text ptype = param.f_type_expr.text param_list += N.desc_parameter(name, name) param_list += nodes.Text(' : ') param_list += N.desc_type(ptype, ptype) if ret_type: signode += N.desc_annotation(' return ', ' return ') signode += N.desc_type(ret_type.text, ret_type.text) if isinstance(decl, lal.AbstractSubpDecl): signode += N.desc_annotation(' is abstract', ' is abstract')
def handle_signature(self, sig, signode): mod, typ, name, generic, params = self.parse_signature(sig) signode += addnodes.desc_type( text='{}'.format(mod.strip() if mod else 'private')) signode += nodes.Text(' ') self.append_ref_signature(typ if typ else name, signode) signode += nodes.inline(text=' ') if typ: signode += addnodes.desc_addname(text='{}'.format(name)) if generic: signode += nodes.Text('<{}>'.format(generic)) param_node = addnodes.desc_parameterlist() if params: self._params_list = self._get_params(params) for (pmod, ptyp, pname, pvalue) in self._params_list: pnode = addnodes.desc_parameter() if pmod: pnode += addnodes.desc_type(text='{}'.format(pmod)) pnode += nodes.Text(' ') self.append_ref_signature(ptyp, pnode) pnode += nodes.Text(' ') pnode += addnodes.desc_addname(text='{}'.format(pname)) if pvalue: pnode += nodes.Text(' = ') self.append_ref_signature(pvalue, pnode) param_node += pnode signode += param_node return self.get_fullname(name)
def handle_signature(self, sig, signode): mod, name = self.parse_signature(sig) if mod: signode += addnodes.desc_type(text='{}'.format(mod.strip())) signode += nodes.Text(' ') signode += addnodes.desc_type(text='enum') signode += nodes.Text(' ') signode += addnodes.desc_name(text='{}'.format(name.strip())) return self.get_fullname(name)
def foobar(argument, is_last, param): parts = argument.replace('[]', '()').split(' ') if len(parts) != 4: raise ValueError("Argument '{0}' has unexpected format".format(argument)) param += addnodes.desc_type(parts[0] + ' ', parts[0] + ' ') param += nodes.emphasis(parts[1] + ' ', parts[1] + ' ') param += addnodes.desc_type(' '.join(parts[2:]), ' '.join(parts[2:])) if not is_last: param += nodes.emphasis(', ', ', ')
def handle_signature(self, sig, signode): signode += addnodes.desc_annotation("relation", "relation ") typ, name, mult = sig.split(" ") signode += addnodes.desc_type(typ, typ + " ") show_name = name if "." in name: _, show_name = name.split(".") signode += addnodes.desc_addname(name, show_name) signode += addnodes.desc_type(mult, " " + mult) return name
def append_ref_signature(self, typname, signode, append_generic=True): match = REF_TYPE_RE.match(typname.strip()) if not match: raise Exception( 'Invalid reference type signature. Got: {}'.format(typname)) is_new, name, generic, is_array, constr = match.groups() if is_new: signode += addnodes.desc_type(text='new') signode += nodes.Text(' ') types = name.split('.') explicit_path = [] i = 1 for t in types: styp = t.strip() explicit_path.append(styp) refnode = addnodes.pending_xref('', refdomain='sphinxsharp', reftype=None, reftarget=styp, modname=None, classname=None) if not self.has_parent(): refnode[self.PARENT_ATTR_NAME] = None else: refnode[self.PARENT_ATTR_NAME] = self.get_parent() if len(explicit_path) > 1: target_path = '.'.join(explicit_path[:-1]) type_par = self.get_type_parent() if self.has_parent_type( ) else None refnode[self.PARENT_ATTR_NAME] = (type_par.parent + '.' \ if type_par and type_par.parent \ else '') + target_path refnode += addnodes.desc_type(text=styp) signode += refnode if i < len(types): signode += nodes.Text('.') i += 1 if append_generic and generic: signode += nodes.Text('<') gen_groups = split_sig(generic) i = 1 for g in gen_groups: self.append_ref_signature(g, signode, append_generic) if i < len(gen_groups): signode += nodes.Text(', ') i += 1 signode += nodes.Text('>') if is_array: signode += nodes.Text('[]') if constr is not None: signode += nodes.Text('()')
def foobar(argument, is_last, param): parts = argument.split(':') name = parts[0].split(' ') if len(name) > 1: param += addnodes.desc_type(name[0] + ' ', name[0] + ' ') param += nodes.emphasis(' '.join(name[1:]) + ': ', ' '.join(name[1:]) + ': ') else: param += nodes.emphasis(name[0] + ': ', name[0] + ': ') param += addnodes.desc_type(parts[-1], parts[-1]) if not is_last: param += nodes.emphasis('; ', '; ')
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_signature(self, sig: str, signode: desc_signature) -> Signature: signode += desc_annotation(self.objtype, self.objtype) module_name = self.options['module'] + '.' signode += desc_name(sig, sig) signode += desc_type(' = ', ' = ') signode.extend(parse_type(self.options['target'], make_desc_type)) return Signature(self.objtype, sig, self.options['module'])
def handle_signature(self, sig: str, signode: desc_signature) -> Signature: if 'oneway' in self.options: signode += desc_annotation('oneway', 'oneway') signode += desc_type(self.options['return_type'] + ' ', self.options['return_type'] + ' ') service_name = self.options['service'] + '.' signode += desc_name(sig, sig) signode += desc_addname('(', '(') first = True for name, type_ in self.options['parameters']: if first: first = False else: signode += desc_addname(', ', ', ') signode.extend(parse_type(type_, make_desc_type)) signode += make_desc_type(' ') signode += desc_addname(name, name) signode += desc_addname(')', ')') first = True if self.options['exceptions']: signode += desc_addname(' throws (', ' throws (') for name, type_ in self.options['exceptions']: if first: first = False else: signode += desc_addname(', ', ', ') signode.extend(parse_type(type_, make_desc_type)) signode += make_desc_type(' ') signode += desc_addname(name, name) if self.options['exceptions']: signode += desc_addname(')', ')') return Signature(self.objtype, service_name + sig, self.options['module'])
def _handle_object_signature(self, sig, signode, m): "Transform a Nim object into RST nodes." name = m.groups()[0] signode += addnodes.desc_type('object', 'object') signode += addnodes.desc_name(name, name) return name
def _pseudo_parse_arglist(signode, arglist): paramlist = desc_parameterlist() param = addnodes.desc_type() def foobar(argument, is_last, param): parts = argument.split(':') name = parts[0].split(' ') if len(name) > 1: param += addnodes.desc_type(name[0] + ' ', name[0] + ' ') param += nodes.emphasis(' '.join(name[1:]) + ': ', ' '.join(name[1:]) + ': ') else: param += nodes.emphasis(name[0] + ': ', name[0] + ': ') param += addnodes.desc_type(parts[-1], parts[-1]) if not is_last: param += nodes.emphasis('; ', '; ') arguments = arglist.split(';') for argument in arguments[:-1]: foobar(argument.strip(), False, param) foobar(arguments[-1].strip(), True, param) paramlist += param signode += paramlist
def handle_signature(self, sig, signode): m = ks_sig_re.match(sig) name = m.group('object') current_struct = self.env.temp_data.get('ks:structure') if m.group('prefix') is None: if current_struct is not None: fullname = current_struct + ':' + name else: struct = m.group('prefix').split(':')[-1] fullname = struct + ':' + name if struct is not None: if struct != '': signode += addnodes.desc_type(struct, struct + ':') signode += addnodes.desc_name(fullname, name) args = m.group('args') if args: signode += addnodes.desc_parameterlist(args, args) else: signode += addnodes.desc_parameterlist() return fullname
def render(self): title = self.title() rettype, name, arglist, const, signature = self.directive.parse_title(title) target = self.directive.create_target(name) # add a signature node signode = addnodes.desc_signature(signature, '') signode['first'] = False signode += addnodes.desc_type('', '') self.directive.add_return_type(signode[-1] , rettype) name = self.directive.add_sig_name(signode, name) self.directive.set_name(name) self.directive.add_sig_args(signode, arglist, const) self.directive.before_content() description_nodes = self.description() content_node = addnodes.desc_content('') content_node += description_nodes self.directive.after_content() target.extend(signode) term = self.node_factory.term("","", ids=[name], *target ) entry = self.node_factory.definition_list_item("",term, content_node) return [entry]
def render(self): title = self.title() rettype, name, arglist, const, signature = self.directive.parse_title(title) fullname = self.directive.get_full_name(name) if self.data_object.kind == "function": # set True that this might be a structure method self.directive.sphinx_directive.typemethod_set = True target = self.directive.create_target(fullname) if self.data_object.kind == "function": self.directive.sphinx_directive.typemethod_set = False # add a signature node signode = addnodes.desc_signature(signature, '') signode['first'] = False signode += addnodes.desc_type('', '') self.directive.add_return_type(signode[-1] , rettype) name = self.directive.add_sig_name(signode, name) self.directive.add_sig_args(signode, arglist, const) description_nodes = self.description() content_node = addnodes.desc_content('') content_node += description_nodes target.extend(signode) term = self.node_factory.term("","", ids=[name], *target ) entry = self.node_factory.definition_list_item("",term, content_node) return [entry]
def handle_signature(self, sig, signode): container_class_name = self.env.temp_data.get('kotlin:class') enum_case = None assoc_value = None raw_value = None # split on ( -> first part is case name parts = [x.strip() for x in sig.split('(', 1)] enum_case = parts[0].strip() if len(parts) > 1: parts = parts[1].rsplit('=', 1) assoc_value = parts[0].strip() if len(parts) > 1: raw_value = parts[1].strip() if assoc_value == "": assoc_value = None else: assoc_value = "(" + assoc_value else: parts = [x.strip() for x in sig.split('=', 1)] enum_case = parts[0].strip() if len(parts) > 1: raw_value = parts[1].strip() # Add class name signode += addnodes.desc_name(enum_case, enum_case) if assoc_value: signode += addnodes.desc_type(assoc_value, assoc_value) if raw_value: signode += addnodes.desc_addname(raw_value, " = " + raw_value) if container_class_name: enum_case = container_class_name + '.' + enum_case return enum_case, enum_case, True
def handle_signature(self, sig, signode): m = ks_sig_re.match(sig) name = m.group('object') struct = None #might override further down current_struct = self.env.temp_data.get('ks:structure') if m.group('prefix') is None: if current_struct is not None: struct = current_struct fullname = current_struct + ':' + name else: raise Exception("Method name lacks a prefix and isn't " + "indented inside a structure section. Problem " + "occurred at " + self.env.docname + ", line " + str(self.lineno) + ".") else: struct = m.group('prefix').split(':')[-1] fullname = struct + ':' + name if struct is not None: if struct != '': signode += addnodes.desc_type(struct,struct+':') signode += addnodes.desc_name(fullname, name) args = m.group('args') if args: signode += addnodes.desc_parameterlist(args,args) else: signode += addnodes.desc_parameterlist() return fullname
def handle_signature(self, sig, signode): sig = sig.strip() type_name, name, arglist = avro_sig_regex.match(sig).groups() if self.prefix: signode += addnodes.desc_annotation(self.prefix + ' ', self.prefix + ' ') if type_name: signode += addnodes.desc_type(type_name, type_name) if name: signode += addnodes.desc_name(name, name) if arglist: paramlist = addnodes.desc_parameterlist() for arg in arglist.split(','): argtype, argname = arg.split(None, 1) param = addnodes.desc_parameter(noemph=True) param += nodes.Text(argtype, argtype) param += nodes.emphasis(' ' + argname, ' ' + argname) paramlist += param signode += paramlist return name
def handle_signature(self, sig, signode): try: tag, name = sig.split() except ValueError: tag, name = None, sig cache = _APP_CACHES.get(self.env.app, {}) key = {'struct': CursorKind.STRUCT_DECL}[tag], (name, ) if key in cache: node, comment, start, end, members = cache[key] signode += addnodes.desc_type(tag, tag + ' ') signode += addnodes.desc_name(node.spelling, node.spelling) self.content = ViewList() for line in comment.splitlines(): self.content.append(line, '<unknown>') self.content.append('', '<unknown>') for (_, member_name), value in members.items(): member_node, member_comment, _, _, _ = value self.content.append( '.. c:member:: %s %s' % (member_node.type.spelling, member_node.spelling), '<unknown>' ) self.content.append('', '<unknown>') for line in member_comment.splitlines(): self.content.append(' ' + line, '<unknown>') self.content.append('', '<unknown>') 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_signature(self, sig, signode): mod, typ, name, getter, setter = self.parse_signature(sig) signode += addnodes.desc_type(text='{}'.format(mod if mod else 'private')) signode += nodes.Text(' ') self.append_ref_signature(typ, signode) signode += nodes.inline(text=' ') signode += addnodes.desc_addname(text='{}'.format(name)) signode += nodes.Text(' { ') accessors = [] if getter: accessors.append('get;') if setter: accessors.append(setter.strip()) signode += addnodes.desc_type(text=' '.join(accessors)) signode += nodes.Text(' } ') return self.get_fullname(name)
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_field_signature(self, sig, signode): try: member = javalang.parse.parse_member_signature(sig) except javalang.parser.JavaSyntaxError: raise self.error("syntax error in field signature") if not isinstance(member, javalang.tree.FieldDeclaration): raise self.error("expected field declaration") mods = formatter.output_modifiers(member.modifiers).build() signode += nodes.Text(mods + ' ', mods + ' ') tnode = addnodes.desc_type('', '') tnode += self._build_type_node(member.type) signode += tnode signode += nodes.Text(' ', ' ') if len(member.declarators) > 1: self.error('only one field may be documented at a time') declarator = member.declarators[0] signode += addnodes.desc_name(declarator.name, declarator.name) dim = '[]' * len(declarator.dimensions) signode += nodes.Text(dim) if declarator.initializer and isinstance(declarator.initializer, javalang.tree.Literal): signode += nodes.Text(' = ' + declarator.initializer.value) return declarator.name
def handle_signature(self, sig, signode): name = CHARmmify(sig, self.length) + ' ' signode += addnodes.desc_name(name, name) for arg in self.arguments[1:]: arg = u' %s ' % arg signode += addnodes.desc_type(arg, arg) return sig.lower()[:self.length]
def handle_signature(self, sig, signode): m = ks_sig_re.match(sig) name = m.group('object') current_struct = self.env.temp_data.get('ks:structure') if m.group('prefix') is None: if current_struct is not None: fullname = current_struct + ':' + name else: struct = m.group('prefix').split(':')[-1] fullname = struct + ':' + name if struct is not None: if struct != '': signode += addnodes.desc_type(struct,struct+':') signode += addnodes.desc_name(fullname, name) args = m.group('args') if args: signode += addnodes.desc_parameterlist(args,args) else: signode += addnodes.desc_parameterlist() return fullname
def run_definition(self, definition, base_ids): r""" Writes down the definition of a field of a message and parses its description. In general it can be seen as a function that converts `MessageField` in parsed document, with a description section containing both signature and informative content text. The signature are set as `attribute` object type. :param definition: a definition that should be parsed :param base_ids: the base id for indexing, local scope will be added to that id, based on the name of the field. :return: a full `desc` node, to be added to the main document """ ids = f"{base_ids}.{definition.name}" desc_type = addnodes.desc_type(text=definition.type_text) desc_name = addnodes.desc_name(text=definition.name) desc_annotation = addnodes.desc_annotation( text=definition.default_text) desc_signature = addnodes.desc_signature(ids=[ids], fullname=[definition.name]) desc_signature += desc_type desc_signature += desc_name desc_signature += desc_annotation section = self.run_section(definition.text, ids) desc_content = addnodes.desc_content() desc_content += section desc = addnodes.desc(objtype="attribute") desc += desc_signature desc += desc_content return desc
def handle_signature(self, sig, signode): m = ks_sig_re.match(sig) name = m.group('object') struct = None #might override further down current_struct = self.env.temp_data.get('ks:structure') if m.group('prefix') is None: if current_struct is not None: struct = current_struct fullname = current_struct + ':' + name else: raise Exception( "Method name lacks a prefix and isn't " + "indented inside a structure section. Problem " + "occurred at " + self.env.docname + ", line " + str(self.lineno) + ".") else: struct = m.group('prefix').split(':')[-1] fullname = struct + ':' + name if struct is not None: if struct != '': signode += addnodes.desc_type(struct, struct + ':') signode += addnodes.desc_name(fullname, name) args = m.group('args') if args: signode += addnodes.desc_parameterlist(args, args) else: signode += addnodes.desc_parameterlist() return fullname
def append_type(self, node, input_typ, ignored_types=None): """ ignored_types is a list of types to ignore in the generics of this type """ typ, modifiers, generic_types, inherited_types, array, ptr = parse_type_signature( input_typ, (self.env.docname, self.lineno)) tnode = addnodes.pending_xref('', refdomain='cs', reftype='type', reftarget=typ, modname=None, classname=None) # Note: this may not be the correct parent namespace if not self.has_parent(): tnode['cs:parent'] = None else: tnode['cs:parent'] = self.get_parent() if modifiers: self.append_modifiers(node, modifiers) typ_short = ExternalRefs.shorten_type(typ) tnode += addnodes.desc_type(typ_short, typ_short) node += tnode if generic_types: self.append_generics(node, generic_types, ignored_types=ignored_types) if array: node += nodes.Text(array) if ptr: node += nodes.Text(ptr)
def render(self): title = self.title() rettype, name, arglist, const, signature = self.directive.parse_title( title) fullname = self.directive.get_full_name(name) if self.data_object.kind == "function": # set True that this might be a structure method self.directive.sphinx_directive.typemethod_set = True target = self.directive.create_target(fullname) if self.data_object.kind == "function": self.directive.sphinx_directive.typemethod_set = False # add a signature node signode = addnodes.desc_signature(signature, '') signode['first'] = False signode += addnodes.desc_type('', '') self.directive.add_return_type(signode[-1], rettype) name = self.directive.add_sig_name(signode, name) self.directive.add_sig_args(signode, arglist, const) description_nodes = self.description() content_node = addnodes.desc_content('') content_node += description_nodes target.extend(signode) term = self.node_factory.term("", "", ids=[name], *target) entry = self.node_factory.definition_list_item("", term, content_node) return [entry]
def render(self): title = self.title() rettype, name, arglist, const, signature = self.directive.parse_title( title) target = self.directive.create_target(name) # add a signature node signode = addnodes.desc_signature(signature, '') signode['first'] = False signode += addnodes.desc_type('', '') self.directive.add_return_type(signode[-1], rettype) name = self.directive.add_sig_name(signode, name) self.directive.set_name(name) self.directive.add_sig_args(signode, arglist, const) self.directive.before_content() description_nodes = self.description() content_node = addnodes.desc_content('') content_node += description_nodes self.directive.after_content() target.extend(signode) term = self.node_factory.term("", "", ids=[name], *target) entry = self.node_factory.definition_list_item("", term, content_node) return [entry]
def handle_signature(self, sig, signode): match = param_var_re.fullmatch(sig) if match is None: logger.warning('could not parse {}'.format(sig)) return None # normalize type string type_str, visibility, name = match.groups() if name is None: logger.warning('missing name from {}'.format(sig)) return None type_str = normalize_type(type_str) signode += addnodes.desc_type(text=type_str + ' ') if visibility is not None: signode += nodes.emphasis(text=visibility + ' ') signode += addnodes.desc_name(text=name) return SolObjFullName( name=name, obj_path=tuple(self.env.ref_context.get('sol:obj_path', [])), param_types=None, )
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 p_expression_word(p): '''expression : WORD | WORD STAR | WORD STAR STAR | WORD LT WORD GT | ENUM WORD | VOID ''' p[0] = addnodes.desc_type(" ".join(p[1:]), " ".join(p[1:]))
def handle_signature(self, sig, signode): ssig = sig.split() name = u'%s-spec ' % ssig[0] signode += addnodes.desc_name(name, name) for arg in self.arguments[1:]: arg = u' %s ' % arg signode += addnodes.desc_type(arg, arg) return sig.lower()
def handle_signature(self, sig, signode): mod, typ, name, self._default = self.parse_signature(sig) signode += addnodes.desc_type(text='{}'.format(mod if mod else 'private')) signode += nodes.Text(' ') self.append_ref_signature(typ, signode) signode += nodes.inline(text=' ') signode += addnodes.desc_addname(text='{}'.format(name)) return self.get_fullname(name)
def _handle_enum_signature(self, sig, signode, m): "Transform a Nim enum into RST nodes." name, values = m.groups() signode += addnodes.desc_type('enum', 'enum') signode += addnodes.desc_name(name, name) signode += addnodes.desc_addname(values, '= ' + values) return name
def handle_signature(self, sig: str, signode: desc_signature) -> Signature: annotation = 'field' signode += desc_annotation(annotation, annotation) struct_name = self.options['struct'] + '.' signode += desc_name(sig, sig) signode += desc_type(': ', ': ') signode.extend(parse_type(self.options['type'], make_desc_type)) return Signature(self.kind, struct_name + sig, self.options['module'])
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_signature(self, sig, signode): signode += addnodes.desc_annotation("attribute", "attribute ") typ, name = sig.split(" ") default = None if "=" in name: name, default = name.split("=") signode += addnodes.desc_type(typ, typ + " ") show_name = name if "." in name: _, show_name = name.split(".") signode += addnodes.desc_addname(name, show_name) if default is not None: signode += addnodes.desc_type(default, "=" + default) return name
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 _make_typedef_documentation(self, obj): kwargs = { 'refdomain': 'cpp', 'refexplicit': False, } content = addnodes.desc_signature() content['ids'].append(obj.get_id()) content.attributes['first'] = True span = nodes.inline() span += nodes.emphasis(text = u'typedef ') if obj._ref is None or obj._ref is '' or self._get_obj_by_refid(obj._ref) is None: span += addnodes.desc_type(text = obj._type) else: ref = self._get_obj_by_refid(obj._ref) kwargs['reftarget'] = unicode(ref.get_name()) kwargs['reftype'] = qiapidoc.data.types.get_obj_type(ref) refname = addnodes.desc_name() refnode = addnodes.pending_xref('', **kwargs) innernode = nodes.literal(text = unicode(ref.name)) innernode.attributes['classes'].extend(['xref', 'cpp', 'cpp-func']) refnode += innernode refname += refnode span += refname content += span if obj._args is '': content += nodes.Text(u' ') span = nodes.inline() span += addnodes.desc_type(text = obj.rawname) content += span if obj._args is not '': content += nodes.inline() + addnodes.desc_type(text = obj._args) span = nodes.inline() span += nodes.Text(obj._desc) return content, span
def handle_signature(self, sig, signode): cache = _APP_CACHES.get(self.env.app, {}) key = CursorKind.VAR_DECL, (sig, ) if key in cache: node, comment, start, end, _ = cache[key] signode += addnodes.desc_type(node.type.spelling, node.type.spelling + ' ') signode += addnodes.desc_name(node.spelling, node.spelling) self.content = ViewList() for lineno, line in enumerate(comment.splitlines(), start[0]): self.content.append(line, '<unknown>', lineno) return sig
def handle_type_sig(self, sig, signode): m = ada_type_sig_re.match(sig) if m is None: raise Exception(f"m did not match for sig {sig}") name = m.groups()[0] signode += addnodes.desc_annotation("type ", "type ") fullname = self._resolve_module_name(signode, "", name) signode += addnodes.desc_type(name, "") return fullname
def handle_signature(self, sig, signode): cache = _APP_CACHES.get(self.env.app, {}) key = CursorKind.FUNCTION_DECL, (sig, ) if key in cache: node, comment, start, end, _ = cache[key] result_type = node.type.get_result() signode += addnodes.desc_type(result_type.spelling, result_type.spelling + ' ') signode += addnodes.desc_name(node.spelling, node.spelling) paramlist = addnodes.desc_parameterlist() for argument in node.get_arguments(): parameter = addnodes.desc_parameter() parameter += addnodes.desc_type(argument.type.spelling, argument.type.spelling + ' ') parameter += nodes.Text(argument.spelling, argument.spelling) paramlist += parameter signode += paramlist self.content = ViewList() for lineno, line in enumerate(comment.splitlines(), start[0]): self.content.append(line, '<unknown>', lineno) return sig
def _parse_type(self, type_name, node): if type_name.endswith("..."): type_name = type_name[:-3] if type_name in primitives: node += addnodes.desc_type(type_name, type_name) else: m = fq_classname_pattern.match(type_name) if m is not None: package, classname, generics = m.groups() else: package, classname, generics = None, fqname, None if package is not None: target = package + classname else: target = classname xref_text = nodes.inline() if package is not None and self.env.config.java_show_package: xref_text += nodes.Text(package, package) xref_text += addnodes.desc_type(classname, classname) if generics is not None: xref_text += nodes.Text(generics, generics) node += addnodes.pending_xref(type_name, xref_text, refdomain="java", reftype="class", reftarget=target)
def parse_c_signature(signode, sig, desctype): """Transform a C (or C++) signature into RST nodes.""" # first try the function pointer signature regex, it's more specific m = c_funcptr_sig_re.match(sig) if m is None: m = c_sig_re.match(sig) if m is None: raise ValueError('no match') rettype, name, arglist, const = m.groups() signode += addnodes.desc_type('', '') parse_c_type(signode[-1], rettype) try: classname, funcname = name.split('::', 1) classname += '::' signode += addnodes.desc_addname(classname, classname) signode += addnodes.desc_name(funcname, funcname) # name (the full name) is still both parts except ValueError: signode += addnodes.desc_name(name, name) # clean up parentheses from canonical name m = c_funcptr_name_re.match(name) if m: name = m.group(1) if not arglist: if desctype == 'cfunction': # for functions, add an empty parameter list signode += addnodes.desc_parameterlist() return name paramlist = addnodes.desc_parameterlist() arglist = arglist.replace('`', '').replace('\\ ', '') # remove markup # this messes up function pointer types, but not too badly ;) args = arglist.split(',') for arg in args: arg = arg.strip() param = addnodes.desc_parameter('', '', noemph=True) try: ctype, argname = arg.rsplit(' ', 1) except ValueError: # no argument name given, only the type parse_c_type(param, arg) else: parse_c_type(param, ctype) param += nodes.emphasis(' '+argname, ' '+argname) paramlist += param signode += paramlist if const: signode += addnodes.desc_addname(const, const) return name
def handle_signature(self, sig, signode): name = sig.strip() fullname = name content = '\n'.join(self.content) method = _http_method_re.search(content) path = _http_path_re.search(content) if method and path: prefix = method.group(1) signode += addnodes.desc_type(prefix + ' ', prefix + ' ') signode += api_url_rule(path.group(1)) return fullname
def make_signature(self): cls = self.item.cls ret = super(InstanceDocumenter, self).make_signature() if cls: super_ref = addnodes.pending_xref( cls.name, nodes.Text(cls.name, cls.name), refdomain='js', reftype='class', reftarget=cls.name ) super_ref['js:module'] = cls['sourcemodule'].name ret.append(addnodes.desc_annotation(' instance of ', ' instance of ')) ret.append(addnodes.desc_type(cls.name, '', super_ref)) if not ret: return [addnodes.desc_name('???', '???')] return ret
def handle_signature(self, sig, signode): """ Transform a memory key signature into RST nodes. Returns the name of the event """ m = memkey_sig_re.match(sig) if m is None: raise ValueError type, name = m.groups() signode += addnodes.desc_type('', '') _parse_type(signode[-1], type) #_parse_type(signode, type) signode += nodes.Text(" ") signode += sphinx.addnodes.desc_name(name, name) return name
def handle_signature(self, sig, signode): ptype = None split = sig.split(':') name = split[0] if len(split) > 1: ptype = split[1] quoted = '"{0}"'.format(name) signode += addnodes.desc_name(quoted, quoted) if ptype: signode += nodes.inline(':', ': ') signode += addnodes.desc_type(ptype, ptype) return sig
def __init__(self, sexp, types=None, show_defaults=False): if not isinstance(sexp, list): self.sexp = _read(sexp) else: self.sexp = sexp self.types = types if self.types: for i, type in enumerate(self.types): type_node = addnodes.pending_xref( '', refdomain='cl', reftype='type', reftarget=type) # type = " " + type type_node += addnodes.desc_type(type, type) self.sexp[i] = [self.sexp[i], type_node] self.show_defaults = show_defaults self.show_defaults = True
def _handle_type_signature(self, sig, signode): m = ada_type_sig_re.match(sig) if m is None: print("m did not match") raise ValueError name, value = m.groups() fullname = self._resolve_module_name(signode, '', name) # signode += addnodes.desc_parameterlist() # stack = [signode[-1]] # signode += addnodes.desc_type(name, name + " is " + value) signode += addnodes.desc_type(name, '') return fullname
def build_signode(self, signode): if self.type == 'unary': signode += addnodes.desc_name(self.name, self.name) context = self.context + self.contextsep signode += addnodes.desc_addname(context, context) if self.retann: signode += addnodes.desc_returns(self.retann, self.retann) elif self.type == 'binary': context = self.context + self.contextsep name = " %s " % (self.name) signode += addnodes.desc_addname(context, context) signode += addnodes.desc_name(name, name) signode += addnodes.desc_addname(context, context) if self.retann: signode += addnodes.desc_returns(self.retann, self.retann) elif self.type == 'index' or self.type == 'newindex': context = self.context + self.contextsep signode += addnodes.desc_addname(context, context) self.build_parameters(signode) if self.retann: if self.type == 'newindex': retann = " = %s" % (self.retann) signode += addnodes.desc_type(retann, retann) else: signode += addnodes.desc_returns(self.retann, self.retann) elif self.type == 'convert': context = self.context + self.contextsep signode += addnodes.desc_name(self.name, self.name) paramlist = _desc_parameterlist('(', ')') paramlist.append(addnodes.desc_addname(context, context)) signode.append(paramlist) if self.retann: signode += addnodes.desc_returns(self.retann, self.retann)
def handle_signature(self, sig, signode): path = self.get_display_path() signode['is_multiline'] = True line = addnodes.desc_signature_line() line['add_permalink'] = True for x in path: line += addnodes.desc_addname(x + '.', x + '.') line += addnodes.desc_name(sig, sig) if 'required' in self.options: line += addnodes.desc_annotation(' (required)', ' (required)') signode += line if 'default' in self.options: line = addnodes.desc_signature_line() line += addnodes.desc_type('Default: ', 'Default: ') line += nodes.literal(self.options['default'], self.options['default']) signode += line return sig
def parse_signature(env, sig, signode): m = sql_table_signature_re.match(sig) if not m: signode += addnodes.desc_name(sig, sig) return sig name, args = m.groups() # TODO: This should be improved with a more appropriate node. # Look for instance at the code generated by .. py:class:: babar signode += addnodes.desc_type(kind+' ',kind+' ') # Add the name of the class signode += addnodes.desc_name(name, name) plist = SQLTableSignatureNode() for m in sql_column_re.finditer(args): x = SQLTableColumnNode() x += _get_column_node(m) plist += x signode += plist return name
def handle_signature(self, sig, signode): try: section, name, default, typename = settingRe.match(sig).groups() except AttributeError: # no match self.error("Setting signature doesn't look right.") if not section: try: section = self.env.temp_data["setting_section"] except KeyError: raise self.error( "Please specify a section for the setting, either by " + "prefixing the setting with the sections within square brackets([]) " + 'or by using the "section" directive.' ) name, default, typename = (v.strip() for v in (name, default, typename)) signode += addnodes.desc_addname(section, "[" + section + "]") signode += addnodes.desc_name(name, name) if default == "#REQUIRED": signode += addnodes.desc_annotation("", " (Required)") else: signode += addnodes.desc_annotation(default, " = " + default) if "init" in self.options: signode += addnodes.desc_annotation("", " (Must be set in init.cfg)") typenode = addnodes.desc_type(typename, "") typenode += nodes.Text(" (", " (") typerefnode = self.env.domains[self.domain].roles["type"]( "type", typename, typename, self.lineno, self.state_machine )[0] typerefnode[0]["refdomain"] = "ircbot" typenode += typerefnode typenode += nodes.Text(")", ")") signode += typenode signode["index"] = "noindex" not in self.options signode["name"] = name signode["shortname"] = name signode["section"] = section signode["type"] = typename signode["default"] = default signode["text"] = "[{0}]{1} = {2} ({3})".format(section, name, default, typename) return (self.typename, signode["text"], name)