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))
