def test_to_type_with_cpp(self):
generator = c_generator.CGenerator()
test_fun = c_ast.FuncCall(c_ast.ID('test_fun'), c_ast.ExprList([]))
memmgr_path = self._find_file('memmgr.h')
ast2 = parse_file(memmgr_path, use_cpp=True)
void_ptr_type = ast2.ext[-3].type.type
void_type = void_ptr_type.type
self.assertEqual(generator.visit(c_ast.Cast(void_ptr_type, test_fun)),
'(void *) test_fun()')
self.assertEqual(generator.visit(c_ast.Cast(void_type, test_fun)),
'(void) test_fun()')
def test_to_type(self):
src = 'int *x;'
generator = c_generator.CGenerator()
test_fun = c_ast.FuncCall(c_ast.ID('test_fun'), c_ast.ExprList([]))
ast1 = parse_to_ast(src)
int_ptr_type = ast1.ext[0].type
int_type = int_ptr_type.type
self.assertEqual(generator.visit(c_ast.Cast(int_ptr_type, test_fun)),
'(int *) test_fun()')
self.assertEqual(generator.visit(c_ast.Cast(int_type, test_fun)),
'(int) test_fun()')
def pre_argument(self, name):
commands = []
commands.append(
_generate_decl(
name + '_int',
c_ast.TypeDecl(name + '_int', [],
c_ast.IdentifierType(['unsigned', 'int']))))
commands.append(_generate_read(name + '_int'))
commands.append(
c_ast.Assignment('|=', c_ast.ID(name + '_int'),
c_ast.Constant('int', PTR_OFFSET)))
commands.append(
c_ast.Decl(
name, [], [], [],
c_ast.PtrDecl(
[],
c_ast.TypeDecl(name, [], c_ast.IdentifierType(['void'])),
),
c_ast.Cast(
c_ast.Typename(
None, [],
c_ast.PtrDecl([],
c_ast.TypeDecl(
None, [],
c_ast.IdentifierType(['void'])))),
c_ast.ID(name + '_int')), []))
return commands
def createMain(self):
#Main Function
#Declaration
z1 = c_ast.TypeDecl('args',[],c_ast.IdentifierType(['int']))
args = c_ast.Decl('args',[],[],[],z1,None,None)
z2= c_ast.PtrDecl([],c_ast.TypeDecl('argv',[],c_ast.IdentifierType(['char'])))
z3=c_ast.ArrayDecl(z2,None,[])
argv = c_ast.Decl('argv',[],[],[],z3,None,None)
params=c_ast.ParamList([args,argv])
mainDec=c_ast.FuncDecl(params,c_ast.TypeDecl('main',[],c_ast.IdentifierType(['int'])))
# insertTest(functionName,varVals,varTypes)
#Body
##Signal
sigalrm=c_ast.ID(name="14")
funcCast=c_ast.TypeDecl(declname = None,quals=[],type=c_ast.IdentifierType(['void']))
paramCast=c_ast.ParamList([c_ast.Typename(name=None,quals=[],type=c_ast.TypeDecl(declname = None,quals=[],type=c_ast.IdentifierType(['int'])))])
typeFunc=c_ast.PtrDecl(type=c_ast.FuncDecl(paramCast,funcCast),quals=[])
kchild=c_ast.Cast(to_type=c_ast.Typename(name=None, quals=[],type=typeFunc),expr=c_ast.ID(name="kill_child"))
expressList = [sigalrm,kchild]
signalStmt=c_ast.FuncCall(c_ast.ID(name="signal"),c_ast.ExprList(expressList))
##Return
returnStmt=c_ast.Return(c_ast.Constant(type="int",value="0"))
comp=c_ast.Compound([signalStmt,returnStmt])
return c_ast.FuncDef(mainDec,None,comp)
def check_value(ast_tree, ext_index, bock_item_index, var_name, func_name):
Cast = c_ast.Cast(
c_ast.Typename(
None, [],
c_ast.PtrDecl([],
c_ast.TypeDecl(None, [],
c_ast.IdentifierType(['void'])))),
c_ast.ID(var_name))
func_call = c_ast.FuncCall(
c_ast.ID('check_value'),
c_ast.ExprList([
c_ast.UnaryOp('&', c_ast.ID('global_log')), Cast,
c_ast.Constant('string', '"' + var_name + '"'),
c_ast.Constant('string', '"' + func_name + '"'),
c_ast.Constant('int', str(len(var_name))),
c_ast.Constant('int', str(len(func_name)))
]))
new_node = c_ast.If(
c_ast.BinaryOp('==', func_call, c_ast.Constant('int', '0')),
c_ast.Compound([
c_ast.FuncCall(
c_ast.ID('printf'),
c_ast.ExprList([
c_ast.Constant('string', '"%s\\n"'),
c_ast.Constant('string', '"Attack Detected"')
])),
c_ast.FuncCall(c_ast.ID('exit'),
c_ast.ExprList([c_ast.Constant('int', '1')]))
]), None)
return merge_ast_tree(ast_tree, ext_index, bock_item_index, new_node,
"insert_before")
def __polybench_init(self, depth: int) -> c_ast.Node:
"""
Generates a polybench-style array element initialisation.
:param depth:
Example: A[i_0][i_1] = (double) (i_0 * i_1 + 1) / N;
"""
subs = self.__subs(depth)
left = self.__array_ref(subs)
right = \
c_ast.Cast(
self.dtype,
c_ast.BinaryOp('/',
c_ast.BinaryOp('+', exprs_prod(subs), c_ast.Constant('int', '1')),
self.sizes[0]
)
)
return c_ast.Assignment('=', left, right)
def __rand_init(self, depth: int) -> c_ast.Node:
"""
Generates a statement initialising an array element randomly.
:param depth:
Example:
A[i_0][i_1] = (double) rand();
"""
subs = self.__subs(depth)
left = self.__array_ref(subs)
right = \
c_ast.Cast(
self.dtype,
c_ast.FuncCall(
c_ast.ID('rand'),
c_ast.ExprList([])
)
)
return c_ast.Assignment('=', left, right)
def update_value(ast_tree, ext_index, bock_item_index, var_name, func_name,
var_size, func_size):
Cast = c_ast.Cast(
c_ast.Typename(
None, [],
c_ast.PtrDecl([],
c_ast.TypeDecl(None, [],
c_ast.IdentifierType(['void'])))),
c_ast.ID(var_name))
new_node = c_ast.FuncCall(
c_ast.ID('update_value'),
c_ast.ExprList([
c_ast.UnaryOp('&', c_ast.ID('global_log')), Cast,
c_ast.Constant('string', '"' + var_name + '"'),
c_ast.Constant('string', '"' + func_name + '"'),
c_ast.Constant('int', str(var_size)),
c_ast.Constant('int', str(func_size))
]))
return merge_ast_tree(ast_tree, ext_index, bock_item_index, new_node,
"insert_after")
def simple_cast(ty, expr, quals=[]):
return c_ast.Cast(c_ast.Typename(quals, ty), expr)
def callback(node: ca.Node, is_expr: bool) -> Optional[ca.Node]:
if node is expr:
typedecl = ca.TypeDecl(None, [], ca.IdentifierType(new_type))
return ca.Cast(ca.Typename(None, [], typedecl), expr)
return None
def MakeCast(identifier_type, node):
return c_ast.Cast(
c_ast.Typename(None, [], c_ast.TypeDecl(None, [], identifier_type)),
node)
