diff options
Diffstat (limited to 'test-chill/testchill/_cpp_validate_env.py')
| -rw-r--r-- | test-chill/testchill/_cpp_validate_env.py | 654 |
1 files changed, 0 insertions, 654 deletions
diff --git a/test-chill/testchill/_cpp_validate_env.py b/test-chill/testchill/_cpp_validate_env.py deleted file mode 100644 index 9ef5a71..0000000 --- a/test-chill/testchill/_cpp_validate_env.py +++ /dev/null @@ -1,654 +0,0 @@ -import ast as _pyast -import collections as _pycollections -import functools as _pyfunctools -import itertools as _pyitertools -import random as _pyrandom -import struct as _pystruct -import types as _pytypes - -from . import util as _chill_util - -_pylambdatype = _pycollections.namedtuple('LambdaType', ['paramtypes','exprtype']) -_pyarraytype = _pycollections.namedtuple('ArrayType', ['dimensions','basetype']) - -_runtime_globals = dict({ - '_pyitertools':_pyitertools, - '_pyrandom':_pyrandom - }) - -def _evalexpr(expr, target_type, bindings): - glbls = dict(bindings) - glbls.update(_runtime_globals) - if target_type is None: - pytype = None - else: - pytype = target_type.getpytype() - expr = _pyast.Expression(expr.compile_expr(pytype)) - expr = _pyast.fix_missing_locations(expr) - return eval(compile(expr, '<string>', 'eval'), glbls) - -def _addbindings(expr, binding_frame): - if hasattr(expr, 'binding_stack'): - expr.binding_stack = [binding_frame] + expr.binding_stack - return expr - - -class _TreeNode(object): - def print_tree(self, stream=None, indent=0): - strname = type(self).__name__ - stream.write(strname + ':\n') - indent += 2 - for k,v in vars(self).items(): - if isinstance(v, _TreeNode): - stream.write(('{}{}:'.format(' '*indent, k))) - v.print_tree(stream, indent + len(k)) - elif isinstance(v, list): - stream.write(('{}{}: [\n'.format(' '*indent, k))) - for itm in v: - if isinstance(itm, _TreeNode): - stream.write(' '*indent) - itm.print_tree(stream, indent + len(k) + 1) - else: - stream.write('{}{}\n'.format(' '*(indent + 1), str(itm))) - else: - stream.write(('{}{}: {}\n'.format(' '*indent, k, str(v)))) - -class _CppType(_TreeNode): - def __init__(self): - pass - - def __repr__(self): - return "{}".format(str(self)) - - def statictype(self, bindings): - return self - - def formatdata(self, data): - raise NotImplementedError - - def get_cdecl_stmt(self, param_name): - raise NotImplementedError - - def get_cread_stmt(self, param_name, istream_name, dims): - raise NotImplementedError - - def get_cwrite_stmt(self, param_name, ostream_name, dims): - raise NotImplementedError - - def getfreevars(self, glbls): - raise NotImplementedError - - -class _CppPrimitiveType(_CppType): - _bycppname = { - 'char': ('char', 'c', 1, False, False, True, False), - 'signed char': ('signed char', 'b', 1, True, False, False, False), - 'unsigned char': ('unsigned char', 'B', 1, True, False, False, False), - 'short': ('short', 'h', 2, True, False, False, True), - 'unsigned short': ('unsigned short', 'H', 2, True, False, False, False), - 'int': ('int', 'i', 4, True, False, False, True), - 'unsigned int': ('unsigned int', 'I', 4, True, False, False, False), - 'long': ('long', 'l', 4, True, False, False, True), - 'unsigned long': ('unsigned long', 'L', 4, True, False, False, False), - 'long long': ('long long', 'q', 8, True, False, False, True), - 'unsigned long long': ('unsigned long long', 'Q', 8, True, False, False, False), - 'float': ('float', 'f', 4, False, True, False, True), - 'double': ('double', 'd', 8, False, True, False, True) - } - def __init__(self, cppname, structfmt, size, isint, isfloat, ischar, issigned): - _CppType.__init__(self) - self.cppname = cppname - self.size = size - self.size_expr = 'sizeof(' + cppname + ')' - self.structfmt = structfmt - self.isint = isint - self.isfloat = isfloat - self.ischar = ischar - self.issigned = issigned - - @staticmethod - def get_from_cppname(cppname): - return _CppPrimitiveType(*_CppPrimitiveType._bycppname[cppname]) - - def getfreevars(self, glbls): - return set() - - def getpytype(self): - if self.ischar: - return str - elif self.isint: - return int - elif self.isfloat: - return float - - def __str__(self): - return self.cppname - - def formatdata(self, data): - return [1], _pystruct.pack(self.structfmt, data) - - def get_cdecl_stmt(self, param_name): - return '{} {};'.format(self.cppname, param_name) - - def get_cread_stmt(self, param_name, istream_name, dims): - return '{}.read((const char*)&{}, {});'.format(istream_name, param_name, self.size_expr) - - def get_cwrite_stmt(self, param_name, ostream_name, dims): - return '{}.write((const char*)&{}, {});'.format(ostream_name, param_name, self.size_expr) - - -class _CppVoidType(_CppType): - def __init__(self): - self.cppname = 'void' - - def getfreevars(self, glbls): - return set() - - def getpytype(self): - return type(None) - - def __str__(self): - return 'void' - - -class _CppArrayType(_CppType): - def __init__(self, basetype, dims=[None]): - _CppType.__init__(self) - self.basetype = basetype - self.dimensions = dims - - def getfreevars(self, glbls): - freevars = self.basetype.getfreevars(glbls) - for fv in iter(d.getfreevars(glbls) for d in self.dimensions if hasattr(d, 'getfreevars')): - freevars = freevars | fv - return freevars - - def getpytype(self): - return _pyarraytype(self.dimensions, self.basetype.getpytype()) - - def __str__(self): - return '{}[{}]'.format(str(self.basetype), ']['.join(map(str,self.dimensions))) - - def statictype(self, bindings): - dim_list = list() - for dim in self.dimensions: - if dim is None: - dim_list.append(None) - else: - dim_list.append(_evalexpr(dim, _CppPrimitiveType.get_from_cppname('int'), bindings)) - return _CppArrayType(self.basetype.statictype(bindings), dim_list) - - def _formatdata_array(self, unit_length, data): - read_length = 0 - if _chill_util.python_version_major == 2: - read_data = '' - else: - read_data = bytes() - while read_length < len(data): - for i in range(unit_length): - _, b = self.basetype.formatdata(data[read_length+i]) - read_data += b - read_length += unit_length - return read_data - - def formatdata(self, data): - prod = lambda l: _pyfunctools.reduce(lambda a,v: a*v, l, 1) - if self.dimensions[0] is None: - return self.dimensions, self._formatdata_array(prod(self.dimensions[1:]), data) - else: - return self.dimensions, self._formatdata_array(prod(self.dimensions), data) - - def get_cdecl_stmt(self, param_name): - return '{} {}[{}];'.format(str(self.basetype), param_name, ']['.join(map(str,self.dimensions))) - - def get_cread_stmt(self, param_name, istream_name, dims): - length = _pyfunctools.reduce(lambda a,v: a*v, self.dimensions) - #TODO: use dims - if isinstance(self.basetype, _CppPrimitiveType): - size_expr = '{}*{}'.format(length, self.basetype.size_expr) - return '{}.read((char*){}, {});'.format(istream_name, param_name, size_expr) - else: - raise NotImplementedError - - def get_cwrite_stmt(self, param_name, ostream_name, dims): - length = _pyfunctools.reduce(lambda a,v: a*v, self.dimensions) - #TODO: use dims - if isinstance(self.basetype, _CppPrimitiveType): - size_expr = '{}*{}'.format(length, self.basetype.size_expr) - return '{}.write((char*){}, {});'.format(ostream_name, param_name, size_expr) - else: - raise NotImplementedError - - -class _CppPointerType(_CppType): - def __init__(self, basetype): - _CppType.__init__(self) - self.basetype = basetype - - def getfreevars(self, glbls): - return self.basetype.getfreevars(glbls) - - def getpytype(self): - return self.basetype.getpytype() - - def __str__(self): - return '{}*'.format(str(self.basetype)) - - def statictype(self, bindings): - return _CppPointerType(self.basetype.statictype(bindings)) - - def formatdata(self, data): - if isinstance(data, list): - if _chill_util.python_version_major == 2: - read_data = '' - else: - read_data = bytes() - for data_item in data: - next_dims, b = self.basetype.formatdata(data_item) - read_data += b - return [len(data)] + next_dims, read_data - else: - dims, fmt_data = self.basetype.formatdata(data) - return [1] + dims, fmt_data - - -class _CppReferenceType(_CppType): - def __init__(self, basetype): - _CppType.__init__(self) - self.basetype = basetype - - def getfreevars(self, glbls): - return self.basetype.getfreevars(glbls) - - def getpytype(self): - return self.basetype.getpytype() - - def __str__(self): - return '{}&'.format(str(self.basetype)) - - def statictype(self, bindings): - return _CppReferenceType(self.basetype.statictype(bindings)) - - def formatdata(self, data): - dims, fmt_data = self.basetype.formatdata(data) - return dims, fmt_data - - -class _Parameter(_TreeNode): - def __init__(self, name, cpptype, direction, init_expr=None): - self.name = name - self.direction = direction - self.cpptype = cpptype - self.init_expr = init_expr - self._generated = None - - @staticmethod - def order_by_freevars(param_list, glbls=set()): - defined_names = set() - parameter_names = set(p.name for p in param_list) - param_queue = _pycollections.deque(param_list) - while len(param_queue): - param = param_queue.popleft() - freevars = (parameter_names & param.getfreevars(glbls)) - defined_names - if not len(freevars): - defined_names.add(param.name) - yield param - else: - param_queue.append(param) - - def getfreevars(self, glbls=set()): - freevars = set() - if self.init_expr is not None: - freevars = freevars | self.init_expr.getfreevars(glbls) - freevars = freevars | self.cpptype.getfreevars(glbls) - return freevars - - def generatedata(self, bindings=dict()): - if self._generated is None: - if self.init_expr is None: - py_data = None - else: - py_data = _evalexpr(self.init_expr, self.cpptype, bindings) - static_type = self.cpptype.statictype(bindings) - dims, data = static_type.formatdata(py_data) - self._generated = (self.name, static_type, dims, data) - return self.name, static_type, dims, data - else: - return self._generated - - -class _Procedure(_TreeNode): - def __init__(self, name, rtype, parameters): - self.name = name - self.rtype = rtype - self.parameters = parameters - self.binding_stack = [] - self._bindings = None - self._params_orderd = None - self._invoke_str = '{}({});'.format(self.name, ','.join([p.name for p in parameters])) - - def _order_params(self): - if not self._params_orderd: - self._params_orderd = list(_Parameter.order_by_freevars(self.parameters)) - - def _compute_bindings(self, global_bindings): - local_bindings = dict(global_bindings) - if self._bindings is None: - new_bindings = dict() - for binding_frame in self.binding_stack: - for name, (ctype, expr) in binding_frame.items(): - value = _evalexpr(expr, ctype, local_bindings) - new_bindings[name] = value - local_bindings[name] = value - self._bindings = new_bindings - local_bindings.update(self._bindings) - return local_bindings - - def generatedata(self, direction_list, global_bindings=None): - self._order_params() - if global_bindings is None: - global_bindings = dict() - bindings = self._compute_bindings(global_bindings) - for param in (p for p in self._params_orderd if p.direction in direction_list): - p_name, p_statictype, p_dims, p_data = param.generatedata(bindings) - #TODO: add binding - yield p_name, p_statictype, p_dims, p_data - - def generatedecls(self, bindings): - for p_name, p_statictype, p_dims, p_data in self.generatedata(['in','out','inout'], bindings): - yield p_statictype.get_cdecl_stmt(p_name) - #for p_name, p_statictype, p_dims, p_data in self.generatedata('out', bindings): - # yield p_statictype.get_cdecl_stmt(p_name) - - def generatereads(self, direction_list, stream, bindings): - for p_name, p_statictype, p_dims, p_data in self.generatedata(direction_list, bindings): - yield p_statictype.get_cread_stmt(p_name, stream, p_dims) - - def generatewrites(self, stream, bindings): - for p_name, p_statictype, p_dims, p_data in self.generatedata(['inout', 'out'], bindings): - yield p_statictype.get_cwrite_stmt(p_name, stream, p_dims) - - def getinvokestr(self): - return self._invoke_str - - -class _Expr(_TreeNode): - def __init__(self): - pass - - def getfreevars(self, glbls): - raise NotImplementedError - - def compile_to_lambda(self, glbls, target_type): - args = _pyast.arguments(list(_pyast.Name(n, _pyast.Param()) for n in self.getfreevars(self, glbls)), None, None, []) - expr = _pyast.Expression(_pyast.Lambda(args, self.compile_expr(target_type))) - expr = _pyast.fix_missing_locations(expr) - return eval(compile(expr, '<string>', 'eval')) - - def compile_expr(self, target_type): - raise NotImplementedError - - -class _ConstantExpr(_Expr): - def __init__(self, value): - self.value = value - - def compile_expr(self, target_type): - if target_type is None: - return _pyast.parse(self.value, '<string>', 'eval').body - elif target_type == chr: - return _pyast.Str(chr(self.value)) - elif target_type == int: - return _pyast.Num(int(self.value)) - elif target_type == str: - return _pyast.Str(str(self.value)) - elif target_type == float: - return _pyast.Num(float(self.value)) - - def getfreevars(self, glbls): - return set() - - def __str__(self): - return self.value - - -class _NameExpr(_Expr): - def __init__(self, name): - self.name = name - - def compile_expr(self, target_type): - return _pyast.Name(self.name, _pyast.Load()) - - def getfreevars(self, glbls): - if self.name not in glbls: - return set([self.name]) - else: - return set() - - def __str__(self): - return self.name - - -class _AttributeExpr(_Expr): - def __init__(self, expr, name): - self.expr = expr - self.name = name - - def compile_expr(self, target_type): - return _pyast.Attribute( - self.expr.compile_expr(None), - self.name, - _pyast.Load()) - - def getfreevars(self, glbls): - return self.expr.getfreevars(glbls) - - def __str__(self): - return '{}.{}'.format(str(self.expr), self.name) - - -class _BinExpr(_Expr): - _optypes = { - '+': _pyast.Add, - '-': _pyast.Sub, - '*': _pyast.Mult, - '**': _pyast.Pow, - '/': _pyast.Div - } - def __init__(self, left, op, right): - self.left = left - self.right = right - self.op = op - - def compile_expr(self, target_type): - return _pyast.BinOp( - self.left.compile_expr(target_type), - _BinExpr._optypes[self.op](), - self.right.compile_expr(target_type)) - - def getfreevars(self, glbls): - return self.left.getfreevars(glbls) | self.right.getfreevars(glbls) - - def __str__(self): - return '({}{}{})'.format(str(self.left),self.op,str(self.right)) - - -class _UnaryExpr(_Expr): - _optypes = { - '-': _pyast.USub - } - def __init__(self, op, expr): - self.op = op - self.expr = expr - - def compile_expr(self, target_type): - return _pyast.UnaryOp( - _UnaryExpr._optypes[self.op](), - self.expr.compile_expr(target_type)) - - def getfreevars(self, glbls): - return self.expr.getfreevars(glbls) - - def __str__(self): - return '({}{})'.format(self.op, str(self.expr)) - - -class _LambdaExpr(_Expr): - def __init__(self, params, expr): - self.params = params - self.expr = expr - - def compile_expr(self, target_type): - if target_type is None: - exprtype = None - else: - assert hasattr(target_type, 'paramtypes') - assert hasattr(target_type, 'exprtype') - exprtype = target_type.exprtype - if _chill_util.python_version_major == 2: - return _pyast.Lambda( - _pyast.arguments([_pyast.Name(p, _pyast.Param()) for p in self.params], None, None, []), - self.expr.compile_expr(exprtype)) - else: - return _pyast.Lambda( - _pyast.arguments([_pyast.arg(p, None) for p in self.params], None, None, [], None, None, [], []), - self.expr.compile_expr(exprtype)) - - def getfreevars(self, glbls): - new_glbls = set(glbls) - new_glbls = new_glbls | set(self.params) - return self.expr.getfreevars(new_glbls) - - def __str__(self): - return 'lambda {}:{}'.format(','.join(map(str,self.params)), str(self.expr)) - - -class _InvokeExpr(_Expr): - def __init__(self, func, parameters): - self.func = func - self.parameters = parameters - - def compile_expr(self, target_type): - if target_type is None: - lt = None - else: - lt = _pylambdatype([None for p in self.parameters], target_type) - return _pyast.Call( - self.func.compile_expr(lt), - [p.compile_expr(None) for p in self.parameters], - [], - None, - None) - - def getfreevars(self, glbls): - return set( - self.func.getfreevars(glbls) | - _pyfunctools.reduce(lambda a,v: a | v.getfreevars(glbls), self.parameters, set())) - - def __str__(self): - return '{}({})'.format(str(self.func),','.join(map(str,self.parameters))) - - -class _Generator(_Expr): - def __init__(self): - _Expr.__init__(self) - - -class _MatrixGenerator(_Generator): - def __init__(self, dims, genexpr): - self.dimensions = dims - self.genexpr = genexpr - - def _compile_dims(self, target_type): - if hasattr(target_type, 'dimensions'): - dim_exprs = list() - assert len(target_type.dimensions) == len(self.dimensions) - for i, d in enumerate(target_type.dimensions): - if d is None: - d = self.dimensions[i] - dim_exprs += [d.compile_expr(int)] - else: - dim_exprs = [d.compile_expr(int) for d in self.dimensions] - return _pyast.List(dim_exprs, _pyast.Load()) - - def _lambda_type(self, target_type): - if hasattr(target_type, 'dimensions'): - return _pylambdatype([int for d in target_type.dimensions], target_type.basetype) - else: - return _pylambdatype([int for d in self.dimensions], target_type) - - def compile_expr(self, target_type): - assert target_type is not None - dims = self._compile_dims(target_type) - ltype = self._lambda_type(target_type) - - #def array(func,dims): - # return [func(*d) for d in itertools.product(*(map(range,dims))] - elt_expr = _pyast.Call(self.genexpr.compile_expr(ltype), [], [], _pyast.Name('_d', _pyast.Load()), None) # func(*d) - # elt_expr = _pyast.Call(_pyast.Name('tuple', _pyast.Load()), [_pyast.Name('_d', _pyast.Load()), elt_expr], [], None, None) # tuple(d, func(*d)) - pdt_expr = _pyast.Attribute(_pyast.Name('_pyitertools', _pyast.Load()), 'product', _pyast.Load()) # itertools.product - itr_expr = _pyast.Call(_pyast.Name('map', _pyast.Load()), [_pyast.Name('range', _pyast.Load()), dims], [], None, None) # map(range,dims) - itr_expr = _pyast.Call(pdt_expr, [], [], itr_expr, None) # itertools.product(*(map(range,dims))) - return _pyast.ListComp( - elt_expr, - [_pyast.comprehension(_pyast.Name('_d', _pyast.Store()), itr_expr, [])]) - - def getfreevars(self, glbls): - return set( - self.genexpr.getfreevars(glbls) | - _pyfunctools.reduce(lambda a,v: a | v.getfreevars(glbls), filter(lambda x: x is not None, self.dimensions), set())) - - def __str__(self): - return 'matrix([{}],{})'.format(','.join(map(str,self.dimensions)),str(self.genexpr)) - - -class _RandomExpr(_Expr): - def __init__(self, minexpr, maxexpr): - self.minexpr = minexpr - self.maxexpr = maxexpr - self.expr = _BinExpr( - _BinExpr( - _InvokeExpr(_AttributeExpr(_NameExpr('_pyrandom'),'random'),[]), - '*', - _BinExpr(maxexpr, '-', minexpr)), - '+', - minexpr) - - def getfreevars(self, glbls): - return self.minexpr.getfreevars(glbls) | self.maxexpr.getfreevars(glbls) - - def compile_expr(self, target_type): - if target_type == int: - return _pyast.Call(_pyast.Name('int', _pyast.Load()),[self.expr.compile_expr(float)],[],None,None) - elif target_type == float: - return self.expr.compile_expr(target_type) - elif target_type is None: - return self.expr.compile_expr(None) - assert False - - def __str__(self): - return 'random({},{})'.format(str(self.minexpr),str(self.maxexpr)) - - -### What to import from * ### -addbindings = _addbindings - -CppType = _CppType -CppPrimitiveType = _CppPrimitiveType -CppVoidType = _CppVoidType -CppArrayType = _CppArrayType -CppPointerType = _CppPointerType - -ConstantExpr = _ConstantExpr -NameExpr = _NameExpr -AttributeExpr = _AttributeExpr -BinExpr = _BinExpr -UnaryExpr = _UnaryExpr -LambdaExpr = _LambdaExpr -InvokeExpr = _InvokeExpr -MatrixGenerator = _MatrixGenerator -RandomExpr = _RandomExpr - -Procedure = _Procedure -Parameter = _Parameter - |