def process_link(self, env, refnode, has_explicit_title, title, target): program = env.temp_data.get("std:program") if not has_explicit_title: if " " in title and not (title.startswith("/") or title.startswith("-")): program, target = re.split(" (?=-|--|/)", title, 1) program = ws_re.sub("-", program) target = target.strip() elif " " in target: program, target = re.split(" (?=-|--|/)", target, 1) program = ws_re.sub("-", program) refnode["refprogram"] = program return title, target
def process_link(self, env, refnode, has_explicit_title, title, target): program = env.temp_data.get('std:program') if not has_explicit_title: if ' ' in title and not (title.startswith('/') or title.startswith('-')): program, target = re.split(' (?=-|--|/)', title, 1) program = ws_re.sub('-', program) target = target.strip() elif ' ' in target: program, target = re.split(' (?=-|--|/)', target, 1) program = ws_re.sub('-', program) refnode['refprogram'] = program return title, target
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 run(self): env = self.state.document.settings.env # normalize whitespace in fullname like XRefRole does fullname = ws_re.sub(' ', self.arguments[0].strip()) targetname = '%s-%s' % (self.ref_type, fullname) # keep the target; this may be used to generate a BBIndex later targets = env.domaindata['bb']['targets'].setdefault(self.ref_type, {}) targets[fullname] = env.docname, targetname # make up the descriptor: a target and potentially an index descriptor node = nodes.target('', '', ids=[targetname]) ret = [node] # add the target to the document self.state.document.note_explicit_target(node) # append the index node if necessary entries = [] for tpl in self.indextemplates: colon = tpl.find(':') if colon != -1: indextype = tpl[:colon].strip() indexentry = tpl[colon+1:].strip() % (fullname,) else: indextype = 'single' indexentry = tpl % (fullname,) entries.append((indextype, indexentry, targetname, targetname)) if entries: inode = addnodes.index(entries=entries) ret.insert(0, inode) return ret
def process_link(self, env, refnode, has_explicit_title, title, target): """Called after parsing title and target text, and creating the reference node (given in *refnode*). This method can alter the reference node and must return a new (or the same) ``(title, target)`` tuple. """ return title, ws_re.sub(' ', target)
def resolve_info_references(app, _env, refnode, contnode): """Resolve Info references. Process all :class:`~sphinx.addnodes.pending_xref` nodes whose ``reftype`` is ``infonode``. Replace the pending reference with a :class:`~docutils.nodes.reference` node, which references the corresponding web URL, as stored in the database referred to by :data:`HTMLXREF_URL`. """ if refnode["reftype"] != "infonode": return None target = ws_re.sub(" ", refnode["reftarget"]) match = INFO_RE.match(target) if not match: app.env.warn(refnode.source, "Invalid info target: {0}".format(target), refnode.line) return contnode manual = match.group("manual") node = match.group("node") xrefdb = app.env.info_htmlxref uri = xrefdb.resolve(manual, node) if not uri: message = "Cannot resolve info manual {0}".format(manual) app.env.warn(refnode.source, message, refnode.line) return contnode else: reference = nodes.reference("", "", internal=False, refuri=uri, reftitle=target) reference += contnode return reference
def run(self): # type: () -> List[nodes.Node] # normalize whitespace in fullname like XRefRole does fullname = ws_re.sub(' ', self.arguments[0].strip()) targetname = '%s-%s' % (self.name, fullname) node = nodes.target('', '', ids=[targetname]) self.state.document.note_explicit_target(node) ret = [node] # type: List[nodes.Node] if self.indextemplate: indexentry = self.indextemplate % (fullname,) indextype = 'single' colon = indexentry.find(':') if colon != -1: indextype = indexentry[:colon].strip() indexentry = indexentry[colon + 1:].strip() inode = addnodes.index(entries=[(indextype, indexentry, targetname, '', None)]) ret.insert(0, inode) name = self.name if ':' in self.name: _, name = self.name.split(':', 1) std = cast(StandardDomain, self.env.get_domain('std')) std.add_object(name, fullname, self.env.docname, targetname) return ret
def process_link(self, env, refnode, has_explicit_title, title, target): # type: (BuildEnvironment, nodes.reference, bool, unicode, unicode) -> Tuple[unicode, unicode] # NOQA """Called after parsing title and target text, and creating the reference node (given in *refnode*). This method can alter the reference node and must return a new (or the same) ``(title, target)`` tuple. """ return title, ws_re.sub(' ', target)
def process_link(self, env, refnode, has_explicit_title, title, target): paren_start = target.index("(") dot_start = target.rindex(".", 0, paren_start) dot_start = target.rindex(".", 0, dot_start) refnode["refdomain"] = "std" refnode["reftype"] = "ref" refnode["refexplicit"] = True return (target[dot_start + 1 : paren_start], ws_re.sub(" ", target.lower()))
def run(self): # type: () -> List[nodes.Node] program = ws_re.sub('-', self.arguments[0].strip()) if program == 'None': self.env.ref_context.pop('std:program', None) else: self.env.ref_context['std:program'] = program return []
def run(self): env = self.state.document.settings.env program = ws_re.sub('-', self.arguments[0].strip()) if program == 'None': env.ref_context.pop('std:program', None) else: env.ref_context['std:program'] = program return []
def run(self): env = self.state.document.settings.env program = ws_re.sub("-", self.arguments[0].strip()) if program == "None": env.ref_context.pop("std:program", None) else: env.ref_context["std:program"] = program return []
def run(self): env = self.state.document.settings.env program = ws_re.sub("-", self.arguments[0].strip()) if program == "None": env.temp_data["std:program"] = None else: env.temp_data["std:program"] = program return []
def process_link(self, env, refnode, has_explicit_title, title, target): paren_start = target.index("(") dot_start = target.rindex(".", 0, paren_start) dot_start = target.rindex(".", 0, dot_start) refnode['refdomain']='std' refnode['reftype']='ref' refnode['refexplicit']=True return (target[dot_start+1:paren_start], ws_re.sub(' ', target.lower()))
def run(self): env = self.state.document.settings.env program = ws_re.sub('-', self.arguments[0].strip()) if program == 'None': env.temp_data['std:program'] = None else: env.temp_data['std:program'] = program return []
def handle_signature(self, sig, signode): directive = get_config_directive(sig) signode.clear() # only show the directive (not daemon and resource type) signode += addnodes.desc_name(sig, directive['shortid']) # normalize whitespace like XRefRole does name = ws_re.sub('', sig) return name
def run(self): env = self.state.document.settings.env program = ws_re.sub('-', self.arguments[0].strip()) if program == 'None': env.currprogram = None else: env.currprogram = program return []
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 _split(self, text, refnode, env): try: program, target = re.split(" (?=-|--|/)", text, 1) except ValueError: env.warn_node("Malformed :option: %r, does not contain option " "marker - or -- or /" % text, refnode) return None, text else: program = ws_re.sub("-", program) return program, target
def handle_signature(self, sig, signode): if self.parse_node: name = self.parse_node(self.env, sig, signode) else: signode.clear() signode += addnodes.desc_name(sig, sig) # normalize whitespace like XRefRole does name = ws_re.sub('', sig) return name
def program_directive(name, arguments, options, content, lineno, content_offset, block_text, state, state_machine): env = state.document.settings.env program = ws_re.sub('-', arguments[0].strip()) if program == 'None': env.currprogram = None else: env.currprogram = program return []
def handle_signature(self, sig, signode): if self.display_prefix: signode += addnodes.desc_annotation(self.display_prefix, self.display_prefix) name = self.options["name"] namespace = self.options["namespace"] fullname = self.options["fullname"] inherits = json.loads(self.options["inherits"]) if "inherits" in self.options else ("", "") implements = json.loads(self.options["implements"]) if "implements" in self.options else [] signode += addnodes.desc_name(name, name) toappend = [] if inherits[0] != "Object" and inherits[0] != "Enum" and inherits[0] != "": xref = addnodes.pending_xref( ":ref:`" + inherits[1] + "`", refdomain="std", reftype="ref", reftarget=ws_re.sub(" ", inherits[1].lower()), refexplicit=False, ) xref += nodes.Text(inherits[0], inherits[0]) toappend.append(xref) for implement in implements: if len(toappend) > 0: toappend.append(nodes.Text(", ", u",\xa0")) xref = addnodes.pending_xref( ":ref:`" + implement[1] + "`", refdomain="std", reftype="ref", reftarget=ws_re.sub(" ", implement[1].lower()), refexplicit=False, ) xref += nodes.Text(implement[0], implement[0]) toappend.append(xref) if len(toappend) > 0: signode += nodes.Text(" : ", u"\xa0:\xa0") for a in toappend: signode += a return name, namespace
def run(self): self.env = env = self.state.document.settings.env # normalize whitespace in fullname like XRefRole does fullname = ws_re.sub(' ', self.arguments[0].strip()) targetname = '%s-%s' % (self.ref_type, fullname) # keep the target; this may be used to generate a BBIndex later targets = env.domaindata['bb']['targets'].setdefault(self.ref_type, {}) targets[fullname] = env.docname, targetname # make up the descriptor: a target and potentially an index descriptor node = nodes.target('', '', ids=[targetname]) ret = [node] # add the target to the document self.state.document.note_explicit_target(node) # append the index node if necessary entries = [] for tpl in self.indextemplates: colon = tpl.find(':') if colon != -1: indextype = tpl[:colon].strip() indexentry = tpl[colon + 1:].strip() % (fullname,) else: indextype = 'single' indexentry = tpl % (fullname,) entries.append( (indextype, indexentry, targetname, targetname, None)) if entries: inode = addnodes.index(entries=entries) ret.insert(0, inode) # if the node has content, set up a signature and parse the content if self.has_content: descnode = addnodes.desc() descnode['domain'] = 'bb' descnode['objtype'] = self.ref_type descnode['noindex'] = True signode = addnodes.desc_signature(fullname, '') if self.name_annotation: annotation = "%s " % self.name_annotation signode += addnodes.desc_annotation(annotation, annotation) signode += addnodes.desc_name(fullname, fullname) descnode += signode contentnode = addnodes.desc_content() self.state.nested_parse(self.content, 0, contentnode) DocFieldTransformer(self).transform_all(contentnode) descnode += contentnode ret.append(descnode) return ret
def handle_signature(self, sig, signode): if self.display_prefix: signode += addnodes.desc_annotation(self.display_prefix, self.display_prefix) name = self.options['name'] namespace = self.options['namespace'] fullname = self.options['fullname'] inherits = json.loads(self.options['inherits']) if 'inherits' in self.options else ("","") implements = json.loads(self.options['implements']) if 'implements' in self.options else [] signode += addnodes.desc_name(name, name) toappend = [] if inherits[0] != "Object" and inherits[0] != "Enum" and inherits[0] != "": xref = addnodes.pending_xref( ':ref:`' + inherits[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', inherits[1].lower()), refexplicit=False) xref += nodes.Text(inherits[0], inherits[0]) toappend.append(xref) for implement in implements: if len(toappend) > 0: toappend.append(nodes.Text(', ', u',\xa0')) xref = addnodes.pending_xref( ':ref:`' + implement[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', implement[1].lower()), refexplicit=False) xref += nodes.Text(implement[0], implement[0]) toappend.append(xref) if len(toappend) > 0: signode += nodes.Text(' : ', u'\xa0:\xa0') for a in toappend: signode += a return name, namespace
def process_link(self, env, refnode, has_explicit_title, title, target): dot_start = target.rindex(".", 0) try: dot_start = target.rindex(".", 0, dot_start) except ValueError: dot_start = -1 refnode['refdomain']='std' refnode['reftype']='ref' refnode['refexplicit']=True return (target[dot_start+1:], ws_re.sub(' ', target.lower()))
def parse_signature(self, sig, signode): parse_node = additional_xref_types[self.desctype][2] if parse_node: name = parse_node(self.env, sig, signode) else: signode.clear() signode += addnodes.desc_name(sig, sig) # normalize whitespace like xfileref_role does name = ws_re.sub('', sig) return name
def process_link(self, env, refnode, has_explicit_title, title, target): dot_start = target.rindex(".", 0) try: dot_start = target.rindex(".", 0, dot_start) except ValueError: dot_start = -1 refnode["refdomain"] = "std" refnode["reftype"] = "ref" refnode["refexplicit"] = True return (target[dot_start + 1 :], ws_re.sub(" ", target.lower()))
def process_link(self, env, refnode, has_explicit_title, title, target): """Called after parsing title and target text, and creating the reference node (given in *refnode*). This method can alter the reference node and must return a new (or the same) ``(title, target)`` tuple. """ #~ print(20130901, refnode, has_explicit_title, title, target) #~ 20130901 <pending_xref refdomain="" refexplicit="False" reftype="ddref"/> False cal.Event cal.Event target = ws_re.sub(' ', target) # replace newlines or tabs by spaces # ~ target = ' '.join(target.split()) # replace newlines or tabs by spaces level, x = resolve_name(target) if x is None: msg = "Could not resolve name %r" % target return [self._reporter.warning(msg, line=self._lineno), target] # raise Exception(msg) # lng = env.temp_data.get('language', env.config.language) lng = CurrentLanguage.get_current_value(env) with translation.override(lng): if isinstance(x, models.Field): text = utils.unescape(str(x.verbose_name)) target = model_name(x.model) + '.' + x.name # print(target) elif isinstance(x, Plugin): text = utils.unescape(str(x.verbose_name)) target = settings.SITE.userdocs_prefix + target elif isinstance(x, type) and issubclass(x, models.Model): text = utils.unescape(str(x._meta.verbose_name)) target = model_name(x) elif isinstance(x, type) and issubclass(x, actors.Actor): text = utils.unescape(str(x.title or x.label)) target = actor_name(x) elif isinstance(x, actions.Action): text = utils.unescape(str(x.label)) target = actor_name(x) else: raise Exception("Don't know how to handle %r" % x) if not has_explicit_title: # avoid replacing title by the heading text refnode['refexplicit'] = True title = text refnode['refwarn'] = False # never warn #~ refnode['reftype'] = 'ref' #~ title = "[%s]" % title #~ if target == 'welfare.reception.waitingvisitors': #~ print("20130907 ddref to %s : title=%r" % (target,title)) return title, target
def process_link(self, env, refnode, has_explicit_title, title, target): """Process the link created by this role. Swap node and manual name, to more closely match the look of references in Texinfo. """ # Normalize whitespace in info node targets target = ws_re.sub(" ", target) refnode["has_explicit_title"] = has_explicit_title if not has_explicit_title: match = INFO_RE.match(target) if match: # Swap title and node to create a title like info does title = "{0}({1})".format(match.group("node"), match.group("manual")) return title, target
def handle_signature(self, sig, signode): name = self.options['name'] type_v = json.loads(self.options['type']) xref = addnodes.pending_xref( ':ref:`' + type_v[1] + '`', refdomain='std', reftype='ref', reftarget=ws_re.sub(' ', type_v[1].lower()), refexplicit=False) xref += nodes.Text(type_v[0], type_v[0]) signode += xref signode += nodes.Text(' ', u'\xa0') signode += addnodes.desc_name(name, name) return name, ""
def run(self): env = self.state.document.settings.env # normalize whitespace in fullname like XRefRole does fullname = ws_re.sub(' ', self.arguments[0].strip()) targetname = '%s-%s' % (self.name, fullname) node = nodes.target('', '', ids=[targetname]) self.state.document.note_explicit_target(node) ret = [node] if self.indextemplate: indexentry = self.indextemplate % (fullname, ) indextype = 'single' colon = indexentry.find(':') if colon != -1: indextype = indexentry[:colon].strip() indexentry = indexentry[colon + 1:].strip() inode = addnodes.index(entries=[(indextype, indexentry, targetname, '')]) ret.insert(0, inode) name = self.name if ':' in self.name: _, name = self.name.split(':', 1) env.domaindata['std']['objects'][name, fullname] = \ env.docname, targetname return ret
def handle_signature(self, sig, signode): signode.clear() signode += addnodes.desc_name(sig, sig) return ws_re.sub('', sig)
def resolve_xref(self, env, fromdocname, builder, typ, target, node, contnode): if typ == 'ref': if node['refexplicit']: # reference to anonymous label; the reference uses # the supplied link caption docname, labelid = self.data['anonlabels'].get(target, ('', '')) sectname = node.astext() else: # reference to named label; the final node will # contain the section name after the label docname, labelid, sectname = self.data['labels'].get(target, ('', '', '')) if not docname: return None return self.build_reference_node(fromdocname, builder, docname, labelid, sectname) elif typ == 'numref': docname, labelid = self.data['anonlabels'].get(target, ('', '')) if not docname: return None if env.config.numfig is False: env.warn(fromdocname, 'numfig is disabled. :numref: is ignored.') return contnode try: target_node = env.get_doctree(docname).ids[labelid] figtype = get_figtype(target_node) figure_id = target_node['ids'][0] fignumber = env.toc_fignumbers[docname][figtype][figure_id] except (KeyError, IndexError): return None title = contnode.astext() if target == fully_normalize_name(title): title = env.config.numfig_format.get(figtype, '') newtitle = title % '.'.join(map(str, fignumber)) return self.build_reference_node(fromdocname, builder, docname, labelid, newtitle, nodeclass=addnodes.number_reference, title=title) elif typ == 'keyword': # keywords are oddballs: they are referenced by named labels docname, labelid, _ = self.data['labels'].get(target, ('', '', '')) if not docname: return None return make_refnode(builder, fromdocname, docname, labelid, contnode) elif typ == 'option': target = target.strip() # most obvious thing: we are a flag option without program if target.startswith(('-', '/', '+')): progname = node.get('std:program') elif re.search(r'[-/+]', target): try: progname, target = re.split(r' (?=-|--|/|\+)', target, 1) except ValueError: return None progname = ws_re.sub('-', progname.strip()) else: progname = None docname, labelid = self.data['progoptions'].get((progname, target), ('', '')) if not docname: return None return make_refnode(builder, fromdocname, docname, labelid, contnode) else: objtypes = self.objtypes_for_role(typ) or [] for objtype in objtypes: if (objtype, target) in self.data['objects']: docname, labelid = self.data['objects'][objtype, target] break else: docname, labelid = '', '' if not docname: return None return make_refnode(builder, fromdocname, docname, labelid, contnode)
def xfileref_role(typ, rawtext, text, lineno, inliner, options={}, content=[]): env = inliner.document.settings.env if not typ: typ = env.config.default_role else: typ = typ.lower() text = utils.unescape(text) # if the first character is a bang, don't cross-reference at all if text[0:1] == '!': text = _fix_parens(typ, text[1:], env) return [ innernodetypes.get(typ, nodes.literal)(rawtext, text, classes=['xref']) ], [] # we want a cross-reference, create the reference node nodeclass = (typ == 'download') and addnodes.download_reference or \ addnodes.pending_xref pnode = nodeclass(rawtext, reftype=typ, refcaption=False, modname=env.currmodule, classname=env.currclass) # we may need the line number for warnings pnode.line = lineno # the link title may differ from the target, but by default # they are the same title = target = text titleistarget = True # look if explicit title and target are given with `foo <bar>` syntax brace = text.find('<') if brace != -1: titleistarget = False pnode['refcaption'] = True m = caption_ref_re.match(text) if m: target = m.group(2) title = m.group(1) else: # fallback: everything after '<' is the target target = text[brace + 1:] title = text[:brace] # special target for Python object cross-references if typ in ('data', 'exc', 'func', 'class', 'const', 'attr', 'meth', 'mod', 'obj'): # fix-up parentheses in link title if titleistarget: title = title.lstrip('.') # only has a meaning for the target target = target.lstrip('~') # only has a meaning for the title title = _fix_parens(typ, title, env) # if the first character is a tilde, don't display the module/class # parts of the contents if title[0:1] == '~': title = title[1:] dot = title.rfind('.') if dot != -1: title = title[dot + 1:] # remove parentheses from the target too if target.endswith('()'): target = target[:-2] # if the first character is a dot, search more specific namespaces first # else search builtins first if target[0:1] == '.': target = target[1:] pnode['refspecific'] = True # some other special cases for the target elif typ == 'option': program = env.currprogram if titleistarget: if ' ' in title and not (title.startswith('/') or title.startswith('-')): program, target = re.split(' (?=-|--|/)', title, 1) program = ws_re.sub('-', program) target = target.strip() elif ' ' in target: program, target = re.split(' (?=-|--|/)', target, 1) program = ws_re.sub('-', program) pnode['refprogram'] = program elif typ == 'term': # normalize whitespace in definition terms (if the term reference is # broken over a line, a newline will be in target) target = ws_re.sub(' ', target).lower() elif typ == 'ref': # reST label names are always lowercased target = ws_re.sub('', target).lower() elif typ == 'cfunc': # fix-up parens for C functions too if titleistarget: title = _fix_parens(typ, title, env) # remove parentheses from the target too if target.endswith('()'): target = target[:-2] else: # remove all whitespace to avoid referencing problems target = ws_re.sub('', target) pnode['reftarget'] = target pnode += innernodetypes.get(typ, nodes.literal)(rawtext, title, classes=['xref']) return [pnode], []
def process_link(self, env, refnode, has_explicit_title, title, target): rel_filename, filename = env.relfn2path(target) make_changed_file(filename, env) return (remove_extension(title), ws_re.sub(' ', remove_extension(target)))
def entity_parse_node(env, sig, signode): signode += docutils.nodes.strong(sig, sig) return ws_re.sub('', sig)
def handle_signature(self, sig, signode): signode.clear() signode += addnodes.desc_name(sig, sig) # normalize whitespace like XRefRole does name = ws_re.sub('', sig) return name
def desc_directive(desctype, arguments, options, content, lineno, content_offset, block_text, state, state_machine): env = state.document.settings.env inode = addnodes.index(entries=[]) node = addnodes.desc() node['desctype'] = desctype noindex = ('noindex' in options) node['noindex'] = noindex # remove backslashes to support (dummy) escapes; helps Vim's highlighting signatures = map(lambda s: s.strip().replace('\\', ''), arguments[0].split('\n')) names = [] clsname = None module = options.get('module', env.currmodule) for i, sig in enumerate(signatures): # add a signature node for each signature in the current unit # and add a reference target for it sig = sig.strip() signode = addnodes.desc_signature(sig, '') signode['first'] = False node.append(signode) try: if desctype in ('function', 'data', 'class', 'exception', 'method', 'staticmethod', 'attribute'): name, clsname = parse_py_signature(signode, sig, desctype, module, env) elif desctype in ('cfunction', 'cmember', 'cmacro', 'ctype', 'cvar'): name = parse_c_signature(signode, sig, desctype) elif desctype == 'cmdoption': optname = parse_option_desc(signode, sig) if not noindex: targetname = optname.replace('/', '-') if env.currprogram: targetname = '-' + env.currprogram + targetname targetname = 'cmdoption' + targetname signode['ids'].append(targetname) state.document.note_explicit_target(signode) inode['entries'].append( ('pair', _('%scommand line option; %s') % ((env.currprogram and env.currprogram + ' ' or ''), sig), targetname, targetname)) env.note_progoption(optname, targetname) continue elif desctype == 'describe': signode.clear() signode += addnodes.desc_name(sig, sig) continue else: # another registered generic x-ref directive rolename, indextemplate, parse_node = additional_xref_types[desctype] if parse_node: fullname = parse_node(env, sig, signode) else: signode.clear() signode += addnodes.desc_name(sig, sig) # normalize whitespace like xfileref_role does fullname = ws_re.sub('', sig) if not noindex: targetname = '%s-%s' % (rolename, fullname) signode['ids'].append(targetname) state.document.note_explicit_target(signode) if indextemplate: indexentry = _(indextemplate) % (fullname,) indextype = 'single' colon = indexentry.find(':') if colon != -1: indextype = indexentry[:colon].strip() indexentry = indexentry[colon+1:].strip() inode['entries'].append((indextype, indexentry, targetname, targetname)) env.note_reftarget(rolename, fullname, targetname) # don't use object indexing below continue except ValueError, err: # signature parsing failed signode.clear() signode += addnodes.desc_name(sig, sig) continue # we don't want an index entry here # only add target and index entry if this is the first description of the # function name in this desc block if not noindex and name not in names: fullname = (module and module + '.' or '') + name # note target if fullname not in state.document.ids: signode['names'].append(fullname) signode['ids'].append(fullname) signode['first'] = (not names) state.document.note_explicit_target(signode) env.note_descref(fullname, desctype, lineno) names.append(name) indextext = desc_index_text(desctype, module, name, env.config.add_module_names) inode['entries'].append(('single', indextext, fullname, fullname))