def _prep_args(args, kwds): arg_values = _prep_value_list(args) kwd_names = [] kwd_values = [] for (k,v) in kwds.items(): kwd_names.append(c_str(k)) kwd_values.append(python_value_to_parakeet(v)) kwd_names = list_to_ctypes_array(kwd_names) kwd_values = list_to_ctypes_array(kwd_values) return arg_values, kwd_names, kwd_values
def mk_call(fn, positional_args, kw_names = [], kw_values = [], src_info=None): """ lower-level helper for building a function call, Assumes function is a Parakeet node and that keyword names have already been converted to character pointers """ assert len(kw_names) == len(kw_values) args_array = list_to_ctypes_array(positional_args) n_args = c_int(len(positional_args)) kw_names_array = list_to_ctypes_array(kw_names, c_char_p) kw_values_array = list_to_ctypes_array(kw_values) n_kwds = c_int(len(kw_names)) srcAddr = src_addr(src_info) #print "mk_call", kw_names_array, kw_values_array # paranode fun, paranode *args, int num_args, # char** keywords, paranode* keyword_values, int num_keyword_args, # source_info_t *src_info return LibPar.mk_call( fn, args_array, n_args, kw_names_array, kw_values_array, n_kwds, srcAddr)
def visit_assign(self, lhs, rhs, src_info = None): """ On the left-hand-side of an assignment we allow either a variable or a tuple of variables. Anything else should signal an error. The right-hand-side is expected to be an expression (and not a statement). """ def mk_lhs_var(node): return build_var(node.id, self.build_src_info(node)) if isinstance(lhs, ast.Name): vars = [mk_lhs_var(lhs)] elif isinstance(lhs, ast.Tuple): assert all([isinstance(elt, ast.Name) for elt in lhs.elts]) vars = [mk_lhs_var(elt) for elt in lhs.elts] else: raise RuntimeError("Unsupported LHS") rhs = self.visit_expr(rhs) return LibPar.mk_assign(list_to_ctypes_array(vars), len(vars), rhs, src_info)
def _prep_value_list(vals): parakeet_values = [python_value_to_parakeet(v) for v in vals] return list_to_ctypes_array(parakeet_values)
def _globals_as_parakeet_value_array(self): return list_to_ctypes_array(self._globals_as_parakeet_value_list())
def register_function(f): print "********************************" print " Registering", f print "********************************" if f in VisitedFunctions: "...already visited" untyped_id = VisitedFunctions[f] global_vars = VisitedFunctionGlobals.get(f, []) return untyped_id, global_vars file_name = f.__code__.co_filename line_offset = f.__code__.co_firstlineno global_refs = f.func_globals argspec = inspect.getargspec(f) assert argspec.varargs is None assert argspec.keywords is None body_source = inspect.getsource(f) #function_source(codeInfo) body_ast = ast.parse(body_source) print body_source print ast_to_str(body_ast) body_ast = ast.fix_missing_locations(body_ast) Converter = ASTConverter(global_refs, argspec.args, file_name, line_offset) parakeet_syntax = Converter.visit_module(body_ast) print "Syntax node", parakeet_syntax for other_fn in Converter.seen_functions: if not VisitedFunctions.has_key(other_fn): register_function(other_fn) global_vars = list(Converter.global_variables) n_globals = len(global_vars) globals_array = list_to_ctypes_array(global_vars,c_char_p) if argspec.defaults is None: default_values = [] positional = argspec.args else: default_values = argspec.defaults positional = argspec.args[:-len(default_values)] positional = map(c_char_p, positional) n_positional = len(positional) n_defaults = len(default_values) positional_args_array = list_to_ctypes_array(positional, c_char_p) default_args = argspec.args[n_positional:] default_args = map(c_char_p, default_args) default_args_array = \ list_to_ctypes_array(default_args, c_char_p) # TODO: Default values are currently RUNTIME value, eek! parakeet_default_values = \ [python_value_to_ast_node(v) for v in default_values] default_values_array = list_to_ctypes_array(parakeet_default_values) # register every function that was seen but not registered fn_name_c_str = c_char_p(global_fn_name(f)) print "Calling register with %d/%d/%d global/positional/default" % (n_globals, n_positional, n_defaults) print "args", default_args_array, len(default_args_array) fun_id = c_int( LibPar.register_untyped_function( fn_name_c_str, globals_array, n_globals, positional_args_array, n_positional, default_args_array, default_values_array, n_defaults, parakeet_syntax)) VisitedFunctions[f] = fun_id VisitedFunctionGlobals[f] = global_vars return fun_id, global_vars
def mk_block(stmts, src_info = None): arr = list_to_ctypes_array(stmts) return LibPar.mk_block(arr, len(stmts), src_addr(src_info))
def mk_tuple(elts, src_info = None): arr = list_to_ctypes_array(elts) return LibPar.mk_tuple(arr, len(arr), src_addr(src_info))
def mk_return(elts, src_info=None): arr = list_to_ctypes_array(elts) if len(elts) > 0 else None return LibPar.mk_return(arr, len(elts), src_addr(src_info))