'alignas', 'alignof', 'and', 'and_eq', 'asm', 'auto', 'bitand', 'bitor',

'bool', 'break', 'case', 'catch', 'char', 'char16_t', 'char32_t', 'class',

'compl', 'concept', 'const', 'constexpr', 'const_cast', 'continue',

'decltype', 'default', 'delete', 'do', 'double', 'dynamic_cast', 'else',

'enum', 'explicit', 'export', 'extern', 'false', 'float', 'for', 'friend',

'goto', 'if', 'inline', 'int', 'long', 'mutable', 'namespace', 'new',

'noexcept', 'not', 'not_eq', 'nullptr', 'operator', 'or', 'or_eq',

'private', 'protected', 'public', 'register', 'reinterpret_cast',

'requires', 'return', 'short', 'signed', 'sizeof', 'static',

'static_assert', 'static_cast', 'struct', 'switch', 'template', 'this',

'thread_local', 'throw', 'true', 'try', 'typedef', 'typeid', 'typename',

'union', 'unsigned', 'using', 'virtual', 'void', 'volatile', 'wchar_t',

'while', 'xor', 'xor_eq'

'char': 'c',

'signed char': 'c',

'unsigned char': 'C',

'int': 'i',

'signed int': 'i',

'unsigned int': 'U',

'long': 'l',

'signed long': 'l',

'unsigned long': 'L',

'bool': 'b'

'std::string': 'ss',

'std::ostream': 'os',

'std::istream': 'is',

'std::iostream': 'ios',

'std::vector': 'v',

'std::map': 'm'

'new': 'new-operator',

'new[]': 'new-array-operator',

'delete': 'delete-operator',

'delete[]': 'delete-array-operator',

# the arguments will make the difference between unary and binary

# '+(unary)' : 'ps',

# '-(unary)' : 'ng',

# '&(unary)' : 'ad',

# '*(unary)' : 'de',

'~': 'inv-operator',

'+': 'add-operator',

'-': 'sub-operator',

'*': 'mul-operator',

'/': 'div-operator',

'%': 'mod-operator',

'&': 'and-operator',

'|': 'or-operator',

'^': 'xor-operator',

'=': 'assign-operator',

'+=': 'add-assign-operator',

'-=': 'sub-assign-operator',

'*=': 'mul-assign-operator',

'/=': 'div-assign-operator',

'%=': 'mod-assign-operator',

'&=': 'and-assign-operator',

'|=': 'or-assign-operator',

'^=': 'xor-assign-operator',

'<<': 'lshift-operator',

'>>': 'rshift-operator',

'<<=': 'lshift-assign-operator',

'>>=': 'rshift-assign-operator',

'==': 'eq-operator',

'!=': 'neq-operator',

'<': 'lt-operator',

'>': 'gt-operator',

'<=': 'lte-operator',

'>=': 'gte-operator',

'!': 'not-operator',

'&&': 'sand-operator',

'||': 'sor-operator',

'++': 'inc-operator',

'--': 'dec-operator',

',': 'comma-operator',

'->*': 'pointer-by-pointer-operator',

'->': 'pointer-operator',

'()': 'call-operator',

'[]': 'subscript-operator'

# not all of these are actually parsed as fundamental types, TODO: do that

'void': 'v',

'bool': 'b',

'char': 'c',

'signed char': 'a',

'unsigned char': 'h',

'wchar_t': 'w',

'char32_t': 'Di',

'char16_t': 'Ds',

'short': 's',

'short int': 's',

'signed short': 's',

'signed short int': 's',

'unsigned short': 't',

'unsigned short int': 't',

'int': 'i',

'signed': 'i',

'signed int': 'i',

'unsigned': 'j',

'unsigned int': 'j',

'long': 'l',

'long int': 'l',

'signed long': 'l',

'signed long int': 'l',

'unsigned long': 'm',

'unsigned long int': 'm',

'long long': 'x',

'long long int': 'x',

'signed long long': 'x',

'signed long long int': 'x',

'unsigned long long': 'y',

'unsigned long long int': 'y',

'float': 'f',

'double': 'd',

'long double': 'e',

'auto': 'Da',

'decltype(auto)': 'Dc',

'std::nullptr_t': 'Dn'

'new': 'nw',

'new[]': 'na',

