def make_func_bodies(self):
"""Extracts bodies of lambda functions
(as opposed to their headers). These bodies
will then be translated to a series of function
calls.
"""
for name in self.func_dict:
tok = Lexer(self.func_dict[name]).get_tokens()
end = tok.match_paren(0)
header_end = tok.match_paren(2)
if tok[header_end+2] == '(': #Function returns another function
start = body.match_paren(header_end+2)+3
else: #Function returns a concrete type
start = header_end+3
self.func_bodies[name] = tok[start:end].get_joined()
self.func_bodies['main'] = self.main
def make_func_declarations(self):
"""Creates function declarations with parameter
types and return types. Higher order functions
are supported. Function declarations are also
used as function signatures.
Precondition: make_func_dict must have been called
"""
for name in self.func_dict:
body = Lexer(self.func_dict[name]).get_tokens()
i = body.index('\\') + 1 #Start of parameters
j = body.match_paren(i)
param_tokens = body[i + 1: j] #Stuff inside parentheses
# print "param list:", param_tokens
params = self.split_params(param_tokens)
params = map(lambda n: n.split(':'), params)
#params is now [[<name>,<type>],...]
c_types = map(lambda n: self.convert_type(*n), params)
# print c_types
return_type = ''
# +2 to skip over ")" and ":"
if body[j+2] == '(': #Function returns another function
# +3 for [")","->","<type>"]
for x in xrange(j+2, body.match_paren(j+2)+3):
return_type += body[x]
else: #Function returns a concrete type
return_type = body[j+2] #+2 to skip over ")" and ":"
func_type = self.convert_type(name, return_type)
# print "params", params
# print "c_types", c_types
#while True:exec raw_input() in globals(), locals()
self.cpp_declarations[name] = func_type + '(' + ', '.join(c_types) + ')'
self.cpp_declarations['main'] = 'int main()' #actually this isn't used
