From 455ebde09dc55d91088d15a89fab0f2dfd1d3b51 Mon Sep 17 00:00:00 2001 From: DasIch Date: Fri, 30 Apr 2010 12:32:42 +0200 Subject: Make sphinx.domains.cpp.DefExpr unhashable --- sphinx/domains/cpp.py | 2 ++ 1 file changed, 2 insertions(+) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 4dac8925..90c3533e 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -132,6 +132,8 @@ class DefExpr(object): def __ne__(self, other): return not self.__eq__(other) + __hash__ = None + def clone(self): """Close a definition expression node""" return deepcopy(self) -- cgit v1.2.1 From d56bf3e26d8707a4e5a9174609c203ec34417cd1 Mon Sep 17 00:00:00 2001 From: DasIch Date: Sun, 9 May 2010 00:54:14 +0200 Subject: Fixed DefExpr.__str__ --- sphinx/domains/cpp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 90c3533e..8df89459 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -110,7 +110,7 @@ class DefinitionError(Exception): return self.description def __str__(self): - return unicode(self.encode('utf-8')) + return unicode(self).encode('utf-8') class DefExpr(object): -- cgit v1.2.1 From 5978c17aed477cc2bbab7eae86bb8b18367c426e Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Sun, 22 Aug 2010 11:36:08 +0200 Subject: Docstring harmonization. --- sphinx/domains/cpp.py | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 8df89459..a59b2b50 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -135,29 +135,31 @@ class DefExpr(object): __hash__ = None def clone(self): - """Close a definition expression node""" + """Clone a definition expression node.""" return deepcopy(self) def get_id(self): - """Returns the id for the node""" + """Return the id for the node.""" return u'' def get_name(self): - """Returns the name. Returns either `None` or a node with - a name you might call :meth:`split_owner` on. + """Return the name. + + Returns either `None` or a node with a name you might call + :meth:`split_owner` on. """ return None def split_owner(self): - """Nodes returned by :meth:`get_name` can split off their - owning parent. This function returns the owner and the - name as a tuple of two items. If a node does not support - it, :exc:`NotImplementedError` is raised. + """Nodes returned by :meth:`get_name` can split off their owning parent. + + This function returns the owner and the name as a tuple of two items. + If a node does not support it, :exc:`NotImplementedError` is raised. """ raise NotImplementedError() def prefix(self, prefix): - """Prefixes a name node (a node returned by :meth:`get_name`).""" + """Prefix a name node (a node returned by :meth:`get_name`).""" raise NotImplementedError() def __str__(self): @@ -984,8 +986,9 @@ class CPPFunctionObject(CPPObject): class CPPCurrentNamespace(Directive): - """This directive is just to tell Sphinx that we're documenting - stuff in namespace foo. + """ + This directive is just to tell Sphinx that we're documenting stuff in + namespace foo. """ has_content = False -- cgit v1.2.1 From 3411097bf8a2ba377e763c9d31e46fc74f7914c3 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Fri, 7 Jan 2011 15:49:01 +0100 Subject: C++ domain now supports array definitions. --- sphinx/domains/cpp.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index e712e01e..4688691d 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -28,6 +28,7 @@ _whitespace_re = re.compile(r'\s+(?u)') _string_re = re.compile(r"[LuU8]?('([^'\\]*(?:\\.[^'\\]*)*)'" r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S) _visibility_re = re.compile(r'\b(public|private|protected)\b') +_array_def_re = re.compile(r'\[\s*(.+?)?\s*\]') _operator_re = re.compile(r'''(?x) \[\s*\] | \(\s*\) @@ -273,6 +274,22 @@ class PtrDefExpr(WrappingDefExpr): return u'%s*' % self.typename +class ArrayDefExpr(WrappingDefExpr): + + def __init__(self, typename, size_hint=None): + WrappingDefExpr.__init__(self, typename) + self.size_hint = size_hint + + def get_id(self): + return self.typename.get_id() + u'A' + + def __unicode__(self): + return u'%s[%s]' % ( + self.typename, + self.size_hint is not None and unicode(self.size_hint) or u'' + ) + + class RefDefExpr(WrappingDefExpr): def get_id(self): @@ -562,6 +579,8 @@ class DefinitionParser(object): expr = ConstDefExpr(expr) elif self.skip_string('*'): expr = PtrDefExpr(expr) + elif self.match(_array_def_re): + expr = ArrayDefExpr(expr, self.last_match.group(1)) elif self.skip_string('&'): expr = RefDefExpr(expr) else: -- cgit v1.2.1 From 554c7dd64f6aca38be6e1d26bb2cf4388f46083d Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Fri, 7 Jan 2011 19:00:29 +0100 Subject: #454: Add more index markup capabilities: marking see/seealso entries, and main entries for a given key. --- sphinx/domains/cpp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 4688691d..4e40dde7 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -852,7 +852,7 @@ class CPPObject(ObjectDescription): indextext = self.get_index_text(name) if indextext: - self.indexnode['entries'].append(('single', indextext, name, name)) + self.indexnode['entries'].append(('single', indextext, theid, '')) def before_content(self): lastname = self.names and self.names[-1] -- cgit v1.2.1 From 0e589964899503542455e46f063c2aa23043e838 Mon Sep 17 00:00:00 2001 From: Chris Pickel Date: Tue, 19 Apr 2011 22:22:33 -0400 Subject: Support varargs in C++ function signatures. --- sphinx/domains/cpp.py | 7 +++++++ 1 file changed, 7 insertions(+) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 5465c91f..2a411740 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -712,6 +712,13 @@ class DefinitionParser(object): self.fail('expected comma between arguments') self.skip_ws() + if self.skip_string('...'): + args.append(ArgumentDefExpr(None, '...', None)) + if self.skip_string(')'): + break + else: + self.fail('expected closing parenthesis after ellipses') + argtype = self._parse_type() argname = default = None self.skip_ws() -- cgit v1.2.1 From 50876de9a9d375635cb6cbfbba969425ec037b94 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Thu, 22 Sep 2011 10:23:46 +0200 Subject: Added support for non-name template arguments. This fixes #696 --- sphinx/domains/cpp.py | 28 ++++++++++++++++++++++++---- 1 file changed, 24 insertions(+), 4 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 2a411740..99622977 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -29,6 +29,7 @@ _string_re = re.compile(r"[LuU8]?('([^'\\]*(?:\\.[^'\\]*)*)'" r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S) _visibility_re = re.compile(r'\b(public|private|protected)\b') _array_def_re = re.compile(r'\[\s*(.+?)?\s*\]') +_template_arg_re = re.compile(r'[^,>]+') _operator_re = re.compile(r'''(?x) \[\s*\] | \(\s*\) @@ -240,6 +241,18 @@ class TemplateDefExpr(PrimaryDefExpr): return u'%s<%s>' % (self.typename, u', '.join(map(unicode, self.args))) +class ConstantTemplateArgExpr(PrimaryDefExpr): + + def __init__(self, arg): + self.arg = arg + + def get_id(self): + return self.arg.replace(u' ', u'-') + + def __unicode__(self): + return unicode(self.arg) + + class WrappingDefExpr(DefExpr): def __init__(self, typename): @@ -544,8 +557,15 @@ class DefinitionParser(object): return CastOpDefExpr(type) def _parse_name(self): + return self._parse_name_or_template_arg(False) + + def _parse_name_or_template_arg(self, in_template): if not self.match(_identifier_re): - self.fail('expected name') + if not in_template: + self.fail('expected name') + if not self.match(_template_arg_re): + self.fail('expected name or constant template argument') + return ConstantTemplateArgExpr(self.matched_text.strip()) identifier = self.matched_text # strictly speaking, operators are not regular identifiers @@ -614,8 +634,8 @@ class DefinitionParser(object): rv = ModifierDefExpr(NameDefExpr(typename), modifiers) return self._attach_crefptr(rv, is_const) - def _parse_type_expr(self): - typename = self._parse_name() + def _parse_type_expr(self, in_template=False): + typename = self._parse_name_or_template_arg(in_template) self.skip_ws() if not self.skip_string('<'): return typename @@ -664,7 +684,7 @@ class DefinitionParser(object): (result and not self.skip_string('::')) or \ self.eof: break - result.append(self._parse_type_expr()) + result.append(self._parse_type_expr(in_template)) if not result: self.fail('expected type') -- cgit v1.2.1 From 9ac257a624084f6ec2e88d08440bfa10ccab4e15 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Thu, 22 Sep 2011 10:33:15 +0200 Subject: Be explicit about rvalue references. --- sphinx/domains/cpp.py | 16 ++++++++++++++-- 1 file changed, 14 insertions(+), 2 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 99622977..77ec032d 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -303,7 +303,7 @@ class ArrayDefExpr(WrappingDefExpr): ) -class RefDefExpr(WrappingDefExpr): +class LValRefDefExpr(WrappingDefExpr): def get_id(self): return self.typename.get_id() + u'R' @@ -312,6 +312,15 @@ class RefDefExpr(WrappingDefExpr): return u'%s&' % self.typename +class RValRefDefExpr(WrappingDefExpr): + + def get_id(self): + return self.typename.get_id() + u'RR' + + def __unicode__(self): + return u'%s&&' % self.typename + + class ConstDefExpr(WrappingDefExpr): def __init__(self, typename, prefix=False): @@ -602,7 +611,10 @@ class DefinitionParser(object): elif self.match(_array_def_re): expr = ArrayDefExpr(expr, self.last_match.group(1)) elif self.skip_string('&'): - expr = RefDefExpr(expr) + if self.skip_string('&'): + expr = RValRefDefExpr(expr) + else: + expr = LValRefDefExpr(expr) else: return expr -- cgit v1.2.1 From 7cabc9f2a989a78753f9ddcbfd941dd3fc45e106 Mon Sep 17 00:00:00 2001 From: Georg Brandl Date: Thu, 22 Sep 2011 10:37:55 +0200 Subject: Closes #680: allow doc fields in cpp domain directives. --- sphinx/domains/cpp.py | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 99622977..df90e451 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -21,6 +21,7 @@ from sphinx.domains import Domain, ObjType from sphinx.directives import ObjectDescription from sphinx.util.nodes import make_refnode from sphinx.util.compat import Directive +from sphinx.util.docfields import Field, GroupedField _identifier_re = re.compile(r'(~?\b[a-zA-Z_][a-zA-Z0-9_]*)\b') @@ -838,6 +839,17 @@ class DefinitionParser(object): class CPPObject(ObjectDescription): """Description of a C++ language object.""" + doc_field_types = [ + GroupedField('parameter', label=l_('Parameters'), + names=('param', 'parameter', 'arg', 'argument'), + can_collapse=True), + GroupedField('exceptions', label=l_('Throws'), rolename='cpp:class', + names=('throws', 'throw', 'exception'), + can_collapse=True), + Field('returnvalue', label=l_('Returns'), has_arg=False, + names=('returns', 'return')), + ] + def attach_name(self, node, name): owner, name = name.split_owner() varname = unicode(name) @@ -1128,7 +1140,7 @@ class CPPDomain(Domain): node.line) return None - parent = node['cpp:parent'] + parent = node.get('cpp:parent', None) rv = _create_refnode(expr) if rv is not None or parent is None: -- cgit v1.2.1 From 7e65f51ebc103ca51e407fb8360d5b58a8171bd4 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Thu, 22 Sep 2011 10:43:24 +0200 Subject: Added support for constexpr in function signatures --- sphinx/domains/cpp.py | 25 ++++++++++++++++--------- 1 file changed, 16 insertions(+), 9 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 77ec032d..f99c3ffc 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -425,27 +425,31 @@ class MemberObjDefExpr(NamedDefExpr): class FuncDefExpr(NamedDefExpr): - def __init__(self, name, visibility, static, explicit, rv, + def __init__(self, name, visibility, static, explicit, constexpr, rv, signature, const, pure_virtual): NamedDefExpr.__init__(self, name, visibility, static) self.rv = rv self.signature = signature self.explicit = explicit + self.constexpr = constexpr self.const = const self.pure_virtual = pure_virtual def get_id(self): - return u'%s%s%s' % ( + return u'%s%s%s%s' % ( self.name.get_id(), self.signature and u'__' + u'.'.join(x.get_id() for x in self.signature) or u'', - self.const and u'C' or u'' + self.const and u'C' or u'', + self.constexpr and 'CE' or '' ) def __unicode__(self): buf = self.get_modifiers() if self.explicit: buf.append(u'explicit') + if self.constexpr: + buf.append(u'constexpr') if self.rv is not None: buf.append(unicode(self.rv)) buf.append(u'%s(%s)' % (self.name, u', '.join( @@ -815,11 +819,14 @@ class DefinitionParser(object): def parse_function(self): visibility, static = self._parse_visibility_static() - if self.skip_word('explicit'): - explicit = True - self.skip_ws() - else: - explicit = False + def _read_word(x): + if self.skip_word(x): + self.skip_ws() + return True + return False + explicit = _read_word('explicit') + constexpr = _read_word('constexpr') + rv = self._parse_type() self.skip_ws() # some things just don't have return values @@ -828,7 +835,7 @@ class DefinitionParser(object): rv = None else: name = self._parse_type() - return FuncDefExpr(name, visibility, static, explicit, rv, + return FuncDefExpr(name, visibility, static, explicit, constexpr, rv, *self._parse_signature()) def parse_class(self): -- cgit v1.2.1 From e3c56cb286cbfb52e6d6186ddefde3776a3e2589 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Thu, 22 Sep 2011 10:54:16 +0200 Subject: Small refactoring for how modifiers are parsed in the C++ domain. --- sphinx/domains/cpp.py | 21 ++++++++++----------- 1 file changed, 10 insertions(+), 11 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index f99c3ffc..9ec70f53 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -529,6 +529,12 @@ class DefinitionParser(object): def skip_ws(self): return self.match(_whitespace_re) + def skip_word_and_ws(self, word): + if self.skip_word(word): + self.skip_ws() + return True + return False + @property def eof(self): return self.pos >= self.end @@ -769,9 +775,7 @@ class DefinitionParser(object): args.append(ArgumentDefExpr(argtype, argname, default)) self.skip_ws() - const = self.skip_word('const') - if const: - self.skip_ws() + const = self.skip_word_and_ws('const') if self.skip_string('='): self.skip_ws() if not (self.skip_string('0') or \ @@ -786,7 +790,7 @@ class DefinitionParser(object): return args, const, pure_virtual def _parse_visibility_static(self): - visibility = 'public' + visibility = 'public' if self.match(_visibility_re): visibility = self.matched_text static = self.skip_word('static') @@ -819,13 +823,8 @@ class DefinitionParser(object): def parse_function(self): visibility, static = self._parse_visibility_static() - def _read_word(x): - if self.skip_word(x): - self.skip_ws() - return True - return False - explicit = _read_word('explicit') - constexpr = _read_word('constexpr') + explicit = self.skip_word_and_ws('explicit') + constexpr = self.skip_word_and_ws('constexpr') rv = self._parse_type() self.skip_ws() -- cgit v1.2.1 From e18d423f0adac717d8e6a8d6ed9fad5bca7f0933 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Thu, 22 Sep 2011 11:15:46 +0200 Subject: Added support for noexcept specifiers --- sphinx/domains/cpp.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index 9ec70f53..ecae79f6 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -426,13 +426,14 @@ class MemberObjDefExpr(NamedDefExpr): class FuncDefExpr(NamedDefExpr): def __init__(self, name, visibility, static, explicit, constexpr, rv, - signature, const, pure_virtual): + signature, const, noexcept, pure_virtual): NamedDefExpr.__init__(self, name, visibility, static) self.rv = rv self.signature = signature self.explicit = explicit self.constexpr = constexpr self.const = const + self.noexcept = noexcept self.pure_virtual = pure_virtual def get_id(self): @@ -456,6 +457,8 @@ class FuncDefExpr(NamedDefExpr): map(unicode, self.signature)))) if self.const: buf.append(u'const') + if self.noexcept: + buf.append(u'noexcept') if self.pure_virtual: buf.append(u'= 0') return u' '.join(buf) @@ -776,6 +779,7 @@ class DefinitionParser(object): args.append(ArgumentDefExpr(argtype, argname, default)) self.skip_ws() const = self.skip_word_and_ws('const') + noexcept = self.skip_word_and_ws('noexcept') if self.skip_string('='): self.skip_ws() if not (self.skip_string('0') or \ @@ -787,7 +791,7 @@ class DefinitionParser(object): pure_virtual = True else: pure_virtual = False - return args, const, pure_virtual + return args, const, noexcept, pure_virtual def _parse_visibility_static(self): visibility = 'public' -- cgit v1.2.1 From 91e0bf99abb0ebe896ecc4e26951f857f87076ee Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Thu, 22 Sep 2011 11:17:18 +0200 Subject: Added support for strings with commas in template definitions. --- sphinx/domains/cpp.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index ecae79f6..d0c62bc7 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -29,7 +29,7 @@ _string_re = re.compile(r"[LuU8]?('([^'\\]*(?:\\.[^'\\]*)*)'" r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S) _visibility_re = re.compile(r'\b(public|private|protected)\b') _array_def_re = re.compile(r'\[\s*(.+?)?\s*\]') -_template_arg_re = re.compile(r'[^,>]+') +_template_arg_re = re.compile(r'(%s)|([^,>]+)' % _string_re.pattern, re.S) _operator_re = re.compile(r'''(?x) \[\s*\] | \(\s*\) -- cgit v1.2.1 From cb3a2ab539aa403af69c3650210fd1325f143291 Mon Sep 17 00:00:00 2001 From: Armin Ronacher Date: Fri, 23 Sep 2011 00:48:52 +0200 Subject: Attach arrays to the name not the type for C++ domain and fixed a few rendering errors. --- sphinx/domains/cpp.py | 126 ++++++++++++++++++++++++++++++++++---------------- 1 file changed, 86 insertions(+), 40 deletions(-) (limited to 'sphinx/domains/cpp.py') diff --git a/sphinx/domains/cpp.py b/sphinx/domains/cpp.py index d0c62bc7..b1f95291 100644 --- a/sphinx/domains/cpp.py +++ b/sphinx/domains/cpp.py @@ -28,7 +28,7 @@ _whitespace_re = re.compile(r'\s+(?u)') _string_re = re.compile(r"[LuU8]?('([^'\\]*(?:\\.[^'\\]*)*)'" r'|"([^"\\]*(?:\\.[^"\\]*)*)")', re.S) _visibility_re = re.compile(r'\b(public|private|protected)\b') -_array_def_re = re.compile(r'\[\s*(.+?)?\s*\]') +_array_def_re = re.compile(r'\[\s*([^\]]+?)?\s*\]') _template_arg_re = re.compile(r'(%s)|([^,>]+)' % _string_re.pattern, re.S) _operator_re = re.compile(r'''(?x) \[\s*\] @@ -223,6 +223,20 @@ class PathDefExpr(PrimaryDefExpr): return u'::'.join(map(unicode, self.path)) +class ArrayTypeSuffixDefExpr(object): + + def __init__(self, size_hint=None): + self.size_hint = size_hint + + def get_id_suffix(self): + return 'A' + + def __unicode__(self): + return u'[%s]' % ( + self.size_hint is not None and unicode(self.size_hint) or u'', + ) + + class TemplateDefExpr(PrimaryDefExpr): def __init__(self, typename, args): @@ -287,22 +301,6 @@ class PtrDefExpr(WrappingDefExpr): return u'%s*' % self.typename -class ArrayDefExpr(WrappingDefExpr): - - def __init__(self, typename, size_hint=None): - WrappingDefExpr.__init__(self, typename) - self.size_hint = size_hint - - def get_id(self): - return self.typename.get_id() + u'A' - - def __unicode__(self): - return u'%s[%s]' % ( - self.typename, - self.size_hint is not None and unicode(self.size_hint) or u'' - ) - - class LValRefDefExpr(WrappingDefExpr): def get_id(self): @@ -348,22 +346,29 @@ class CastOpDefExpr(PrimaryDefExpr): class ArgumentDefExpr(DefExpr): - def __init__(self, type, name, default=None): + def __init__(self, type, name, type_suffixes, default=None): self.name = name self.type = type + self.type_suffixes = type_suffixes self.default = default def get_name(self): return self.name.get_name() def get_id(self): - if self.type is None: - return 'X' - return self.type.get_id() + buf = [] + buf.append(self.type and self.type.get_id() or 'X') + for suffix in self.type_suffixes: + buf.append(suffix.get_id_suffix()) + return u''.join(buf) def __unicode__(self): - return (u'%s %s' % (self.type or u'', self.name or u'')).strip() + \ - (self.default is not None and u'=%s' % self.default or u'') + buf = [(u'%s %s' % (self.type or u'', self.name or u'')).strip()] + if self.default is not None: + buf.append('=%s' % self.default) + for suffix in self.type_suffixes: + buf.append(unicode(suffix)) + return u''.join(buf) class NamedDefExpr(DefExpr): @@ -387,14 +392,19 @@ class NamedDefExpr(DefExpr): class TypeObjDefExpr(NamedDefExpr): - def __init__(self, name, visibility, static, typename): + def __init__(self, name, visibility, static, typename, type_suffixes): NamedDefExpr.__init__(self, name, visibility, static) self.typename = typename + self.type_suffixes = type_suffixes def get_id(self): if self.typename is None: - return self.name.get_id() - return u'%s__%s' % (self.name.get_id(), self.typename.get_id()) + buf = [self.name.get_id()] + else: + buf = [u'%s__%s' % (self.name.get_id(), self.typename.get_id())] + for suffix in self.type_suffixes: + buf.append(suffix.get_id_suffix()) + return u''.join(buf) def __unicode__(self): buf = self.get_modifiers() @@ -402,25 +412,36 @@ class TypeObjDefExpr(NamedDefExpr): buf.append(unicode(self.name)) else: buf.extend(map(unicode, (self.typename, self.name))) - return u' '.join(buf) + buf = [u' '.join(buf)] + for suffix in self.type_suffixes: + buf.append(unicode(suffix)) + return u''.join(buf) class MemberObjDefExpr(NamedDefExpr): - def __init__(self, name, visibility, static, typename, value): + def __init__(self, name, visibility, static, typename, type_suffixes, + value): NamedDefExpr.__init__(self, name, visibility, static) self.typename = typename + self.type_suffixes = type_suffixes self.value = value def get_id(self): - return u'%s__%s' % (self.name.get_id(), self.typename.get_id()) + buf = [u'%s__%s' % (self.name.get_id(), self.typename.get_id())] + for suffix in self.type_suffixes: + buf.append(suffix.get_id_suffix()) + return u''.join(buf) def __unicode__(self): buf = self.get_modifiers() - buf.append(u'%s %s' % (self.typename, self.name)) + buf.extend((unicode(self.typename), unicode(self.name))) + buf = [u' '.join(buf)] + for suffix in self.type_suffixes: + buf.append(unicode(suffix)) if self.value is not None: - buf.append(u'= %s' % self.value) - return u' '.join(buf) + buf.append(u' = %s' % self.value) + return u''.join(buf) class FuncDefExpr(NamedDefExpr): @@ -621,8 +642,6 @@ class DefinitionParser(object): expr = ConstDefExpr(expr) elif self.skip_string('*'): expr = PtrDefExpr(expr) - elif self.match(_array_def_re): - expr = ArrayDefExpr(expr, self.last_match.group(1)) elif self.skip_string('&'): if self.skip_string('&'): expr = RValRefDefExpr(expr) @@ -631,6 +650,13 @@ class DefinitionParser(object): else: return expr + def _try_parse_type_suffixes(self): + rv = [] + while self.match(_array_def_re): + rv.append(ArrayTypeSuffixDefExpr(self.last_match.group(1))) + self.skip_ws() + return rv + def _peek_const(self, path): try: path.remove('const') @@ -758,25 +784,29 @@ class DefinitionParser(object): self.skip_ws() if self.skip_string('...'): - args.append(ArgumentDefExpr(None, '...', None)) + args.append(ArgumentDefExpr(None, '...', [], None)) if self.skip_string(')'): break else: self.fail('expected closing parenthesis after ellipses') - argtype = self._parse_type() argname = default = None + argtype = self._parse_type() self.skip_ws() + type_suffixes = self._try_parse_type_suffixes() if self.skip_string('='): - self.pos += 1 default = self._parse_default_expr() elif self.current_char not in ',)': argname = self._parse_name() self.skip_ws() + type_suffixes.extend(self._try_parse_type_suffixes()) if self.skip_string('='): default = self._parse_default_expr() + if argname is None: + argname = argtype + argtype = None - args.append(ArgumentDefExpr(argtype, argname, default)) + args.append(ArgumentDefExpr(argtype, argname, type_suffixes, default)) self.skip_ws() const = self.skip_word_and_ws('const') noexcept = self.skip_word_and_ws('noexcept') @@ -809,21 +839,25 @@ class DefinitionParser(object): self.skip_ws() if not self.eof: name = self._parse_type() + type_suffixes = self._try_parse_type_suffixes() else: name = typename typename = None - return TypeObjDefExpr(name, visibility, static, typename) + type_suffixes = [] + return TypeObjDefExpr(name, visibility, static, typename, type_suffixes) def parse_member_object(self): visibility, static = self._parse_visibility_static() typename = self._parse_type() name = self._parse_type() + type_suffixes = self._try_parse_type_suffixes() self.skip_ws() if self.skip_string('='): value = self.read_rest().strip() else: value = None - return MemberObjDefExpr(name, visibility, static, typename, value) + return MemberObjDefExpr(name, visibility, static, typename, + type_suffixes, value) def parse_function(self): visibility, static = self._parse_visibility_static() @@ -868,6 +902,10 @@ class CPPObject(ObjectDescription): node += addnodes.desc_addname(owner, owner) node += addnodes.desc_name(varname, varname) + def attach_type_suffixes(self, node, suffixes): + for suffix in suffixes: + node += nodes.Text(unicode(suffix)) + def attach_type(self, node, type): # XXX: link to c? text = unicode(type) @@ -886,6 +924,9 @@ class CPPObject(ObjectDescription): if obj.static: node += addnodes.desc_annotation('static', 'static') node += nodes.Text(' ') + if getattr(obj, 'constexpr', False): + node += addnodes.desc_annotation('constexpr', 'constexpr') + node += nodes.Text(' ') def add_target_and_index(self, sigobj, sig, signode): theid = sigobj.get_id() @@ -971,6 +1012,7 @@ class CPPTypeObject(CPPObject): self.attach_type(signode, obj.typename) signode += nodes.Text(' ') self.attach_name(signode, obj.name) + self.attach_type_suffixes(signode, obj.type_suffixes) class CPPMemberObject(CPPObject): @@ -988,6 +1030,7 @@ class CPPMemberObject(CPPObject): self.attach_type(signode, obj.typename) signode += nodes.Text(' ') self.attach_name(signode, obj.name) + self.attach_type_suffixes(signode, obj.type_suffixes) if obj.value is not None: signode += nodes.Text(u' = ' + obj.value) @@ -1017,6 +1060,7 @@ class CPPFunctionObject(CPPObject): self.attach_type(param, arg.type) param += nodes.Text(u' ') param += nodes.emphasis(unicode(arg.name), unicode(arg.name)) + self.attach_type_suffixes(param, arg.type_suffixes) if arg.default is not None: def_ = u'=' + unicode(arg.default) param += nodes.emphasis(def_, def_) @@ -1025,6 +1069,8 @@ class CPPFunctionObject(CPPObject): node += paramlist if func.const: node += addnodes.desc_addname(' const', ' const') + if func.noexcept: + node += addnodes.desc_addname(' noexcept', ' noexcept') if func.pure_virtual: node += addnodes.desc_addname(' = 0', ' = 0') -- cgit v1.2.1