'delete': 'dl',

'delete[]': 'da',

# the arguments will make the difference between unary and binary

# in operator definitions

# '+(unary)' : 'ps',

# '-(unary)' : 'ng',

# '&(unary)' : 'ad',

# '*(unary)' : 'de',

'~': 'co', 'compl': 'co',

'+': 'pl',

'-': 'mi',

'*': 'ml',

'/': 'dv',

'%': 'rm',

'&': 'an', 'bitand': 'an',

'|': 'or', 'bitor': 'or',

'^': 'eo', 'xor': 'eo',

'=': 'aS',

'+=': 'pL',

'-=': 'mI',

'*=': 'mL',

'/=': 'dV',

'%=': 'rM',

'&=': 'aN', 'and_eq': 'aN',

'|=': 'oR', 'or_eq': 'oR',

'^=': 'eO', 'xor_eq': 'eO',

'<<': 'ls',

'>>': 'rs',

'<<=': 'lS',

'>>=': 'rS',

'==': 'eq',

'!=': 'ne', 'not_eq': 'ne',

'<': 'lt',

'>': 'gt',

'<=': 'le',

'>=': 'ge',

'!': 'nt', 'not': 'nt',

'&&': 'aa', 'and': 'aa',

'||': 'oo', 'or': 'oo',

'++': 'pp',

'--': 'mm',

',': 'cm',

'->*': 'pm',

'->': 'pt',

'()': 'cl',

'[]': 'ix',

'.*': 'ds' # this one is not overloadable, but we need it for expressions

'++': 'pp_',

'--': 'mm_',

'*': 'de',

'&': 'ad',

'+': 'ps',

'-': 'ng',

'!': 'nt', 'not': 'nt',

'~': 'co', 'compl': 'co'

['||', 'or'],

['&&', 'and'],

['|', 'bitor'],

['^', 'xor'],

['&', 'bitand'],

['==', '!=', 'not_eq'],

['<=', '>=', '<', '>'],

['<<', '>>'],

['+', '-'],

['*', '/', '%'],

['.*', '->*']

'dynamic_cast': 'dc',

'static_cast': 'sc',

'const_cast': 'cc',

'reinterpret_cast': 'rc'

def __init__(self, symbol: "Symbol", declaration: "ASTDeclaration") -> None:

assert symbol

assert declaration

self.symbol = symbol

self.declaration = declaration

def __str__(self) -> str:

def __init__(self, identifier: str) -> None:

assert identifier is not None

assert len(identifier) != 0

self.identifier = identifier

def is_anon(self) -> bool:

return self.identifier[0] == '@'

def get_id(self, version: int) -> str:

if self.is_anon() and version < 3:

raise NoOldIdError()

if version == 1:

if self.identifier == 'size_t':

return 's'

else:

return self.identifier

if self.identifier == "std":

return 'St'

elif self.identifier[0] == "~":

# a destructor, just use an arbitrary version of dtors

return 'D0'

else:

if self.is_anon():

return 'Ut%d_%s' % (len(self.identifier) - 1, self.identifier[1:])

else:

return str(len(self.identifier)) + self.identifier

# and this is where we finally make a difference between __str__ and the display string

def __str__(self) -> str:

return self.identifier

def get_display_string(self) -> str:

return "[anonymous]" if self.is_anon() else self.identifier

def describe_signature(self, signode: TextElement, mode: str, env: "BuildEnvironment",

prefix: str, templateArgs: str, symbol: "Symbol") -> None:

verify_description_mode(mode)

if mode == 'markType':

targetText = prefix + self.identifier + templateArgs

pnode = addnodes.pending_xref('', refdomain='cpp',

reftype='identifier',

reftarget=targetText, modname=None,

classname=None)

key = symbol.get_lookup_key()

pnode['cpp:parent_key'] = key

if self.is_anon():

pnode += nodes.strong(text="[anonymous]")

else:

pnode += nodes.Text(self.identifier)

signode += pnode

elif mode == 'lastIsName':

if self.is_anon():

signode += nodes.strong(text="[anonymous]")

else:

signode += addnodes.desc_name(self.identifier, self.identifier)

elif mode == 'noneIsName':

if self.is_anon():

signode += nodes.strong(text="[anonymous]")

else:

signode += nodes.Text(self.identifier)

