def test_c_parse():
src1 = """\
int a, b = 4;
float c, d = 2.4;
"""
expr1.convert_to_expr(src1, "c")
ls = expr1.return_expr()
assert ls[0] == Declaration(
Variable(Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert ls[1] == Declaration(
Variable(Symbol("b"),
type=IntBaseType(String("integer")),
value=Integer(4)))
assert ls[2] == Declaration(
Variable(
Symbol("c"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert ls[3] == Declaration(
Variable(
Symbol("d"),
type=FloatBaseType(String("real")),
value=Float("2.3999999999999999", precision=53),
))
def test_var():
expr1.convert_to_expr(src, "f")
ls = expr1.return_expr()
for iter in expr1.return_expr():
assert isinstance(iter, Declaration)
assert ls[0] == Declaration(
Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls[1] == Declaration(
Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls[2] == Declaration(
Variable(Symbol("c"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls[3] == Declaration(
Variable(Symbol("d"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls[4] == Declaration(
Variable(Symbol("p"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls[5] == Declaration(
Variable(Symbol("q"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls[6] == Declaration(
Variable(Symbol("r"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls[7] == Declaration(
Variable(Symbol("s"), type=FloatBaseType(String("real")), value=Float(0.0))
)
def test_function():
c_src1 = "void fun1()" + "\n" + "{" + "\n" + "int a;" + "\n" + "}"
c_src2 = ("int fun2()" + "\n" + "{" + "\n" + "int a;" + "\n" +
"return a;" + "\n" + "}")
c_src3 = ("float fun3()" + "\n" + "{" + "\n" + "float b;" + "\n" +
"return b;" + "\n" + "}")
c_src4 = "float fun4()" + "\n" + "{}"
res1 = SymPyExpression(c_src1, "c").return_expr()
res2 = SymPyExpression(c_src2, "c").return_expr()
res3 = SymPyExpression(c_src3, "c").return_expr()
res4 = SymPyExpression(c_src4, "c").return_expr()
assert res1[0] == FunctionDefinition(
NoneToken(),
name=String("fun1"),
parameters=(),
body=CodeBlock(
Declaration(
Variable(
Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0),
))),
)
assert res2[0] == FunctionDefinition(
IntBaseType(String("integer")),
name=String("fun2"),
parameters=(),
body=CodeBlock(
Declaration(
Variable(
Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0),
)),
Return("a"),
),
)
assert res3[0] == FunctionDefinition(
FloatBaseType(String("real")),
name=String("fun3"),
parameters=(),
body=CodeBlock(
Declaration(
Variable(
Symbol("b"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
)),
Return("b"),
),
)
assert res4[0] == FunctionPrototype(FloatBaseType(String("real")),
name=String("fun4"),
parameters=())
def test_parameters():
c_src1 = ('void fun1( int a)' + '\n' + '{' + '\n' + 'int i;' + '\n' +
'}')
c_src2 = ('int fun2(float x, float y)' + '\n' + '{' + '\n' + 'int a;' +
'\n' + 'return a;' + '\n' + '}')
c_src3 = ('float fun3(int p, float q, int r)' + '\n' + '{' + '\n' +
'float b;' + '\n' + 'return b;' + '\n' + '}')
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
assert res1[0] == FunctionDefinition(
NoneToken(),
name=String('fun1'),
parameters=(Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)), ),
body=CodeBlock(
Declaration(
Variable(Symbol('i'),
type=IntBaseType(String('integer')),
value=Integer(0)))))
assert res2[0] == FunctionDefinition(
IntBaseType(String('integer')),
name=String('fun2'),
parameters=(Variable(Symbol('x'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)),
Variable(Symbol('y'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53))),
body=CodeBlock(
Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0))), Return('a')))
assert res3[0] == FunctionDefinition(
FloatBaseType(String('real')),
name=String('fun3'),
parameters=(Variable(Symbol('p'),
type=IntBaseType(String('integer')),
value=Integer(0)),
Variable(Symbol('q'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)),
Variable(Symbol('r'),
type=IntBaseType(String('integer')),
value=Integer(0))),
body=CodeBlock(
Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53))), Return('b')))
def transform_floating_literal(self, node):
"""Transformation function for floating literal
Used to get the value and type of the given floating literal.
Returns
=======
val : list
List with two arguments type and Value
type contains the type of float
value contains the value stored in the variable
Notes
=====
Only Base Float type supported for now
"""
type = FloatBaseType(String('real'))
try:
value = next(node.get_tokens()).spelling
except (StopIteration, ValueError):
# No tokens
value = Float(node.literal)
val = [type, value]
return val
def visit_Variable(self, node):
"""Visitor Function for Variable Declaration
Visits each variable declaration present in the ASR and creates a
Symbol declaration for each variable
Notes
=====
The functions currently only support declaration of integer and
real variables. Other data types are still under development.
Raises
======
NotImplementedError() when called for unsupported data types
"""
if isinstance(node.type, asr.Integer):
var_type = IntBaseType(String('integer'))
value = Integer(0)
elif isinstance(node.type, asr.Real):
var_type = FloatBaseType(String('real'))
value = Float(0.0)
else:
raise NotImplementedError("Data type not supported")
if not (node.intent == 'in'):
new_node = Variable(node.name).as_Declaration(type=var_type,
value=value)
self._py_ast.append(new_node)
def test_function():
c_src1 = ('void fun1()' + '\n' + '{' + '\n' + 'int a;' + '\n' + '}')
c_src2 = ('int fun2()' + '\n' + '{' + '\n' + 'int a;' + '\n' +
'return a;' + '\n' + '}')
c_src3 = ('float fun3()' + '\n' + '{' + '\n' + 'float b;' + '\n' +
'return b;' + '\n' + '}')
c_src4 = ('float fun4()' + '\n' + '{}')
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
res4 = SymPyExpression(c_src4, 'c').return_expr()
assert res1[0] == FunctionDefinition(
NoneToken(),
name=String('fun1'),
parameters=(),
body=CodeBlock(
Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))))
assert res2[0] == FunctionDefinition(
IntBaseType(String('integer')),
name=String('fun2'),
parameters=(),
body=CodeBlock(
Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0))), Return('a')))
assert res3[0] == FunctionDefinition(
FloatBaseType(String('real')),
name=String('fun3'),
parameters=(),
body=CodeBlock(
Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53))), Return('b')))
assert res4[0] == FunctionPrototype(FloatBaseType(String('real')),
name=String('fun4'),
parameters=())
def test_sym_expr():
src1 = (src + """\
d = a + b -c
""")
expr3 = SymPyExpression(src, 'f')
expr4 = SymPyExpression(src1, 'f')
ls1 = expr3.return_expr()
ls2 = expr4.return_expr()
for i in range(0, 7):
assert isinstance(ls1[i], Declaration)
assert isinstance(ls2[i], Declaration)
assert isinstance(ls2[8], Assignment)
assert ls1[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls1[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls1[2] == Declaration(
Variable(Symbol('c'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls1[3] == Declaration(
Variable(Symbol('d'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls1[4] == Declaration(
Variable(Symbol('p'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls1[5] == Declaration(
Variable(Symbol('q'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls1[6] == Declaration(
Variable(Symbol('r'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls1[7] == Declaration(
Variable(Symbol('s'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls2[8] == Assignment(Variable(Symbol('d')),
Symbol('a') + Symbol('b') - Symbol('c'))
def transform_parm_decl(self, node):
"""Transformation function for Parameter Declaration
Used to create parameter nodes for the required functions for the
respective nodes in the clang AST
Returns
=======
param : Codegen AST Node
Variable node with the value nad type of the variable
Raises
======
ValueError if multiple children encountered in the parameter node
"""
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
value = Integer(0)
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
value = Float(0.0)
try:
children = node.get_children()
child = next(children)
# Any namespace nodes can be ignored
while child.kind in [cin.CursorKind.NAMESPACE_REF,
cin.CursorKind.TYPE_REF,
cin.CursorKind.TEMPLATE_REF]:
child = next(children)
# If there is a child, it is the default value of the parameter.
args = self.transform(child)
param = Variable(
node.spelling
).as_Declaration(
type = args[0],
value = args[1]
)
except StopIteration:
param = Variable(
node.spelling
).as_Declaration(
type = type,
value = value
)
try:
value = self.transform(next(children))
raise ValueError("Can't handle multiple children on parameter")
except StopIteration:
pass
return param
def test_fortran_parse():
expr = SymPyExpression(src, "f")
ls = expr.return_expr()
assert ls[0] == Declaration(
Variable(Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert ls[1] == Declaration(
Variable(Symbol("b"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert ls[2] == Declaration(
Variable(Symbol("c"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert ls[3] == Declaration(
Variable(Symbol("d"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert ls[4] == Declaration(
Variable(
Symbol("p"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert ls[5] == Declaration(
Variable(
Symbol("q"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert ls[6] == Declaration(
Variable(
Symbol("r"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert ls[7] == Declaration(
Variable(
Symbol("s"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
def test_float():
c_src1 = "float a = 1.0;"
c_src2 = "float a = 1.25;" + "\n" + "float b = 2.39;" + "\n"
c_src3 = "float x = 1, y = 2;"
c_src4 = "float p = 5, e = 7.89;"
res1 = SymPyExpression(c_src1, "c").return_expr()
res2 = SymPyExpression(c_src2, "c").return_expr()
res3 = SymPyExpression(c_src3, "c").return_expr()
res4 = SymPyExpression(c_src4, "c").return_expr()
assert res1[0] == Declaration(
Variable(
Symbol("a"),
type=FloatBaseType(String("real")),
value=Float("1.0", precision=53),
))
assert res2[0] == Declaration(
Variable(
Symbol("a"),
type=FloatBaseType(String("real")),
value=Float("1.25", precision=53),
))
assert res2[1] == Declaration(
Variable(
Symbol("b"),
type=FloatBaseType(String("real")),
value=Float("2.3900000000000001", precision=53),
))
assert res3[0] == Declaration(
Variable(
Symbol("x"),
type=FloatBaseType(String("real")),
value=Float("1.0", precision=53),
))
assert res3[1] == Declaration(
Variable(
Symbol("y"),
type=FloatBaseType(String("real")),
value=Float("2.0", precision=53),
))
assert res4[0] == Declaration(
Variable(
Symbol("p"),
type=FloatBaseType(String("real")),
value=Float("5.0", precision=53),
))
assert res4[1] == Declaration(
Variable(
Symbol("e"),
type=FloatBaseType(String("real")),
value=Float("7.89", precision=53),
))
def test_sym_expr():
src1 = (
src
+ """\
d = a + b -c
"""
)
expr3 = SymPyExpression(src, "f")
expr4 = SymPyExpression(src1, "f")
ls1 = expr3.return_expr()
ls2 = expr4.return_expr()
for i in range(0, 7):
assert isinstance(ls1[i], Declaration)
assert isinstance(ls2[i], Declaration)
assert isinstance(ls2[8], Assignment)
assert ls1[0] == Declaration(
Variable(Symbol("a"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls1[1] == Declaration(
Variable(Symbol("b"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls1[2] == Declaration(
Variable(Symbol("c"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls1[3] == Declaration(
Variable(Symbol("d"), type=IntBaseType(String("integer")), value=Integer(0))
)
assert ls1[4] == Declaration(
Variable(Symbol("p"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls1[5] == Declaration(
Variable(Symbol("q"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls1[6] == Declaration(
Variable(Symbol("r"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls1[7] == Declaration(
Variable(Symbol("s"), type=FloatBaseType(String("real")), value=Float(0.0))
)
assert ls2[8] == Assignment(
Variable(Symbol("d")), Symbol("a") + Symbol("b") - Symbol("c")
)
def test_variable():
c_src1 = ('int a;' + '\n' + 'int b;' + '\n')
c_src2 = ('float a;' + '\n' + 'float b;' + '\n')
c_src3 = ('int a;' + '\n' + 'float b;' + '\n' + 'int c;')
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
assert res1[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res1[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res2[0] == Declaration(
Variable(Symbol('a'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res2[1] == Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res3[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res3[1] == Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res3[2] == Declaration(
Variable(Symbol('c'),
type=IntBaseType(String('integer')),
value=Integer(0)))
def test_float():
c_src1 = 'float a = 1.0;'
c_src2 = ('float a = 1.25;' + '\n' + 'float b = 2.39;' + '\n')
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
assert res1[0] == Declaration(
Variable(Symbol('a'),
type=FloatBaseType(String('real')),
value=Float('1.0', precision=53)))
assert res2[0] == Declaration(
Variable(Symbol('a'),
type=FloatBaseType(String('real')),
value=Float('1.25', precision=53)))
assert res2[1] == Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('2.3900000000000001', precision=53)))
def test_var():
expr1.convert_to_expr(src, 'f')
ls = expr1.return_expr()
for iter in expr1.return_expr():
assert isinstance(iter, Declaration)
assert ls[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[2] == Declaration(
Variable(Symbol('c'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[3] == Declaration(
Variable(Symbol('d'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[4] == Declaration(
Variable(Symbol('p'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls[5] == Declaration(
Variable(Symbol('q'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls[6] == Declaration(
Variable(Symbol('r'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
assert ls[7] == Declaration(
Variable(Symbol('s'),
type=FloatBaseType(String('real')),
value=Float(0.0)))
def test_fortran_parse():
expr = SymPyExpression(src, 'f')
ls = expr.return_expr()
assert ls[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[2] == Declaration(
Variable(Symbol('c'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[3] == Declaration(
Variable(Symbol('d'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[4] == Declaration(
Variable(Symbol('p'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert ls[5] == Declaration(
Variable(Symbol('q'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert ls[6] == Declaration(
Variable(Symbol('r'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert ls[7] == Declaration(
Variable(Symbol('s'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
def test_c_parse():
src1 = """\
int a, b = 4;
float c, d = 2.4;
"""
expr1.convert_to_expr(src1, 'c')
ls = expr1.return_expr()
assert ls[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert ls[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('integer')),
value=Integer(4)))
assert ls[2] == Declaration(
Variable(Symbol('c'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert ls[3] == Declaration(
Variable(Symbol('d'),
type=FloatBaseType(String('real')),
value=Float('2.3999999999999999', precision=53)))
def visit_Function(self, node):
"""Visitor Function for function Definitions
Visits each function definition present in the ASR and creates a
function definition node in the Python AST with all the elements of the
given function
The functions declare all the variables required as SymPy symbols in
the function before the function definition
This function also the call_visior_function to parse the contents of
the function body
"""
# TODO: Return statement, variable declaration
fn_args = []
fn_body = []
fn_name = node.name
for arg_iter in node.args:
fn_args.append(Variable(arg_iter.name))
for i in node.body:
fn_ast = call_visitor(i)
try:
fn_body_expr = fn_ast
except UnboundLocalError:
fn_body_expr = []
for sym in node.symtab.symbols:
decl = call_visitor(node.symtab.symbols[sym])
for symbols in decl:
fn_body.append(symbols)
for elem in fn_body_expr:
fn_body.append(elem)
fn_body.append(Return(Variable(node.return_var.name)))
if isinstance(node.return_var.type, asr.Integer):
ret_type = IntBaseType(String('integer'))
elif isinstance(node.return_var.type, asr.Real):
ret_type = FloatBaseType(String('real'))
else:
raise NotImplementedError("Data type not supported")
new_node = FunctionDefinition(return_type=ret_type,
name=fn_name,
parameters=fn_args,
body=fn_body)
self._py_ast.append(new_node)
def test_float():
c_src1 = 'float a = 1.0;'
c_src2 = ('float a = 1.25;' + '\n' + 'float b = 2.39;' + '\n')
c_src3 = 'float x = 1, y = 2;'
c_src4 = 'float p = 5, e = 7.89;'
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
res4 = SymPyExpression(c_src4, 'c').return_expr()
assert res1[0] == Declaration(
Variable(Symbol('a'),
type=FloatBaseType(String('real')),
value=Float('1.0', precision=53)))
assert res2[0] == Declaration(
Variable(Symbol('a'),
type=FloatBaseType(String('real')),
value=Float('1.25', precision=53)))
assert res2[1] == Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('2.3900000000000001', precision=53)))
assert res3[0] == Declaration(
Variable(Symbol('x'),
type=FloatBaseType(String('real')),
value=Float('1.0', precision=53)))
assert res3[1] == Declaration(
Variable(Symbol('y'),
type=FloatBaseType(String('real')),
value=Float('2.0', precision=53)))
assert res4[0] == Declaration(
Variable(Symbol('p'),
type=FloatBaseType(String('real')),
value=Float('5.0', precision=53)))
assert res4[1] == Declaration(
Variable(Symbol('e'),
type=FloatBaseType(String('real')),
value=Float('7.89', precision=53)))
def test_variable():
c_src1 = "int a;" + "\n" + "int b;" + "\n"
c_src2 = "float a;" + "\n" + "float b;" + "\n"
c_src3 = "int a;" + "\n" + "float b;" + "\n" + "int c;"
c_src4 = "int x = 1, y = 6.78;" + "\n" + "float p = 2, q = 9.67;"
res1 = SymPyExpression(c_src1, "c").return_expr()
res2 = SymPyExpression(c_src2, "c").return_expr()
res3 = SymPyExpression(c_src3, "c").return_expr()
res4 = SymPyExpression(c_src4, "c").return_expr()
assert res1[0] == Declaration(
Variable(Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res1[1] == Declaration(
Variable(Symbol("b"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res2[0] == Declaration(
Variable(
Symbol("a"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert res2[1] == Declaration(
Variable(
Symbol("b"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert res3[0] == Declaration(
Variable(Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res3[1] == Declaration(
Variable(
Symbol("b"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert res3[2] == Declaration(
Variable(Symbol("c"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res4[0] == Declaration(
Variable(Symbol("x"),
type=IntBaseType(String("integer")),
value=Integer(1)))
assert res4[1] == Declaration(
Variable(Symbol("y"),
type=IntBaseType(String("integer")),
value=Integer(6)))
assert res4[2] == Declaration(
Variable(
Symbol("p"),
type=FloatBaseType(String("real")),
value=Float("2.0", precision=53),
))
assert res4[3] == Declaration(
Variable(
Symbol("q"),
type=FloatBaseType(String("real")),
value=Float("9.67", precision=53),
))
def transform_function_decl(self, node):
"""Transformation Function For Function Declaration
Used to create nodes for function declarations and definitions for
the respective nodes in the clang AST
Returns
=======
function : Codegen AST node
- FunctionPrototype node if function body is not present
- FunctionDefinition node if the function body is present
"""
token = node.get_tokens()
c_ret_type = next(token).spelling
if (c_ret_type == 'void'):
ret_type = none
elif (c_ret_type == 'int'):
ret_type = IntBaseType(String('integer'))
elif (c_ret_type == 'float'):
ret_type = FloatBaseType(String('real'))
else:
raise NotImplementedError("Variable not yet supported")
body = []
param = []
try:
children = node.get_children()
child = next(children)
# If the node has any children, the first children will be the
# return type and namespace for the function declaration. These
# nodes can be ignored.
while child.kind == cin.CursorKind.NAMESPACE_REF:
child = next(children)
while child.kind == cin.CursorKind.TYPE_REF:
child = next(children)
# Subsequent nodes will be the parameters for the function.
try:
while True:
decl = self.transform(child)
if (child.kind == cin.CursorKind.PARM_DECL):
param.append(decl)
elif (child.kind == cin.CursorKind.COMPOUND_STMT):
for val in decl:
body.append(val)
else:
body.append(decl)
child = next(children)
except StopIteration:
pass
except StopIteration:
pass
if body == []:
function = FunctionPrototype(return_type=ret_type,
name=node.spelling,
parameters=param)
else:
function = FunctionDefinition(return_type=ret_type,
name=node.spelling,
parameters=param,
body=body)
return function
def transform_var_decl(self, node):
"""Transformation Function for Variable Declaration
Used to create nodes for variable declarations and assignments with
values or function call for the respective nodes in the clang AST
Returns
=======
A variable node as Declaration, with the given value or 0 if the
value is not provided
Raises
======
NotImplementedError : if called for data types not currently
implemented
Notes
=====
This function currently only supports basic Integer and Float data
types
"""
try:
children = node.get_children()
child = next(children)
#ignoring namespace and type details for the variable
while child.kind == cin.CursorKind.NAMESPACE_REF:
child = next(children)
while child.kind == cin.CursorKind.TYPE_REF:
child = next(children)
val = self.transform(child)
# List in case of variable assignment, FunctionCall node in case of a funcion call
if (child.kind == cin.CursorKind.INTEGER_LITERAL
or child.kind == cin.CursorKind.UNEXPOSED_EXPR):
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
value = Integer(val)
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
value = Float(val)
else:
raise NotImplementedError()
return Variable(node.spelling).as_Declaration(type=type,
value=value)
elif (child.kind == cin.CursorKind.CALL_EXPR):
return Variable(node.spelling).as_Declaration(value=val)
else:
raise NotImplementedError()
except StopIteration:
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
value = Integer(0)
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
value = Float(0.0)
else:
raise NotImplementedError()
return Variable(node.spelling).as_Declaration(type=type,
value=value)
def test_parameters():
c_src1 = "void fun1( int a)" + "\n" + "{" + "\n" + "int i;" + "\n" + "}"
c_src2 = ("int fun2(float x, float y)" + "\n" + "{" + "\n" + "int a;" +
"\n" + "return a;" + "\n" + "}")
c_src3 = ("float fun3(int p, float q, int r)" + "\n" + "{" + "\n" +
"float b;" + "\n" + "return b;" + "\n" + "}")
res1 = SymPyExpression(c_src1, "c").return_expr()
res2 = SymPyExpression(c_src2, "c").return_expr()
res3 = SymPyExpression(c_src3, "c").return_expr()
assert res1[0] == FunctionDefinition(
NoneToken(),
name=String("fun1"),
parameters=(Variable(Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0)), ),
body=CodeBlock(
Declaration(
Variable(
Symbol("i"),
type=IntBaseType(String("integer")),
value=Integer(0),
))),
)
assert res2[0] == FunctionDefinition(
IntBaseType(String("integer")),
name=String("fun2"),
parameters=(
Variable(
Symbol("x"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
),
Variable(
Symbol("y"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
),
),
body=CodeBlock(
Declaration(
Variable(
Symbol("a"),
type=IntBaseType(String("integer")),
value=Integer(0),
)),
Return("a"),
),
)
assert res3[0] == FunctionDefinition(
FloatBaseType(String("real")),
name=String("fun3"),
parameters=(
Variable(Symbol("p"),
type=IntBaseType(String("integer")),
value=Integer(0)),
Variable(
Symbol("q"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
),
Variable(Symbol("r"),
type=IntBaseType(String("integer")),
value=Integer(0)),
),
body=CodeBlock(
Declaration(
Variable(
Symbol("b"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
)),
Return("b"),
),
)
def test_function_call():
c_src1 = "x = fun1(2);"
c_src2 = "y = fun2(2, 3, 4);"
c_src3 = "int p, q, r;" + "\n" + "z = fun3(p, q, r);"
c_src4 = "float x, y;" + "\n" + "int z;" + "\n" + "i = fun4(x, y, z)"
c_src5 = "a = fun()"
res1 = SymPyExpression(c_src1, "c").return_expr()
res2 = SymPyExpression(c_src2, "c").return_expr()
res3 = SymPyExpression(c_src3, "c").return_expr()
res4 = SymPyExpression(c_src4, "c").return_expr()
res5 = SymPyExpression(c_src5, "c").return_expr()
assert res1[0] == Declaration(
Variable(Symbol("x"),
value=FunctionCall(String("fun1"), function_args=([
2,
]))))
assert res2[0] == Declaration(
Variable(
Symbol("y"),
value=FunctionCall(String("fun2"), function_args=([2, 3, 4])),
))
assert res3[0] == Declaration(
Variable(Symbol("p"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res3[1] == Declaration(
Variable(Symbol("q"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res3[2] == Declaration(
Variable(Symbol("r"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res3[3] == Declaration(
Variable(
Symbol("z"),
value=FunctionCall(
String("fun3"),
function_args=([Symbol("p"),
Symbol("q"),
Symbol("r")]),
),
))
assert res4[0] == Declaration(
Variable(
Symbol("x"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert res4[1] == Declaration(
Variable(
Symbol("y"),
type=FloatBaseType(String("real")),
value=Float("0.0", precision=53),
))
assert res4[2] == Declaration(
Variable(Symbol("z"),
type=IntBaseType(String("integer")),
value=Integer(0)))
assert res4[3] == Declaration(
Variable(
Symbol("i"),
value=FunctionCall(
String("fun4"),
function_args=([Symbol("x"),
Symbol("y"),
Symbol("z")]),
),
))
assert res5[0] == Declaration(
Variable(Symbol("a"),
value=FunctionCall(String("fun"), function_args=())))
def transform_var_decl(self, node):
"""Transformation Function for Variable Declaration
Used to create nodes for variable declarations and assignments with
values or function call for the respective nodes in the clang AST
Returns
=======
A variable node as Declaration, with the given value or 0 if the
value is not provided
Raises
======
NotImplementedError : if called for data types not currently
implemented
Notes
=====
This function currently only supports basic Integer and Float data
types
"""
try:
children = node.get_children()
child = next(children)
#ignoring namespace and type details for the variable
while child.kind == cin.CursorKind.NAMESPACE_REF:
child = next(children)
while child.kind == cin.CursorKind.TYPE_REF:
child = next(children)
val = self.transform(child)
# List in case of variable assignment,
# FunctionCall node in case of a function call
if (child.kind == cin.CursorKind.INTEGER_LITERAL
or child.kind == cin.CursorKind.UNEXPOSED_EXPR):
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
# when only one decl_ref_expr is assigned
# e.g., int b = a;
if isinstance(val, str):
value = Symbol(val)
# e.g., int b = true;
elif isinstance(val, bool):
value = Integer(0) if val == False else Integer(1)
# when val is integer or character literal
# e.g., int b = 1; or int b = 'a';
elif isinstance(val, (Integer, int, Float, float)):
value = Integer(val)
# when val is combination of both of the above
# but in total only two nodes on rhs
# e.g., int b = a * 1;
else:
value = val
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
# e.g., float b = a;
if isinstance(val, str):
value = Symbol(val)
# e.g., float b = true;
elif isinstance(val, bool):
value = Float(0.0) if val == False else Float(1.0)
# e.g., float b = 1.0;
elif isinstance(val, (Integer, int, Float, float)):
value = Float(val)
# e.g., float b = a * 1.0;
else:
value = val
elif (node.type.kind == cin.TypeKind.BOOL):
type = Type(String('bool'))
# e.g., bool b = a;
if isinstance(val, str):
value = Symbol(val)
# e.g., bool b = 1;
elif isinstance(val, (Integer, int, Float, float)):
value = sympify(bool(val))
# e.g., bool b = a * 1;
else:
value = val
else:
raise NotImplementedError("Only bool, int " \
"and float are supported")
elif (child.kind == cin.CursorKind.CALL_EXPR):
return Variable(
node.spelling
).as_Declaration(
value = val
)
# when val is combination of more than two expr and
# integer(or float)
elif (child.kind == cin.CursorKind.BINARY_OPERATOR):
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
elif (node.type.kind == cin.TypeKind.BOOL):
type = Type(String('bool'))
else:
raise NotImplementedError("Only bool, int " \
"and float are supported")
value = val
elif (child.kind == cin.CursorKind.CXX_BOOL_LITERAL_EXPR):
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
value = Integer(val)
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
value = Float(val)
elif (node.type.kind == cin.TypeKind.BOOL):
type = Type(String('bool'))
value = sympify(val)
else:
raise NotImplementedError("Only bool, int " \
"and float are supported")
else:
raise NotImplementedError()
except StopIteration:
if (node.type.kind == cin.TypeKind.INT):
type = IntBaseType(String('integer'))
value = Integer(0)
elif (node.type.kind == cin.TypeKind.FLOAT):
type = FloatBaseType(String('real'))
value = Float(0.0)
elif (node.type.kind == cin.TypeKind.BOOL):
type = Type(String('bool'))
value = false
else:
raise NotImplementedError("Only bool, int " \
"and float are supported")
return Variable(
node.spelling
).as_Declaration(
type = type,
value = value
)
def test_variable():
c_src1 = ('int a;' + '\n' + 'int b;' + '\n')
c_src2 = ('float a;' + '\n' + 'float b;' + '\n')
c_src3 = ('int a;' + '\n' + 'float b;' + '\n' + 'int c;')
c_src4 = ('int x = 1, y = 6.78;' + '\n' + 'float p = 2, q = 9.67;')
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
res4 = SymPyExpression(c_src4, 'c').return_expr()
assert res1[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res1[1] == Declaration(
Variable(Symbol('b'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res2[0] == Declaration(
Variable(Symbol('a'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res2[1] == Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res3[0] == Declaration(
Variable(Symbol('a'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res3[1] == Declaration(
Variable(Symbol('b'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res3[2] == Declaration(
Variable(Symbol('c'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res4[0] == Declaration(
Variable(Symbol('x'),
type=IntBaseType(String('integer')),
value=Integer(1)))
assert res4[1] == Declaration(
Variable(Symbol('y'),
type=IntBaseType(String('integer')),
value=Integer(6)))
assert res4[2] == Declaration(
Variable(Symbol('p'),
type=FloatBaseType(String('real')),
value=Float('2.0', precision=53)))
assert res4[3] == Declaration(
Variable(Symbol('q'),
type=FloatBaseType(String('real')),
value=Float('9.67', precision=53)))
def test_function_call():
c_src1 = 'x = fun1(2);'
c_src2 = 'y = fun2(2, 3, 4);'
c_src3 = ('int p, q, r;' + '\n' + 'z = fun3(p, q, r);')
c_src4 = ('float x, y;' + '\n' + 'int z;' + '\n' + 'i = fun4(x, y, z)')
c_src5 = 'a = fun()'
res1 = SymPyExpression(c_src1, 'c').return_expr()
res2 = SymPyExpression(c_src2, 'c').return_expr()
res3 = SymPyExpression(c_src3, 'c').return_expr()
res4 = SymPyExpression(c_src4, 'c').return_expr()
res5 = SymPyExpression(c_src5, 'c').return_expr()
assert res1[0] == Declaration(
Variable(Symbol('x'),
value=FunctionCall(String('fun1'), function_args=([
2,
]))))
assert res2[0] == Declaration(
Variable(Symbol('y'),
value=FunctionCall(String('fun2'),
function_args=([2, 3, 4]))))
assert res3[0] == Declaration(
Variable(Symbol('p'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res3[1] == Declaration(
Variable(Symbol('q'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res3[2] == Declaration(
Variable(Symbol('r'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res3[3] == Declaration(
Variable(Symbol('z'),
value=FunctionCall(String('fun3'),
function_args=([
Symbol('p'),
Symbol('q'),
Symbol('r')
]))))
assert res4[0] == Declaration(
Variable(Symbol('x'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res4[1] == Declaration(
Variable(Symbol('y'),
type=FloatBaseType(String('real')),
value=Float('0.0', precision=53)))
assert res4[2] == Declaration(
Variable(Symbol('z'),
type=IntBaseType(String('integer')),
value=Integer(0)))
assert res4[3] == Declaration(
Variable(Symbol('i'),
value=FunctionCall(String('fun4'),
function_args=([
Symbol('x'),
Symbol('y'),
Symbol('z')
]))))
assert res5[0] == Declaration(
Variable(Symbol('a'),
value=FunctionCall(String('fun'), function_args=())))
