sandboxed-api/sandboxed_api/tools/generator2/code.py

953 lines
32 KiB
Python
Raw Normal View History

# Copyright 2019 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
"""Module related to code analysis and generation."""
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from ctypes import util
import itertools
import os
from clang import cindex
# pylint: disable=unused-import
from typing import (Text, List, Optional, Set, Dict, Callable, IO, Generator as
Gen, Tuple, Union, Sequence)
# pylint: enable=unused-import
_PARSE_OPTIONS = (
cindex.TranslationUnit.PARSE_SKIP_FUNCTION_BODIES
| cindex.TranslationUnit.PARSE_INCOMPLETE |
# for include directives
cindex.TranslationUnit.PARSE_DETAILED_PROCESSING_RECORD)
def _init_libclang():
"""Finds and initializes the libclang library."""
if cindex.Config.loaded:
return
# Try to find libclang in the standard location and a few versioned paths
# that are used on Debian (and others). If LD_LIBRARY_PATH is set, it is
# used as well.
for lib in [
'clang', 'clang-9', 'clang-8', 'clang-7', 'clang-6.0', 'clang-5.0',
'clang-4.0'
]:
libclang = util.find_library(lib)
if libclang:
cindex.Config.set_library_file(libclang)
break
def get_header_guard(path):
# type: (Text) -> Text
"""Generates header guard string from path."""
# the output file will be most likely somewhere in genfiles, strip the
# prefix in that case, also strip .gen if this is a step before clang-format
if not path:
raise ValueError('Cannot prepare header guard from path: {}'.format(path))
if 'genfiles/' in path:
path = path.split('genfiles/')[1]
if path.endswith('.gen'):
path = path.split('.gen')[0]
path = path.upper().replace('.', '_').replace('-', '_').replace('/', '_')
return path + '_'
def _stringify_tokens(tokens, separator='\n'):
# type: (Sequence[cindex.Token], Text) -> Text
"""Converts tokens to text respecting line position (disrespecting column)."""
previous = OutputLine(0, []) # not used in output
lines = [] # type: List[OutputLine]
for _, group in itertools.groupby(tokens, lambda t: t.location.line):
group_list = list(group)
line = OutputLine(previous.next_tab, group_list)
lines.append(line)
previous = line
return separator.join(str(l) for l in lines)
TYPE_MAPPING = {
cindex.TypeKind.VOID: '::sapi::v::Void',
cindex.TypeKind.CHAR_S: '::sapi::v::Char',
cindex.TypeKind.INT: '::sapi::v::Int',
cindex.TypeKind.UINT: '::sapi::v::UInt',
cindex.TypeKind.LONG: '::sapi::v::Long',
cindex.TypeKind.ULONG: '::sapi::v::ULong',
cindex.TypeKind.UCHAR: '::sapi::v::UChar',
cindex.TypeKind.USHORT: '::sapi::v::UShort',
cindex.TypeKind.SHORT: '::sapi::v::Short',
cindex.TypeKind.LONGLONG: '::sapi::v::LLong',
cindex.TypeKind.ULONGLONG: '::sapi::v::ULLong',
cindex.TypeKind.FLOAT: '::sapi::v::Reg<float>',
cindex.TypeKind.DOUBLE: '::sapi::v::Reg<double>',
cindex.TypeKind.LONGDOUBLE: '::sapi::v::Reg<long double>',
cindex.TypeKind.SCHAR: '::sapi::v::SChar',
cindex.TypeKind.SHORT: '::sapi::v::Short',
cindex.TypeKind.BOOL: '::sapi::v::Bool',
}
class Type(object):
"""Class representing a type.
Wraps cindex.Type of the argument/return value and provides helpers for the
code generation.
"""
def __init__(self, tu, clang_type):
# type: (_TranslationUnit, cindex.Type) -> None
self._clang_type = clang_type
self._tu = tu
# pylint: disable=protected-access
def __eq__(self, other):
# type: (Type) -> bool
# Use get_usr() to deduplicate Type objects based on declaration
decl = self._get_declaration()
decl_o = other._get_declaration()
return decl.get_usr() == decl_o.get_usr()
def __ne__(self, other):
# type: (Type) -> bool
return not self.__eq__(other)
def __lt__(self, other):
# type: (Type) -> bool
"""Compares two Types belonging to the same TranslationUnit.
This is being used to properly order types before emitting to generated
file. To be more specific: structure definition that contains field that is
a typedef should end up after that typedef definition. This is achieved by
exploiting the order in which clang iterate over AST in translation unit.
Args:
other: other comparison type
Returns:
true if this Type occurs earlier in the AST than 'other'
"""
self._validate_tu(other)
return (self._tu.order[self._get_declaration().hash] <
self._tu.order[other._get_declaration().hash]) # pylint: disable=protected-access
def __gt__(self, other):
# type: (Type) -> bool
"""Compares two Types belonging to the same TranslationUnit.
This is being used to properly order types before emitting to generated
file. To be more specific: structure definition that contains field that is
a typedef should end up after that typedef definition. This is achieved by
exploiting the order in which clang iterate over AST in translation unit.
Args:
other: other comparison type
Returns:
true if this Type occurs later in the AST than 'other'
"""
self._validate_tu(other)
return (self._tu.order[self._get_declaration().hash] >
self._tu.order[other._get_declaration().hash]) # pylint: disable=protected-access
def __hash__(self):
"""Types with the same declaration should hash to the same value."""
return hash(self._get_declaration().get_usr())
def _validate_tu(self, other):
# type: (Type) -> None
if self._tu != other._tu: # pylint: disable=protected-access
raise ValueError('Cannot compare types from different translation units.')
def is_void(self):
# type: () -> bool
return self._clang_type.kind == cindex.TypeKind.VOID
def is_typedef(self):
# type: () -> bool
return self._clang_type.kind == cindex.TypeKind.TYPEDEF
# Hack: both class and struct types are indistinguishable except for
# declaration cursor kind
def is_elaborated(self): # class, struct, union
# type: () -> bool
return (self._clang_type.kind == cindex.TypeKind.ELABORATED or
self._clang_type.kind == cindex.TypeKind.RECORD)
def is_struct(self):
# type: () -> bool
return (self.is_elaborated() and
self._get_declaration().kind == cindex.CursorKind.STRUCT_DECL)
def is_class(self):
# type: () -> bool
return (self.is_elaborated() and
self._get_declaration().kind == cindex.CursorKind.CLASS_DECL)
def is_function(self):
# type: () -> bool
return self._clang_type.kind == cindex.TypeKind.FUNCTIONPROTO
def is_ptr(self):
# type: () -> bool
if self.is_typedef():
return self._clang_type.get_canonical().kind == cindex.TypeKind.POINTER
return self._clang_type.kind == cindex.TypeKind.POINTER
def is_enum(self):
# type: () -> bool
return self._clang_type.kind == cindex.TypeKind.ENUM
def is_const_array(self):
# type: () -> bool
return self._clang_type.kind == cindex.TypeKind.CONSTANTARRAY
def is_simple_type(self):
# type: () -> bool
return self._clang_type.kind in TYPE_MAPPING
def get_pointee(self):
# type: () -> Type
return Type(self._tu, self._clang_type.get_pointee())
def _get_declaration(self):
# type: () -> cindex.Cursor
decl = self._clang_type.get_declaration()
if decl.kind == cindex.CursorKind.NO_DECL_FOUND and self.is_ptr():
decl = self.get_pointee()._get_declaration() # pylint: disable=protected-access
return decl
def get_related_types(self, result=None, skip_self=False):
# type: (Optional[Set[Type]], bool) -> Set[Type]
"""Returns all types related to this one eg. typedefs, nested structs."""
if result is None:
result = set()
if self in result or self.is_simple_type() or self.is_class():
return result
if self.is_const_array():
t = Type(self._tu, self._clang_type.get_array_element_type())
return t.get_related_types(result)
if self.is_typedef():
return self._get_related_types_of_typedef(result)
if self._clang_type.kind in (cindex.TypeKind.POINTER,
cindex.TypeKind.MEMBERPOINTER,
cindex.TypeKind.LVALUEREFERENCE,
cindex.TypeKind.RVALUEREFERENCE):
return self.get_pointee().get_related_types(result, skip_self)
if self.is_elaborated(): # union + struct, class hould be filtered out
return self._get_related_types_of_elaborated(result, skip_self)
if self.is_function():
return self._get_related_types_of_function(result)
if self.is_enum():
if not skip_self:
result.add(self)
self._tu.search_for_macro_name(self._get_declaration())
return result
raise ValueError('Unhandled kind: {}'.format(self._clang_type.kind))
def _get_related_types_of_typedef(self, result):
# type: (Set[Type]) -> Set[Type]
"""Returns all intermediate types related to the typedef."""
result.add(self)
decl = self._get_declaration()
t = Type(self._tu, decl.underlying_typedef_type)
if t.is_ptr():
t = t.get_pointee()
self._tu.search_for_macro_name(decl)
if not t.is_simple_type():
skip_child = self.contains_declaration(t)
if t.is_elaborated() and skip_child:
# if child declaration is contained in parent, we don't have to emit it
self._tu.types_to_skip.add(t)
result.update(t.get_related_types(result, skip_child))
return result
def _get_related_types_of_elaborated(self, result, skip_self=False):
# type: (Set[Type], bool) -> Set[Type]
"""Returns all types related to the structure."""
# skip unnamed structures eg. typedef struct {...} x;
# struct {...} will be rendered as part of typedef rendering
if self._get_declaration().spelling and not skip_self:
self._tu.search_for_macro_name(self._get_declaration())
result.add(self)
for f in self._clang_type.get_fields():
self._tu.search_for_macro_name(f)
result.update(Type(self._tu, f.type).get_related_types(result))
return result
def _get_related_types_of_function(self, result):
# type: (Set[Type]) -> Set[Type]
"""Returns all types related to the function."""
for arg in self._clang_type.argument_types():
result.update(Type(self._tu, arg).get_related_types(result))
related = Type(self._tu,
self._clang_type.get_result()).get_related_types(result)
result.update(related)
return result
def contains_declaration(self, other):
# type: (Type) -> bool
"""Checks if string representation of a type contains the other type."""
self_extent = self._get_declaration().extent
other_extent = other._get_declaration().extent # pylint: disable=protected-access
if other_extent.start.file is None:
return False
return (other_extent.start in self_extent and
other_extent.end in self_extent)
def stringify(self):
# type: () -> Text
"""Returns string representation of the Type."""
# (szwl): as simple as possible, keeps macros in separate lines not to
# break things; this will go through clang format nevertheless
tokens = [
x for x in self._get_declaration().get_tokens()
if x.kind is not cindex.TokenKind.COMMENT
]
return _stringify_tokens(tokens)
class OutputLine(object):
"""Helper class for Type printing."""
def __init__(self, tab, tokens):
# type: (int, List[cindex.Token]) -> None
self.tokens = tokens
self.spellings = []
self.define = False
self.tab = tab
self.next_tab = tab
list(map(self._process_token, self.tokens))
def _process_token(self, t):
# type: (cindex.Token) -> None
"""Processes a token, setting up internal states rel. to intendation."""
if t.spelling == '#':
self.define = True
elif t.spelling == '{':
self.next_tab += 1
elif t.spelling == '}':
self.tab -= 1
self.next_tab -= 1
is_bracket = t.spelling == '('
is_macro = len(self.spellings) == 1 and self.spellings[0] == '#'
if self.spellings and not is_bracket and not is_macro:
self.spellings.append(' ')
self.spellings.append(t.spelling)
def __str__(self):
# type: () -> Text
tabs = ('\t' * self.tab) if not self.define else ''
return tabs + ''.join(t for t in self.spellings)
class ArgumentType(Type):
"""Class representing function argument type.
Object fields are being used by the code template:
pos: argument position
type: string representation of the type
argument: string representation of the type as function argument
mapped_type: SAPI equivalent of the type
wrapped: wraps type in SAPI object constructor
call_argument: type (or it's sapi wrapper) used in function call
"""
def __init__(self, function, pos, arg_type, name=None):
# type: (Function, int, cindex.Type, Optional[Text]) -> None
super(ArgumentType, self).__init__(function.translation_unit(), arg_type)
self._function = function
self.pos = pos
self.name = name or 'a{}'.format(pos)
self.type = arg_type.spelling
template = '{}' if self.is_ptr() else '&{}_'
self.call_argument = template.format(self.name)
def __str__(self):
# type: () -> Text
"""Returns function argument prepared from the type."""
if self.is_ptr():
return '::sapi::v::Ptr* {}'.format(self.name)
return '{} {}'.format(self._clang_type.spelling, self.name)
@property
def wrapped(self):
# type: () -> Text
return '{} {name}_(({name}))'.format(self.mapped_type, name=self.name)
@property
def mapped_type(self):
# type: () -> Text
"""Maps the type to its SAPI equivalent."""
if self.is_ptr():
# TODO(szwl): const ptrs do not play well with SAPI C++ API...
spelling = self._clang_type.spelling.replace('const', '')
return '::sapi::v::Reg<{}>'.format(spelling)
type_ = self._clang_type
if type_.kind == cindex.TypeKind.TYPEDEF:
type_ = self._clang_type.get_canonical()
if type_.kind == cindex.TypeKind.ELABORATED:
type_ = type_.get_canonical()
if type_.kind == cindex.TypeKind.ENUM:
return '::sapi::v::IntBase<{}>'.format(self._clang_type.spelling)
if type_.kind in [
cindex.TypeKind.CONSTANTARRAY, cindex.TypeKind.INCOMPLETEARRAY
]:
return '::sapi::v::Reg<{}>'.format(self._clang_type.spelling)
if type_.kind == cindex.TypeKind.LVALUEREFERENCE:
return 'LVALUEREFERENCE::NOT_SUPPORTED'
if type_.kind == cindex.TypeKind.RVALUEREFERENCE:
return 'RVALUEREFERENCE::NOT_SUPPORTED'
if type_.kind in [cindex.TypeKind.RECORD, cindex.TypeKind.ELABORATED]:
raise ValueError('Elaborate type (eg. struct) in mapped_type is not '
'supported: function {}, arg {}, type {}, location {}'
''.format(self._function.name, self.pos,
self._clang_type.spelling,
self._function.cursor.location))
if type_.kind not in TYPE_MAPPING:
raise KeyError('Key {} does not exist in TYPE_MAPPING.'
' function {}, arg {}, type {}, location {}'
''.format(type_.kind, self._function.name, self.pos,
self._clang_type.spelling,
self._function.cursor.location))
return TYPE_MAPPING[type_.kind]
class ReturnType(ArgumentType):
"""Class representing function return type.
Attributes:
return_type: sapi::StatusOr<T> where T is original return type, or
absl::Status for functions returning void
"""
def __init__(self, function, arg_type):
# type: (Function, cindex.Type) -> None
super(ReturnType, self).__init__(function, 0, arg_type, None)
def __str__(self):
# type: () -> Text
"""Returns function return type prepared from the type."""
# TODO(szwl): const ptrs do not play well with SAPI C++ API...
spelling = self._clang_type.spelling.replace('const', '')
return_type = 'sapi::StatusOr<{}>'.format(spelling)
return_type = 'absl::Status' if self.is_void() else return_type
return return_type
class Function(object):
"""Class representing SAPI-wrapped function used by the template.
Wraps Clang cursor object of kind FUNCTION_DECL and provides helpers to
aid code generation.
"""
def __init__(self, tu, cursor):
# type: (_TranslationUnit, cindex.Cursor) -> None
self._tu = tu
self.cursor = cursor # type: cindex.Index
self.name = cursor.spelling # type: Text
self.mangled_name = cursor.mangled_name # type: Text
self.result = ReturnType(self, cursor.result_type)
self.original_definition = '{} {}'.format(
cursor.result_type.spelling, self.cursor.displayname) # type: Text
types = self.cursor.get_arguments()
self.argument_types = [
ArgumentType(self, i, t.type, t.spelling) for i, t in enumerate(types)
]
def translation_unit(self):
# type: () -> _TranslationUnit
return self._tu
def arguments(self):
# type: () -> List[ArgumentType]
return self.argument_types
def call_arguments(self):
# type: () -> List[Text]
return [a.call_argument for a in self.argument_types]
def get_absolute_path(self):
# type: () -> Text
return self.cursor.location.file.name
def get_include_path(self, prefix):
# type: (Optional[Text]) -> Text
"""Creates a proper include path."""
# TODO(szwl): sanity checks
# TODO(szwl): prefix 'utils/' and the path is '.../fileutils/...' case
if prefix and not prefix.endswith('/'):
prefix += '/'
if not prefix:
return self.get_absolute_path()
elif prefix in self.get_absolute_path():
return prefix + self.get_absolute_path().split(prefix)[-1]
return prefix + self.get_absolute_path().split('/')[-1]
def get_related_types(self, processed=None):
# type: (Optional[Set[Type]]) -> Set[Type]
result = self.result.get_related_types(processed)
for a in self.argument_types:
result.update(a.get_related_types(processed))
return result
def is_mangled(self):
# type: () -> bool
return self.name != self.mangled_name
def __hash__(self):
# type: () -> int
return hash(self.cursor.get_usr())
def __eq__(self, other):
# type: (Function) -> bool
return self.mangled_name == other.mangled_name
class _TranslationUnit(object):
"""Class wrapping clang's _TranslationUnit. Provides extra utilities."""
def __init__(self, path, tu, limit_scan_depth=False):
# type: (Text, cindex.TranslationUnit, bool) -> None
self.path = path
self.limit_scan_depth = limit_scan_depth
self._tu = tu
self._processed = False
self.forward_decls = dict()
self.functions = set()
self.order = dict()
self.defines = {}
self.required_defines = set()
self.types_to_skip = set()
def _process(self):
# type: () -> None
"""Walks the cursor tree and caches some for future use."""
if not self._processed:
# self.includes[self._tu.spelling] = (0, self._tu.cursor)
self._processed = True
# TODO(szwl): duplicates?
# TODO(szwl): for d in translation_unit.diagnostics:, handle that
for i, cursor in enumerate(self._walk_preorder()):
# naive way to order types: they should be ordered when walking the tree
if cursor.kind.is_declaration():
self.order[cursor.hash] = i
if (cursor.kind == cindex.CursorKind.MACRO_DEFINITION and
cursor.location.file):
self.order[cursor.hash] = i
self.defines[cursor.spelling] = cursor
# most likely a forward decl of struct
if (cursor.kind == cindex.CursorKind.STRUCT_DECL and
not cursor.is_definition()):
self.forward_decls[Type(self, cursor.type)] = cursor
if (cursor.kind == cindex.CursorKind.FUNCTION_DECL and
cursor.linkage != cindex.LinkageKind.INTERNAL):
if self.limit_scan_depth:
if (cursor.location and cursor.location.file.name == self.path):
self.functions.add(Function(self, cursor))
else:
self.functions.add(Function(self, cursor))
def get_functions(self):
# type: () -> Set[Function]
if not self._processed:
self._process()
return self.functions
def _walk_preorder(self):
# type: () -> Gen
for c in self._tu.cursor.walk_preorder():
yield c
def search_for_macro_name(self, cursor):
# type: (cindex.Cursor) -> None
"""Searches for possible macro usage in constant array types."""
tokens = list(t.spelling for t in cursor.get_tokens())
try:
for token in tokens:
if token in self.defines and token not in self.required_defines:
self.required_defines.add(token)
self.search_for_macro_name(self.defines[token])
except ValueError:
return
class Analyzer(object):
"""Class responsible for analysis."""
@staticmethod
def process_files(input_paths, compile_flags, limit_scan_depth=False):
# type: (Text, List[Text], bool) -> List[_TranslationUnit]
"""Processes files with libclang and returns TranslationUnit objects."""
_init_libclang()
tus = []
for path in input_paths:
tu = Analyzer._analyze_file_for_tu(
path, compile_flags=compile_flags, limit_scan_depth=limit_scan_depth)
tus.append(tu)
return tus
# pylint: disable=line-too-long
@staticmethod
def _analyze_file_for_tu(path,
compile_flags=None,
test_file_existence=True,
unsaved_files=None,
limit_scan_depth=False):
# type: (Text, Optional[List[Text]], bool, Optional[Tuple[Text, Union[Text, IO[Text]]]], bool) -> _TranslationUnit
"""Returns Analysis object for given path."""
compile_flags = compile_flags or []
if test_file_existence and not os.path.isfile(path):
raise IOError('Path {} does not exist.'.format(path))
_init_libclang()
index = cindex.Index.create() # type: cindex.Index
# TODO(szwl): hack until I figure out how python swig does that.
# Headers will be parsed as C++. C libs usually have
# '#ifdef __cplusplus extern "C"' for compatibility with c++
lang = '-xc++' if not path.endswith('.c') else '-xc'
args = [lang]
args += compile_flags
args.append('-I.')
return _TranslationUnit(
path,
index.parse(
path,
args=args,
unsaved_files=unsaved_files,
options=_PARSE_OPTIONS),
limit_scan_depth=limit_scan_depth)
class Generator(object):
"""Class responsible for code generation."""
AUTO_GENERATED = ('// AUTO-GENERATED by the Sandboxed API generator.\n'
'// Edits will be discarded when regenerating this file.\n')
GUARD_START = ('#ifndef {0}\n' '#define {0}')
GUARD_END = '#endif // {}'
EMBED_INCLUDE = '#include \"{}/{}_embed.h"'
EMBED_CLASS = ('class {0}Sandbox : public ::sapi::Sandbox {{\n'
' public:\n'
' {0}Sandbox() : ::sapi::Sandbox({1}_embed_create()) {{}}\n'
'}};')
def __init__(self, translation_units):
# type: (List[cindex.TranslationUnit]) -> None
"""Initializes the generator.
Args:
translation_units: list of translation_units for analyzed files,
facultative. If not given, then one is computed for each element of
input_paths
"""
self.translation_units = translation_units
self.functions = None
_init_libclang()
def generate(self,
name,
function_names,
namespace=None,
output_file=None,
embed_dir=None,
embed_name=None):
# pylint: disable=line-too-long
# type: (Text, List[Text], Optional[Text], Optional[Text], Optional[Text], Optional[Text]) -> Text
"""Generates structures, functions and typedefs.
Args:
name: name of the class that will contain generated interface
function_names: list of function names to export to the interface
namespace: namespace of the interface
output_file: path to the output file, used to generate header guards;
defaults to None that does not generate the guard #include directives;
defaults to None that causes to emit the whole file path
embed_dir: path to directory with embed includes
embed_name: name of the embed object
Returns:
generated interface as a string
"""
related_types = self._get_related_types(function_names)
forward_decls = self._get_forward_decls(related_types)
functions = self._get_functions(function_names)
related_types = [(t.stringify() + ';') for t in related_types]
defines = self._get_defines()
api = {
'name': name,
'functions': functions,
'related_types': defines + forward_decls + related_types,
'namespaces': namespace.split('::') if namespace else [],
'embed_dir': embed_dir,
'embed_name': embed_name,
'output_file': output_file
}
return self.format_template(**api)
def _get_functions(self, func_names=None):
# type: (Optional[List[Text]]) -> List[Function]
"""Gets Function objects that will be used to generate interface."""
if self.functions is not None:
return self.functions
self.functions = []
# TODO(szwl): for d in translation_unit.diagnostics:, handle that
for translation_unit in self.translation_units:
self.functions += [
f for f in translation_unit.get_functions()
if not func_names or f.name in func_names
]
# allow only nonmangled functions - C++ overloads are not handled in
# code generation
self.functions = [f for f in self.functions if not f.is_mangled()]
# remove duplicates
self.functions = list(set(self.functions))
self.functions.sort(key=lambda x: x.name)
return self.functions
def _get_related_types(self, func_names=None):
# type: (Optional[List[Text]]) -> List[Type]
"""Gets type definitions related to chosen functions.
Types related to one function will land in the same translation unit,
we gather the types, sort it and put as a sublist in types list.
This is necessary as we can't compare types from two different translation
units.
Args:
func_names: list of function names to take into consideration, empty means
all functions.
Returns:
list of types in correct (ready to render) order
"""
processed = set()
fn_related_types = set()
types = []
types_to_skip = set()
for f in self._get_functions(func_names):
fn_related_types = f.get_related_types()
types += sorted(r for r in fn_related_types if r not in processed)
processed.update(fn_related_types)
types_to_skip.update(f.translation_unit().types_to_skip)
return [t for t in types if t not in types_to_skip]
def _get_defines(self):
# type: () -> List[Text]
"""Gets #define directives that appeared during TranslationUnit processing.
Returns:
list of #define string representations
"""
def make_sort_condition(translation_unit):
return lambda cursor: translation_unit.order[cursor.hash]
result = []
for tu in self.translation_units:
tmp_result = []
sort_condition = make_sort_condition(tu)
for name in tu.required_defines:
if name in tu.defines:
define = tu.defines[name]
tmp_result.append(define)
for define in sorted(tmp_result, key=sort_condition):
result.append('#define ' +
_stringify_tokens(define.get_tokens(), separator=' \\\n'))
return result
def _get_forward_decls(self, types):
# type: (List[Type]) -> List[Text]
"""Gets forward declarations of related types, if present."""
forward_decls = dict()
result = []
done = set()
for tu in self.translation_units:
forward_decls.update(tu.forward_decls)
for t in types:
if t in forward_decls and t not in done:
result.append(_stringify_tokens(forward_decls[t].get_tokens()) + ';')
done.add(t)
return result
def _format_function(self, f):
# type: (Function) -> Text
"""Renders one function of the Api.
Args:
f: function object with information necessary to emit full function body
Returns:
filled function template
"""
result = []
result.append(' // {}'.format(f.original_definition))
arguments = ', '.join(str(a) for a in f.arguments())
result.append(' {} {}({}) {{'.format(f.result, f.name, arguments))
result.append(' {} ret;'.format(f.result.mapped_type))
argument_types = []
for a in f.argument_types:
if not a.is_ptr():
argument_types.append(a.wrapped + ';')
if argument_types:
for arg in argument_types:
result.append(' {}'.format(arg))
call_arguments = f.call_arguments()
if call_arguments: # fake empty space to add ',' before first argument
call_arguments.insert(0, '')
result.append('')
# For OSS, the macro below will be replaced.
result.append(' SAPI_RETURN_IF_ERROR(sandbox_->Call("{}", &ret{}));'
''.format(f.name, ', '.join(call_arguments)))
return_status = 'return absl::OkStatus();'
if f.result and not f.result.is_void():
if f.result and f.result.is_enum():
return_status = ('return static_cast<{}>'
'(ret.GetValue());').format(f.result.type)
else:
return_status = 'return ret.GetValue();'
result.append(' {}'.format(return_status))
result.append(' }')
return '\n'.join(result)
def format_template(self, name, functions, related_types, namespaces,
embed_dir, embed_name, output_file):
# pylint: disable=line-too-long
# type: (Text, List[Function], List[Type], List[Text], Text, Text, Text) -> Text
# pylint: enable=line-too-long
"""Formats arguments into proper interface header file.
Args:
name: name of the Api - 'Test' will yield TestApi object
functions: list of functions to generate
related_types: types used in the above functions
namespaces: list of namespaces to wrap the Api class with
embed_dir: directory where the embedded library lives
embed_name: name of embedded library
output_file: interface output path - used in header guard generation
Returns:
generated header file text
"""
result = [Generator.AUTO_GENERATED]
header_guard = get_header_guard(output_file) if output_file else ''
if header_guard:
result.append(Generator.GUARD_START.format(header_guard))
# Copybara transform results in the paths below.
result.append('#include "sandboxed_api/sandbox.h"')
result.append('#include "sandboxed_api/vars.h"')
if embed_dir and embed_name:
result.append(Generator.EMBED_INCLUDE.format(embed_dir, embed_name))
if namespaces:
result.append('')
for n in namespaces:
result.append('namespace {} {{'.format(n))
if related_types:
result.append('')
for t in related_types:
result.append(t)
result.append('')
if embed_dir and embed_name:
result.append(
Generator.EMBED_CLASS.format(name, embed_name.replace('-', '_')))
result.append('class {}Api {{'.format(name))
result.append(' public:')
result.append(' explicit {}Api(::sapi::Sandbox* sandbox)'
' : sandbox_(sandbox) {{}}'.format(name))
result.append(' // Deprecated')
result.append(' ::sapi::Sandbox* GetSandbox() const { return sandbox(); }')
result.append(' ::sapi::Sandbox* sandbox() const { return sandbox_; }')
for f in functions:
result.append('')
result.append(self._format_function(f))
result.append('')
result.append(' private:')
result.append(' ::sapi::Sandbox* sandbox_;')
result.append('};')
result.append('')
if namespaces:
for n in reversed(namespaces):
result.append('}} // namespace {}'.format(n))
if header_guard:
result.append(Generator.GUARD_END.format(header_guard))
result.append('')
return '\n'.join(result)