else:

def __init__(self, identOrOp: Union[ASTIdentifier, "ASTOperator"],

templateArgs: "ASTTemplateArgs") -> None:

self.identOrOp = identOrOp

self.templateArgs = templateArgs

def is_operator(self) -> bool:

return False

def get_id(self, version: int) -> str:

res = self.identOrOp.get_id(version)

if self.templateArgs:

res += self.templateArgs.get_id(version)

return res

def _stringify(self, transform: StringifyTransform) -> str:

res = transform(self.identOrOp)

if self.templateArgs:

res += transform(self.templateArgs)

return res

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", prefix: str, symbol: "Symbol") -> None:

tArgs = str(self.templateArgs) if self.templateArgs is not None else ''

self.identOrOp.describe_signature(signode, mode, env, prefix, tArgs, symbol)

if self.templateArgs is not None:

def __init__(self, names: List[ASTNestedNameElement],

templates: List[bool], rooted: bool) -> None:

assert len(names) > 0

self.names = names

self.templates = templates

assert len(self.names) == len(self.templates)

self.rooted = rooted

@property

def name(self) -> "ASTNestedName":

return self

def num_templates(self) -> int:

count = 0

for n in self.names:

if n.is_operator():

continue

if n.templateArgs:

count += 1

return count

def get_id(self, version: int, modifiers: str = '') -> str:

if version == 1:

tt = str(self)

if tt in _id_shorthands_v1:

return _id_shorthands_v1[tt]

else:

return '::'.join(n.get_id(version) for n in self.names)

res = []

if len(self.names) > 1 or len(modifiers) > 0:

res.append('N')

res.append(modifiers)

for n in self.names:

res.append(n.get_id(version))

if len(self.names) > 1 or len(modifiers) > 0:

res.append('E')

return ''.join(res)

def _stringify(self, transform: StringifyTransform) -> str:

res = []

if self.rooted:

res.append('')

for i in range(len(self.names)):

n = self.names[i]

t = self.templates[i]

if t:

res.append("template " + transform(n))

else:

res.append(transform(n))

return '::'.join(res)

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

verify_description_mode(mode)

# just print the name part, with template args, not template params

if mode == 'noneIsName':

signode += nodes.Text(str(self))

elif mode == 'param':

name = str(self)

signode += nodes.emphasis(name, name)

elif mode == 'markType' or mode == 'lastIsName' or mode == 'markName':

# Each element should be a pending xref targeting the complete

# prefix. however, only the identifier part should be a link, such

# that template args can be a link as well.

# For 'lastIsName' we should also prepend template parameter lists.

templateParams = [] # type: List[Any]

if mode == 'lastIsName':

assert symbol is not None

if symbol.declaration.templatePrefix is not None:

templateParams = symbol.declaration.templatePrefix.templates

iTemplateParams = 0

templateParamsPrefix = ''

prefix = ''

first = True

names = self.names[:-1] if mode == 'lastIsName' else self.names

# If lastIsName, then wrap all of the prefix in a desc_addname,

# else append directly to signode.

# NOTE: Breathe relies on the prefix being in the desc_addname node,

# so it can remove it in inner declarations.

dest = signode

if mode == 'lastIsName':

dest = addnodes.desc_addname()

for i in range(len(names)):

nne = names[i]

template = self.templates[i]

if not first:

dest += nodes.Text('::')

prefix += '::'

if template:

dest += nodes.Text("template ")

first = False

txt_nne = str(nne)

if txt_nne != '':

if nne.templateArgs and iTemplateParams < len(templateParams):

templateParamsPrefix += str(templateParams[iTemplateParams])

iTemplateParams += 1

nne.describe_signature(dest, 'markType',

env, templateParamsPrefix + prefix, symbol)

prefix += txt_nne

if mode == 'lastIsName':

if len(self.names) > 1:

dest += addnodes.desc_addname('::', '::')

signode += dest

if self.templates[-1]:

signode += nodes.Text("template ")

self.names[-1].describe_signature(signode, mode, env, '', symbol)

else:

def get_id(self, version: int) -> str:

raise NotImplementedError(repr(self))

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

def _stringify(self, transform: StringifyTransform) -> str:

return 'nullptr'

def get_id(self, version: int) -> str:

return 'LDnE'

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

