# Copyright 2019 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
This module provides C++ language specific implementations of
code_node.CodeNode.
"""
from .code_node import CodeNode
from .code_node import CompositeNode
from .code_node import EmptyNode
from .code_node import Likeliness
from .code_node import ListNode
from .code_node import SymbolScopeNode
from .code_node import TextNode
from .code_node import WeakDependencyNode
from .codegen_expr import CodeGenExpr
from .codegen_format import format_template
class CxxBlockNode(CompositeNode):
def __init__(self, body):
template_format = (
"{{\n" #
" {body}\n"
"}}")
CompositeNode.__init__(
self,
template_format,
body=_to_symbol_scope_node(body, Likeliness.ALWAYS))
class CxxIfNode(CompositeNode):
def __init__(self, cond, attribute, body, likeliness):
attribute = attribute + ' ' if (attribute is not None) else ''
template_format = (
"if ({cond}) {attribute}{{\n" #
" {body}\n"
"}}")
CompositeNode.__init__(self,
template_format,
cond=_to_conditional_node(cond),
attribute=_to_maybe_text_node(attribute),
body=_to_symbol_scope_node(body, likeliness))
class CxxIfElseNode(CompositeNode):
def __init__(self, cond, attribute, then, then_likeliness, else_,
else_likeliness):
attribute = attribute + ' ' if (attribute is not None) else ''
template_format = ("if ({cond}) {attribute}{{\n"
" {then}\n"
"}} else {{\n"
" {else_}\n"
"}}")
CompositeNode.__init__(
self,
template_format,
cond=_to_conditional_node(cond),
attribute=_to_maybe_text_node(attribute),
then=_to_symbol_scope_node(then, then_likeliness),
else_=_to_symbol_scope_node(else_, else_likeliness))
class CxxLikelyIfNode(CxxIfNode):
def __init__(self, cond, attribute, body):
CxxIfNode.__init__(self, cond, attribute, body, Likeliness.LIKELY)
class CxxUnlikelyIfNode(CxxIfNode):
def __init__(self, cond, attribute, body):
CxxIfNode.__init__(self, cond, attribute, body, Likeliness.UNLIKELY)
class CxxMultiBranchesNode(CodeNode):
class _Clause(object):
def __init__(self, cond, body):
assert isinstance(cond, (CodeNode, bool))
assert isinstance(body, SymbolScopeNode)
self.cond = cond
self.body = body
def __init__(self):
clauses_gensym = CodeNode.gensym()
clauses = []
template_text = format_template(
"""\
% for {clause} in {clauses}:
% if not loop.first:
else \\
% endif
% if {clause}.cond is not False:
% if {clause}.cond is not True:
if (${{{clause}.cond}}) \\
% endif
{{
${{{clause}.body}}
}}\\
% if {clause}.cond is True:
<% break %>
% endif
% endif
% endfor\
""",
clause=CodeNode.gensym(),
clauses=clauses_gensym)
template_vars = {clauses_gensym: clauses}
CodeNode.__init__(
self, template_text=template_text, template_vars=template_vars)
self._clauses = clauses
def append(self, cond, body, likeliness=Likeliness.LIKELY):
if cond is None:
cond = False
elif isinstance(cond, CodeGenExpr):
if cond.is_always_true:
cond = True
elif cond.is_always_false:
cond = False
if not isinstance(cond, bool):
cond = _to_conditional_node(cond)
body = _to_symbol_scope_node(body, likeliness)
if isinstance(cond, CodeNode):
cond.set_outer(self)
body.set_outer(self)
self._clauses.append(self._Clause(cond, body))
class CxxSwitchNode(CodeNode):
class _Clause(object):
def __init__(self, case, body, should_add_break):
assert isinstance(case, CodeNode) or case is None
assert isinstance(body, SymbolScopeNode)
assert isinstance(should_add_break, bool)
self.case = case
self.body = body
self.should_add_break = should_add_break
def __init__(self, cond):
cond = _to_conditional_node(cond)
cond_gensym = CodeNode.gensym()
clauses_gensym = CodeNode.gensym()
clauses = []
default_clauses_gensym = CodeNode.gensym()
default_clauses = []
template_text = format_template(
"""\
switch (${{{cond}}}) {{
% for {clause} in {clauses}:
case ${{{clause}.case}}: {{
${{{clause}.body}}
% if {clause}.should_add_break:
break;
% endif
}}
% endfor
% for {clause} in {default_clauses}:
default: {{
${{{clause}.body}}
% if {clause}.should_add_break:
break;
% endif
}}
% endfor
}}\
""",
cond=cond_gensym,
clause=CodeNode.gensym(),
clauses=clauses_gensym,
default_clauses=default_clauses_gensym)
template_vars = {
cond_gensym: cond,
clauses_gensym: clauses,
default_clauses_gensym: default_clauses,
}
CodeNode.__init__(
self, template_text=template_text, template_vars=template_vars)
self._clauses = clauses
self._default_clauses = default_clauses
def append(self,
case,
body,
should_add_break=True,
likeliness=Likeliness.LIKELY):
"""
Args:
case: Constant expression of 'case' label, or None for 'default'
label.
body: The body statements.
should_add_break: True adds 'break' statement at the end of |body|.
likeliness: The likeliness of |body|.
"""
if case is not None:
case = _to_maybe_text_node(case)
case.set_outer(self)
body = _to_symbol_scope_node(body, likeliness)
body.set_outer(self)
if case is not None:
self._clauses.append(self._Clause(case, body, should_add_break))
else:
assert not self._default_clauses
self._default_clauses.append(
self._Clause(case, body, should_add_break))
class CxxForLoopNode(CompositeNode):
def __init__(self, cond, body, weak_dep_syms=None):
assert weak_dep_syms is None or isinstance(weak_dep_syms,
(list, tuple))
if weak_dep_syms is None:
weak_deps = EmptyNode()
else:
weak_deps = WeakDependencyNode(weak_dep_syms)
template_format = (
"{weak_deps}" #
"for ({cond}) {{\n"
" {body}\n"
"}}\n")
CompositeNode.__init__(self,
template_format,
weak_deps=weak_deps,
cond=_to_conditional_node(cond),
body=_to_symbol_scope_node(
body, Likeliness.LIKELY))
class CxxBreakableBlockNode(CompositeNode):
def __init__(self, body, likeliness=Likeliness.LIKELY):
template_format = ("do {{ // Dummy loop for use of 'break'.\n"
" {body}\n"
"}} while (false);")
CompositeNode.__init__(
self,
template_format,
body=_to_symbol_scope_node(body, likeliness))
class CxxFuncDeclNode(CompositeNode):
def __init__(self,
name,
arg_decls,
return_type,
template_params=None,
static=False,
explicit=False,
constexpr=False,
const=False,
override=False,
default=False,
delete=False,
nodiscard=False):
"""
Args:
name: Function name.
arg_decls: List of argument declarations.
return_type: Return type.
template_params: List of template parameters or None.
static: True makes this a static function.
explicit: True makes this an explicit constructor.
constexpr: True makes this a constexpr function.
const: True makes this a const function.
override: True makes this an overriding function.
default: True makes this have the default implementation.
delete: True makes this function be deleted.
nodiscard: True adds [[nodiscard]] attribute.
"""
assert isinstance(name, str)
assert isinstance(static, bool)
assert isinstance(explicit, bool)
assert isinstance(constexpr, bool)
assert isinstance(const, bool)
assert isinstance(override, bool)
assert isinstance(default, bool)
assert isinstance(delete, bool)
assert not (default and delete)
assert isinstance(nodiscard, bool)
template_format = ("{template}"
"{nodiscard_result}"
"{static}{explicit}{constexpr}"
"{return_type} "
"{name}({arg_decls})"
"{const}"
"{override}"
"{default_or_delete}"
";")
if template_params is None:
template = ""
else:
template = "template <{}>\n".format(", ".join(template_params))
static = "static " if static else ""
explicit = "explicit " if explicit else ""
constexpr = "constexpr " if constexpr else ""
const = " const" if const else ""
override = " override" if override else ""
if default:
default_or_delete = " = default"
elif delete:
default_or_delete = " = delete"
else:
default_or_delete = ""
nodiscard_result = ("[[nodiscard]] " if nodiscard else "")
CompositeNode.__init__(self,
template_format,
name=_to_maybe_text_node(name),
arg_decls=ListNode(map(_to_maybe_text_node,
arg_decls),
separator=", "),
return_type=_to_maybe_text_node(return_type),
template=template,
static=static,
explicit=explicit,
constexpr=constexpr,
const=const,
override=override,
default_or_delete=default_or_delete,
nodiscard_result=nodiscard_result)
class CxxFuncDefNode(CompositeNode):
def __init__(self,
name,
arg_decls,
return_type,
class_name=None,
template_params=None,
static=False,
inline=False,
explicit=False,
constexpr=False,
const=False,
override=False,
member_initializer_list=None):
"""
Args:
name: Function name.
arg_decls: List of argument declarations.
return_type: Return type.
class_name: Class name to be used as nested-name-specifier.
template_params: List of template parameters or None.
static: True makes this a static function.
inline: True makes this an inline function.
explicit: True makes this an explicit constructor.
constexpr: True makes this a constexpr function.
const: True makes this a const function.
override: True makes this an overriding function.
member_initializer_list: List of member initializers.
"""
assert isinstance(name, str)
assert isinstance(static, bool)
assert isinstance(inline, bool)
assert isinstance(explicit, bool)
assert isinstance(constexpr, bool)
assert isinstance(const, bool)
assert isinstance(override, bool)
self._function_name = name
self._arg_decls = arg_decls
self._return_type = return_type
self._const = const
# Presence of some attributes only makes sense on inline defitintions,
# in which case a separate declaration does not make sense.
self._inhibit_make_decl = (template_params or inline or explicit
or constexpr)
template_format = ("{template}"
"{static}{inline}{explicit}{constexpr}"
"{return_type} "
"{class_name}{name}({arg_decls})"
"{const}"
"{override}"
"{member_initializer_list} {{\n"
" {body}\n"
"}}")
if class_name is None:
class_name = ""
else:
class_name = ListNode([_to_maybe_text_node(class_name)], tail="::")
if template_params is None:
template = ""
else:
template = "template <{}>\n".format(", ".join(template_params))
static = "static " if static else ""
inline = "inline " if inline else ""
explicit = "explicit " if explicit else ""
constexpr = "constexpr " if constexpr else ""
const = " const" if const else ""
override = " override" if override else ""
if member_initializer_list is None:
member_initializer_list = ""
else:
member_initializer_list = ListNode(
map(_to_maybe_text_node, member_initializer_list),
separator=", ",
head=" : ")
self._body_node = SymbolScopeNode()
CompositeNode.__init__(
self,
template_format,
name=_to_maybe_text_node(name),
arg_decls=ListNode(
map(_to_maybe_text_node, arg_decls), separator=", "),
return_type=_to_maybe_text_node(return_type),
class_name=class_name,
template=template,
static=static,
inline=inline,
explicit=explicit,
constexpr=constexpr,
const=const,
override=override,
member_initializer_list=member_initializer_list,
body=self._body_node)
@property
def function_name(self):
return self._function_name
@property
def body(self):
return self._body_node
def make_decl(self,
static=False,
explicit=False,
override=False,
nodiscard=False):
assert not self._inhibit_make_decl
return CxxFuncDeclNode(name=self._function_name,
arg_decls=self._arg_decls,
return_type=self._return_type,
const=self._const,
static=static,
explicit=explicit,
override=override,
nodiscard=nodiscard)
class CxxClassDefNode(CompositeNode):
def __init__(self,
name,
base_class_names=None,
template_params=None,
final=False,
export=None):
"""
Args:
name: The class name to be defined.
base_class_names: The list of base class names.
template_params: List of template parameters or None.
final: True makes this a final class.
export: Class export annotation.
"""
assert isinstance(final, bool)
template_format = ("{template}"
"class{export} {name}{final}{base_clause} {{\n"
" {top_section}\n"
" {public_section}\n"
" {protected_section}\n"
" {private_section}\n"
" {bottom_section}\n"
"}};")
if template_params is None:
template = ""
else:
template = "template <{}>\n".format(", ".join(template_params))
if export is None:
export = ""
else:
export = ListNode([_to_maybe_text_node(export)], head=" ")
final = " final" if final else ""
if base_class_names is None:
base_clause = ""
else:
base_specifier_list = [
CompositeNode(
"public {base_class_name}",
base_class_name=_to_maybe_text_node(base_class_name))
for base_class_name in base_class_names
]
base_clause = ListNode(
base_specifier_list, separator=", ", head=" : ")
self._top_section = ListNode(tail="\n")
self._public_section = ListNode(head="public:\n", tail="\n")
self._protected_section = ListNode(head="protected:\n", tail="\n")
self._private_section = ListNode(head="private:\n", tail="\n")
self._bottom_section = ListNode()
CompositeNode.__init__(self,
template_format,
name=_to_maybe_text_node(name),
base_clause=base_clause,
template=template,
final=final,
export=export,
top_section=self._top_section,
public_section=self._public_section,
protected_section=self._protected_section,
private_section=self._private_section,
bottom_section=self._bottom_section)
@property
def top_section(self):
return self._top_section
@property
def public_section(self):
return self._public_section
@property
def protected_section(self):
return self._protected_section
@property
def private_section(self):
return self._private_section
@property
def bottom_section(self):
return self._bottom_section
class CxxNamespaceNode(CompositeNode):
def __init__(self, name="", body=None):
template_format = ("namespace {name} {{\n"
"\n"
"{body}\n"
"\n"
"}} // namespace {name}")
if body is None:
self._body = ListNode()
else:
self._body = _to_list_node(body)
CompositeNode.__init__(
self, template_format, name=name, body=self._body)
@property
def body(self):
return self._body
def _to_conditional_node(cond):
if isinstance(cond, CodeNode):
return cond
if isinstance(cond, CodeGenExpr):
return TextNode(cond.to_text())
if isinstance(cond, str):
return TextNode(cond)
assert False
def _to_list_node(node):
if isinstance(node, ListNode):
return node
if isinstance(node, CodeNode):
return ListNode([node])
if isinstance(node, (list, tuple)):
return ListNode(node)
assert False
def _to_maybe_text_node(node):
if isinstance(node, CodeNode):
return node
if isinstance(node, str):
return TextNode(node)
assert False
def _to_symbol_scope_node(node, likeliness):
if isinstance(node, SymbolScopeNode):
pass
elif isinstance(node, CodeNode):
node = SymbolScopeNode([node])
elif isinstance(node, (list, tuple)):
node = SymbolScopeNode(node)
else:
assert False
node.set_likeliness(likeliness)
return node
Codebase Browser
chromium