def total_print(self):
pre('main' in self.defns, 'entry point `main` undefined!')
ccode = indent(
main_template.replace('/*TYPE_DEFNS*/',
self.render_type_defns()).replace(
'/*FUNCTION_DECLS*/',
self.render_func_decls()).replace(
'/*FUNCTION_IMPLS*/',
self.render_func_impls()))
return ccode
def process_function(self, tree):
pre(tree.label == 'FUNCTION', 'unexpected tree label')
header, body = tree.relevant_kids()
ident, functype = header.relevant_kids()
arglist, out_type = functype.relevant_kids()
arg_types_by_nm = {}
arglist = list(arglist.relevant_kids())
while arglist:
judgement = arglist[0]
argident, argtype = judgement.relevant_kids()
arg_types_by_nm[argident.get_source()] = argtype.get_source()
arglist = arglist[1:]
if arglist:
arglist = list(arglist[0].relevant_kids())
return (ident.get_source(), arg_types_by_nm, out_type.get_source(),
body)
def translate_expr(self, tree, types_by_nm):
expansions = {'or': ' || ', 'and': ' && ', 'not': '!', '+': ' + '}
ccode = ''.join(((
lambda s: (expansions[s] if s in expansions else s)
)(k.strip())) if type(k) == str else ((
lambda ident:
('_{}'.format(ident) if ident in types_by_nm else '_{}'.format(
ident) if ident in self.globals else self.defns[ident]['cname']
if ident in self.defns and self.defns[ident]['kind'] == 'function'
else pre(
False, '`{}` not declared! (ctxt {})'.format(
ident, self.curr_ctxt())))
)(k.get_source())) if k.label == 'LOWER_IDENT' else (
(lambda ident: ('_make_{}'.format(ident) if ident in self.defns and
self.defns[ident]['alg'] == 'struct' else pre(
False, '`{}` not declared! (ctxt {})'.format(
ident, self.curr_ctxt())))
)(k.get_source())) if k.label == 'UPPER_IDENT' else (
self.translate_expr(k, types_by_nm)) for k in tree.kids)
#if tree.label == 'EQ_EXPR':
# ccode = '({})'.format(ccode)
return ccode
def final(self):
return (lambda text:
(lambda tree:
(pre(text.is_at_end(), 'failed to parse to end!:{}'.format(
text.context())), tree)[1])(self.parsers['MAIN'](text)))
def analyze_block(self, tree, types_by_nm={}):
''' assume no function defns within
'''
# copy:
types_by_nm = types_by_nm.copy()
node_stack = list(tree.relevant_kids())
while node_stack:
k, node_stack = node_stack[0], node_stack[1:]
if k.label == 'SKIP':
pass
elif k.label == 'ABORT':
self.write_code('ABORT;')
elif k.label == 'DECLARATION':
ident, typename = self.process_declaration(k)
pre(
ident not in types_by_nm and ident not in self.globals,
'variable {} already declared as {}!'.format(
ident, types_by_nm[ident]
if ident in types_by_nm else self.globals[ident]
if ident in self.globals else None))
types_by_nm[ident] = typename
self.write_code('{} _{};', typename, ident)
elif k.label == 'ASSIGNMENT':
lvalue, expr = self.process_assignment(k)
if lvalue.get_source().strip() == 'return':
self.write_code('return {};',
self.translate_expr(expr, types_by_nm))
else:
self.write_code('{} = {};',
self.translate_expr(lvalue, types_by_nm),
self.translate_expr(expr, types_by_nm))
elif k.label == 'MATCH':
expr, guardeds = k.relevant_kids()
expr_type = self.get_type(expr, types_by_nm)
pre(self.defns[expr_type]['alg'] == 'enum',
'can only match on sum types!')
alternatives = self.defns[expr_type]['child_fields']
temp_nm = self.fresh_var_nm()
cond_cons_pairs = self.process_guarded_sequence(guardeds)
self.write_code('{} {} = {};', expr_type, temp_nm,
self.translate_expr(expr, types_by_nm))
self.write_code('switch ({}.tag) {{', temp_nm)
for i, (cond, cons) in enumerate(cond_cons_pairs):
alt, name = cond.relevant_kids()
alt = alt.get_source()
name = name.get_source()
idx = alternatives.index(alt)
self.write_code('case {} /*{}*/ : {{', idx, alt)
self.write_code('{} _{} = {}.data.{};',
self.defns[expr_type]['child_types'][idx],
name, temp_nm, alt)
self.analyze_block(cons, types_by_nm)
self.write_code('}} break;')
self.write_code('}}')
elif k.label == 'IF':
guardeds, = k.relevant_kids()
cond_cons_pairs = self.process_guarded_sequence(guardeds)
pre(cond_cons_pairs,
'alternative constructs must have at least one branch')
for i, (cond, cons) in enumerate(cond_cons_pairs):
self.write_code(
'{} ({}) {{', 'if' if i == 0 else '} else if',
self.translate_expr(cond, types_by_nm).strip())
self.analyze_block(cons, types_by_nm)
self.write_code('}} else {{')
self.write_code('ABORT;')
self.write_code('}}')
elif k.label == 'DO':
cond_cons_pairs = self.process_guarded_sequence(k)
pre(cond_cons_pairs,
'repetitive constructs must have at least one branch')
self.write_code('while (true) {')
for i, (cond, cons) in enumerate(cond_cons_pairs):
self.write_code(
'{} ({}) {{', 'if' if i == 0 else '} else if',
self.translate_expr(cond, types_by_nm).strip())
self.analyze_block(cons, types_by_nm)
self.write_code('}} else {{')
self.write_code('break;')
self.write_code('}}')
self.write_code('}}')
elif k.label == 'TYPE_DEFN':
self.process_type_defn(k)
elif k.label == 'FUNCTION':
ident, arg_types_by_nm, out_type, body = self.process_function(
k)
print(CC + '@R creating ctxt {}...@D '.format(ident))
self.push_ctxt(ident)
self.make_defn('function',
ident=ident,
out_type=out_type,
arg_types_by_nm=arg_types_by_nm.copy())
self.analyze_block(body, arg_types_by_nm)
self.pop_ctxt()
elif k.label == 'PRINT':
ident, = k.relevant_kids()
ident = ident.get_source()
pre(
ident in types_by_nm,
'{} not declared! (print ctxt {})'.format(
ident, self.curr_ctxt()))
typename = types_by_nm[ident]
if typename == 'Float':
self.write_code('printf("{} \\t %f\\n", _{});', ident,
ident)
elif typename == 'Int':
self.write_code('printf("{} \\t %d\\n", _{});', ident,
ident)
elif typename == 'Bool':
self.write_code(
'printf("{} \\t %s\\n", _{}?"true":"false");', ident,
ident)
else:
pre(False, 'unknown typename!')
else:
node_stack = list(k.relevant_kids()) + node_stack
if self.ctxt_stack:
for nm in types_by_nm:
self.destroy(nm, types_by_nm[nm])
def process_assignment(self, tree):
pre(tree.label == 'ASSIGNMENT', 'unexpected tree label')
lvalue, expr = tree.relevant_kids()
return lvalue, expr
data1 = data1.cuda()
p = model(data1)
p = p.cpu()
s = p.data.numpy()
P[i] = s
print('P:' + str(Count))
print(np.max(P))
print(np.min(P))
P[P > 0.5] = 1
P[P <= 0.5] = 0
T.append(P)
pp = P.transpose(1, 2, 0)
dice1 = dice(pp, y1)
sen1 = sen(pp, y1)
spe1 = spe(pp, y1)
pre1 = pre(pp, y1)
TolD = TolD + dice1
TolS = TolS + sen1
TolP = TolP + spe1
TolR = TolR + pre1
print(dice1)
print(sen1)
print(spe1)
print(pre1)
print(TolD / Count)
print(TolS / Count)
print(TolP / Count)
print(TolR / Count)
print(s.shape)
plt.subplot(231)
plt.imshow(pp[:, :, f[2, 1] - 2], cmap=plt.get_cmap('gray'))