def __init__(self, value: bool) -> None:

self.value = value

def _stringify(self, transform: StringifyTransform) -> str:

if self.value:

return 'true'

else:

return 'false'

def get_id(self, version: int) -> str:

if self.value:

return 'L1E'

else:

return 'L0E'

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

def __init__(self, data: str) -> None:

self.data = data

def _stringify(self, transform: StringifyTransform) -> str:

return self.data

def get_id(self, version: int) -> str:

return "L%sE" % self.data

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

txt = str(self)

def __init__(self, data: str) -> None:

self.data = data

def _stringify(self, transform: StringifyTransform) -> str:

return self.data

def get_id(self, version: int) -> str:

# note: the length is not really correct with escaping

return "LA%d_KcE" % (len(self.data) - 2)

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

txt = str(self)

def __init__(self, prefix: str, data: str) -> None:

self.prefix = prefix # may be None when no prefix

self.data = data

assert prefix in _id_char_from_prefix

self.type = _id_char_from_prefix[prefix]

decoded = data.encode().decode('unicode-escape')

if len(decoded) == 1:

self.value = ord(decoded)

else:

raise UnsupportedMultiCharacterCharLiteral(decoded)

def _stringify(self, transform: StringifyTransform) -> str:

if self.prefix is None:

return "'" + self.data + "'"

else:

return self.prefix + "'" + self.data + "'"

def get_id(self, version: int) -> str:

return self.type + str(self.value)

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

txt = str(self)

def _stringify(self, transform: StringifyTransform) -> str:

return "this"

def get_id(self, version: int) -> str:

return "fpT"

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

def __init__(self, leftExpr: ASTExpression,

op: str, rightExpr: ASTExpression) -> None:

assert leftExpr is not None or rightExpr is not None

self.leftExpr = leftExpr

self.op = op

self.rightExpr = rightExpr

def _stringify(self, transform: StringifyTransform) -> str:

res = ['(']

if self.leftExpr:

res.append(transform(self.leftExpr))

res.append(' ')

res.append(transform(self.op))

res.append(' ')

res.append('...')

if self.rightExpr:

res.append(' ')

res.append(transform(self.op))

res.append(' ')

res.append(transform(self.rightExpr))

res.append(')')

return ''.join(res)

def get_id(self, version: int) -> str:

assert version >= 3

if version == 3:

return str(self)

# https://github.com/itanium-cxx-abi/cxx-abi/pull/67

res = []

if self.leftExpr is None: # (... op expr)

res.append('fl')

elif self.rightExpr is None: # (expr op ...)

res.append('fr')

else: # (expr op ... op expr)

# we don't check where the parameter pack is,

# we just always call this a binary left fold

res.append('fL')

res.append(_id_operator_v2[self.op])

if self.leftExpr:

res.append(self.leftExpr.get_id(version))

if self.rightExpr:

res.append(self.rightExpr.get_id(version))

return ''.join(res)

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

signode.append(nodes.Text('('))

if self.leftExpr:

self.leftExpr.describe_signature(signode, mode, env, symbol)

signode.append(nodes.Text(' '))

signode.append(nodes.Text(self.op))

signode.append(nodes.Text(' '))

signode.append(nodes.Text('...'))

if self.rightExpr:

signode.append(nodes.Text(' '))

signode.append(nodes.Text(self.op))

signode.append(nodes.Text(' '))

self.rightExpr.describe_signature(signode, mode, env, symbol)

def __init__(self, expr: ASTExpression):

self.expr = expr

def _stringify(self, transform: StringifyTransform) -> str:

return '(' + transform(self.expr) + ')'

def get_id(self, version: int) -> str:

return self.expr.get_id(version)

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

signode.append(nodes.Text('(', '('))

self.expr.describe_signature(signode, mode, env, symbol)

def __init__(self, name: ASTNestedName):

# note: this class is basically to cast a nested name as an expression

self.name = name

def _stringify(self, transform: StringifyTransform) -> str:

return transform(self.name)

def get_id(self, version: int) -> str:

return self.name.get_id(version)

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None:

def get_id(self, idPrefix: str, version: int) -> str:

raise NotImplementedError(repr(self))

def describe_signature(self, signode: TextElement, mode: str,

env: "BuildEnvironment", symbol: "Symbol") -> None: