def create_subr_read_typedecl_in_module(self, node):
parent = node.kgen_parent
stmt = node.kgen_stmt
raw_entity_names = set([
uname.firstpartname()
for uname, req in KGGenType.get_state(stmt.geninfo)
])
entity_names = [
e for e in raw_entity_names
if not stmt.get_variable(e).is_parameter()
]
raw_out_entity_names = set([
uname.firstpartname()
for uname, req in KGGenType.get_state_out(stmt.geninfo)
])
out_entity_names = [
e for e in raw_out_entity_names
if not stmt.get_variable(e).is_parameter()
]
def get_attrs(attrspec, allowed_attrs):
attrspec = []
for attr in stmt.attrspec:
if any(
attr.startswith(allowed_attr)
for allowed_attr in allowed_attrs):
attrspec.append(attr)
return attrspec
def get_decls(names, decls, prefix=''):
import re
entity_decls = []
for decl in decls:
ename = re.split('\(|\*|=', decl)[0].strip()
if ename in names:
entity_decls.append(prefix + decl)
return entity_decls
if len(entity_names) == 0:
node.kgen_forced_line = False
elif len(entity_names) != len(stmt.entity_decls):
attrspec = get_attrs(
stmt.attrspec,
['pointer', 'allocatable', 'dimension', 'public', 'target'])
entity_decls = get_decls(entity_names, stmt.entity_decls)
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
if stmt.is_derived():
node.type_spec = 'TYPE'
else:
node.type_spec = stmt.__class__.__name__.upper()
node.attrspec = attrspec
node.selector = stmt.selector
node.entity_decls = entity_decls
node.kgen_use_tokgen = True
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
if len(out_entity_names) > 0:
attrspec = get_attrs(stmt.attrspec,
['pointer', 'allocatable', 'dimension'])
entity_decls = get_decls(out_entity_names,
stmt.entity_decls,
prefix='kgenref_')
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
part_append_genknode(node.kgen_parent,
DECL_PART,
stmt.__class__,
attrs=attrs)
is_class_derived = check_class_derived(stmt)
for entity_name, entity_decl in zip(entity_names, stmt.entity_decls):
if node.kgen_parent.name + entity_name in self.kernel_extern_reads:
continue
if is_remove_state(entity_name, stmt): continue
self.kernel_extern_reads.append(node.kgen_parent.name +
entity_name)
var = stmt.get_variable(entity_name)
subrname = get_typedecl_readname(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][1],
subrname,
entity_name,
stmt,
var,
prefix='kgenref_')
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, parent, var,
stmt)
self.kernel_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
self.create_read_intrinsic(
self.kernel_externs_subrs[node.kgen_parent][0],
entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_intrinsic(
self.kernel_externs_subrs[node.kgen_parent][1],
entity_name,
stmt,
var,
prefix='kgenref_')
else: # implicit array
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][1],
subrname,
entity_name,
stmt,
var,
prefix='kgenref_')
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, parent,
var, stmt)
self.kernel_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived:
if var.is_allocatable() or var.is_pointer():
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][1],
subrname,
entity_name,
stmt,
var,
prefix='kgenref_')
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, parent,
var, stmt)
self.kernel_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if (is_class_derived and uname.firstpartname()
== stmt.selector[1]
) or uname.firstpartname() == stmt.name:
#if uname.firstpartname()==stmt.name:
if len(req.res_stmts) > 0:
res = req.res_stmts[0]
subrname = get_dtype_readname(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
namedpart_append_comment(self.kernel_externs_subrs[node.kgen_parent][0], EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_read_call(
self.kernel_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(
self.kernel_externs_subrs[
node.kgen_parent][1],
subrname,
entity_name,
stmt,
var,
prefix='kgenref_')
else: # intrinsic type
self.create_read_intrinsic(
self.kernel_externs_subrs[node.kgen_parent][0],
entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_intrinsic(
self.kernel_externs_subrs[node.kgen_parent][1],
entity_name,
stmt,
var,
prefix='kgenref_')
def create_subr_write_typedecl_in_module(self, node):
parent = node.kgen_parent
stmt = node.kgen_stmt
raw_entity_names = set([
uname.firstpartname()
for uname, req in KGGenType.get_state(stmt.geninfo)
])
entity_names = [
e for e in raw_entity_names
if not stmt.get_variable(e).is_parameter()
]
raw_out_entity_names = set([
uname.firstpartname()
for uname, req in KGGenType.get_state_out(stmt.geninfo)
])
out_entity_names = [
e for e in raw_out_entity_names
if not stmt.get_variable(e).is_parameter()
]
#entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state(stmt.geninfo)])
#out_entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state_out(stmt.geninfo)])
is_class_derived = check_class_derived(stmt)
for entity_name, entity_decl in zip(entity_names, stmt.entity_decls):
if node.kgen_parent.name + entity_name in self.state_extern_writes:
continue
if is_remove_state(entity_name, stmt): continue
self.state_extern_writes.append(node.kgen_parent.name +
entity_name)
var = stmt.get_variable(entity_name)
subrname = get_typedecl_writename(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][1],
subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, parent, var,
stmt)
self.state_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
self.create_write_intrinsic(
self.state_externs_subrs[node.kgen_parent][0],
entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_intrinsic(
self.state_externs_subrs[node.kgen_parent][1],
entity_name, stmt, var)
else: # implicit array
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][1],
subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, parent,
var, stmt)
self.state_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived:
if var.is_allocatable() or var.is_pointer():
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][1],
subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, parent,
var, stmt)
self.state_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if (is_class_derived and uname.firstpartname()
== stmt.selector[1]
) or uname.firstpartname() == stmt.name:
#if uname.firstpartname()==stmt.name:
if len(req.res_stmts) > 0:
res = req.res_stmts[0]
subrname = get_dtype_writename(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
namedpart_append_comment(self.state_externs_subrs[node.kgen_parent][0], EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_write_call(
self.state_externs_subrs[node.kgen_parent][0],
subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(
self.state_externs_subrs[node.kgen_parent]
[1], subrname, entity_name, stmt, var)
else: # intrinsic type
self.create_write_intrinsic(
self.state_externs_subrs[node.kgen_parent][0],
entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_intrinsic(
self.state_externs_subrs[node.kgen_parent][1],
entity_name, stmt, var)
def create_write_subr(self, subrname, entity_name, parent, var, stmt):
checks = lambda n: isinstance(n.kgen_stmt, block_statements.Subroutine
) and n.name == subrname
if subrname not in self.state_created_subrs and not part_has_node(
parent, SUBP_PART, checks):
if is_remove_state(entity_name, stmt): return
self.state_created_subrs.append(subrname)
checks = lambda n: n.kgen_match_class == statements.Contains
if not parent in state_gencore_contains and not part_has_node(
parent, CONTAINS_PART, checks):
part_append_comment(parent, CONTAINS_PART, '')
part_append_gensnode(parent, CONTAINS_PART,
statements.Contains)
part_append_comment(parent, CONTAINS_PART, '')
state_gencore_contains.append(parent)
part_append_comment(parent, SUBP_PART,
'write state subroutine for %s' % subrname)
attrs = {
'name': subrname,
'args': ['var', 'kgen_unit', 'printvar']
}
subrobj = part_append_gensnode(parent,
SUBP_PART,
block_statements.Subroutine,
attrs=attrs)
part_append_comment(parent, SUBP_PART, '')
parent.kgen_stmt.top.used4genstate = True
# variable A
#import pdb; pdb.set_trace()
attrspec = ['INTENT(IN)']
if var.is_allocatable(): attrspec.append('ALLOCATABLE')
if var.is_pointer(): attrspec.append('POINTER')
if var.is_array():
attrspec.append('DIMENSION(%s)' % ','.join(':' * var.rank))
attrs = {
'type_spec': stmt.__class__.__name__.upper(),
'attrspec': attrspec,
'selector': stmt.selector,
'entity_decls': ['var']
}
part_append_gensnode(subrobj,
DECL_PART,
stmt.__class__,
attrs=attrs)
# kgen_unit
attrs = {
'type_spec': 'INTEGER',
'attrspec': ['INTENT(IN)'],
'entity_decls': ['kgen_unit']
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Integer,
attrs=attrs)
# printvar
attrs = {
'type_spec': 'CHARACTER',
'attrspec': ['INTENT(IN)', 'OPTIONAL'],
'selector': ('*', None),
'entity_decls': ['printvar']
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Character,
attrs=attrs)
# kgen_istrue
attrs = {'type_spec': 'LOGICAL', 'entity_decls': ['kgen_istrue']}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Logical,
attrs=attrs)
# array index A
if var.is_array():
attrs = {
'type_spec': 'INTEGER',
'entity_decls':
['idx%d' % (d + 1) for d in range(var.rank)]
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Integer,
attrs=attrs)
attrs = {
'type_spec': 'REAL',
'entity_decls': ['kgen_array_sum'],
'selector': (None, '8')
}
part_append_genknode(subrobj,
DECL_PART,
typedecl_statements.Real,
attrs=attrs)
part_append_comment(subrobj, DECL_PART, '')
pobj = gen_write_istrue(subrobj, var, 'var')
if var.is_array():
for dim in range(var.rank):
attrs = {
'items': ['LBOUND(var, %d)' % (dim + 1)],
'specs': ['UNIT = kgen_unit']
}
part_append_gensnode(pobj,
EXEC_PART,
statements.Write,
attrs=attrs)
attrs = {
'items': ['UBOUND(var, %d)' % (dim + 1)],
'specs': ['UNIT = kgen_unit']
}
part_append_gensnode(pobj,
EXEC_PART,
statements.Write,
attrs=attrs)
if stmt.is_derived():
indexes = ['idx%d' % (d + 1) for d in range(var.rank)]
str_indexes = ','.join(indexes)
#tostr_indexes = ','.join([ 'kgen_tostr(idx)' for idx in indexes])
prevobj = pobj
doobjs = []
for d in range(var.rank):
attrs = {
'loopcontrol':
'idx%(d)d=LBOUND(var,%(d)d), UBOUND(var,%(d)d)' % {
'd': d + 1
}
}
doobj = part_append_gensnode(prevobj,
EXEC_PART,
block_statements.Do,
attrs=attrs)
doobjs.append(doobj)
prevobj = doobj
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_gensnode(doobjs[-1],
EXEC_PART,
block_statements.IfThen,
attrs=attrs)
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname() == stmt.name and len(
req.res_stmts) > 0:
res = req.res_stmts[0]
callname = get_dtype_writename(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
part_append_comment(ifpvarobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
#attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', 'printvar // "(", %s, ")"'%tostr_indexes]}
attrs = {
'designator':
callname,
'items': [
'var(%s)' % str_indexes, 'kgen_unit',
'printvar // "(%s)"' % str_indexes
]
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Call,
attrs=attrs)
part_append_gensnode(ifpvarobj, EXEC_PART,
statements.Else)
if any(
match_namepath(pattern,
pack_exnamepath(
stmt, entity_name),
internal=False)
for pattern in getinfo('print_var_names')):
#attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', '"%s(", %s, ")"'%(entity_name, tostr_indexes)]}
attrs = {
'designator':
callname,
'items': [
'var(%s)' % str_indexes, 'kgen_unit',
'"%s(%s)"' % (entity_name, str_indexes)
]
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Call,
attrs=attrs)
else:
attrs = {
'designator': callname,
'items':
['var(%s)' % str_indexes, 'kgen_unit']
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Call,
attrs=attrs)
else: # intrinsic type
attrs = {'items': ['var'], 'specs': ['UNIT = kgen_unit']}
part_append_gensnode(pobj,
EXEC_PART,
statements.Write,
attrs=attrs)
if any(
match_namepath(pattern,
pack_exnamepath(stmt, entity_name),
internal=False)
for pattern in getinfo('print_var_names')):
if stmt.is_numeric() and var.is_array():
attrs = {
'items': [
'"** KGEN DEBUG: " // "REAL(SUM(%s), 8) **"'
% entity_name, 'REAL(SUM(var), 8)'
]
}
else:
attrs = {
'items': [
'"** KGEN DEBUG: " // "%s **" // NEW_LINE("A")'
% entity_name, 'var'
]
}
part_append_gensnode(pobj,
EXEC_PART,
statements.Write,
attrs=attrs)
else:
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_gensnode(
pobj,
EXEC_PART,
block_statements.IfThen,
attrs=attrs)
if stmt.is_numeric() and var.is_array():
attrs = {
'items': [
'"** KGEN DEBUG: REAL(SUM(" // printvar // "), 8) **"',
'REAL(SUM(var), 8)'
]
}
else:
attrs = {
'items': [
'"** KGEN DEBUG: " // printvar // " **" // NEW_LINE("A")',
'var'
]
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Write,
attrs=attrs)
else: # scalar
if stmt.is_derived():
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_gensnode(pobj,
EXEC_PART,
block_statements.IfThen,
attrs=attrs)
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname() == stmt.name and len(
req.res_stmts) > 0:
res = req.res_stmts[0]
callname = get_dtype_writename(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
part_append_comment(ifpvarobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
attrs = {
'designator':
callname,
'items': [
'var', 'kgen_unit',
'printvar // " %s "' % entity_name
]
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Call,
attrs=attrs)
part_append_gensnode(ifpvarobj, EXEC_PART,
statements.Else)
if any(
match_namepath(pattern,
pack_exnamepath(
stmt, entity_name),
internal=False)
for pattern in getinfo('print_var_names')):
attrs = {
'designator': callname,
'items':
['var', 'kgen_unit',
'"%s"' % entity_name]
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Call,
attrs=attrs)
else:
attrs = {
'designator': callname,
'items': ['var', 'kgen_unit']
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Call,
attrs=attrs)
else: # intrinsic type
attrs = {'items': ['var'], 'specs': ['UNIT = kgen_unit']}
part_append_gensnode(pobj,
EXEC_PART,
statements.Write,
attrs=attrs)
if any(
match_namepath(pattern,
pack_exnamepath(stmt, entity_name),
internal=False)
for pattern in getinfo('print_var_names')):
attrs = {
'items': [
'"** KGEN DEBUG: " // "%s **"' % entity_name,
'var'
]
}
part_append_gensnode(pobj,
EXEC_PART,
statements.Write,
attrs=attrs)
else:
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_gensnode(
pobj,
EXEC_PART,
block_statements.IfThen,
attrs=attrs)
attrs = {
'items':
['"** KGEN DEBUG: " // printvar // " **"', 'var']
}
part_append_gensnode(ifpvarobj,
EXEC_PART,
statements.Write,
attrs=attrs)
def create_dtype_write_subr(self, node):
assert node.kgen_stmt, 'None kgen statement'
subrname = get_dtype_writename(node.kgen_stmt)
if subrname is None: return
parent = node.kgen_parent
checks = lambda n: isinstance(n.kgen_stmt, block_statements.Subroutine
) and n.name == subrname
if not part_has_node(parent, SUBP_PART, checks):
checks = lambda n: n.kgen_match_class == statements.Contains
if not parent in state_gencore_contains and not part_has_node(
parent, CONTAINS_PART, checks):
part_append_comment(parent, CONTAINS_PART, '')
part_append_gensnode(parent, CONTAINS_PART,
statements.Contains)
part_append_comment(parent, CONTAINS_PART, '')
state_gencore_contains.append(parent)
part_append_comment(parent, SUBP_PART,
'read state subroutine for %s' % subrname)
attrs = {
'prefix': 'RECURSIVE',
'name': subrname,
'args': ['var', 'kgen_unit', 'printname', 'printvar']
}
subrobj = part_append_gensnode(parent,
SUBP_PART,
block_statements.Subroutine,
attrs=attrs)
part_append_comment(parent, SUBP_PART, '')
# variable
attrs = {
'type_spec': 'TYPE',
'attrspec': ['INTENT(IN)'],
'selector': (None, node.name),
'entity_decls': ['var']
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Type,
attrs=attrs)
# kgen_unit
attrs = {
'type_spec': 'INTEGER',
'attrspec': ['INTENT(IN)'],
'entity_decls': ['kgen_unit']
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Integer,
attrs=attrs)
# printname
attrs = {
'type_spec': 'CHARACTER',
'attrspec': ['INTENT(IN)'],
'selector': ('*', None),
'entity_decls': ['printname']
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Character,
attrs=attrs)
# printvar
attrs = {
'type_spec': 'LOGICAL',
'attrspec': ['INTENT(IN)', 'OPTIONAL'],
'selector': (None, None),
'entity_decls': ['printvar']
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Character,
attrs=attrs)
# kgen_istrue
attrs = {'type_spec': 'LOGICAL', 'entity_decls': ['kgen_istrue']}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Logical,
attrs=attrs)
attrs = {
'type_spec': 'REAL',
'entity_decls': ['kgen_array_sum'],
'selector': (None, '8')
}
part_append_gensnode(subrobj,
DECL_PART,
typedecl_statements.Real,
attrs=attrs)
part_append_comment(subrobj, DECL_PART, '')
parent_names = []
getinfo('traverse')(node.kgen_stmt.f2003, self.get_extends,
parent_names)
extends = []
for parent_typename in parent_names:
for uname, req in node.kgen_stmt.unknowns.iteritems():
if uname.firstpartname() == parent_typename:
if len(req.res_stmts) > 0:
extends.extend(
get_part(req.res_stmts[0].genspair, TYPE_PART))
break
comp_part = get_part(node, TYPE_PART)
for item in extends + comp_part:
if not hasattr(item, 'kgen_stmt'): continue
if not isinstance(
item.kgen_stmt,
typedecl_statements.TypeDeclarationStatement):
continue
stmt = item.kgen_stmt
entity_names = [
get_entity_name(decl) for decl in stmt.entity_decls
]
for entity_name, entity_decl in zip(entity_names,
stmt.entity_decls):
if is_remove_state(entity_name, stmt): continue
node.kgen_stmt.top.used4genstate = True
var = stmt.get_variable(entity_name)
callname = get_typedecl_writename(stmt, entity_name)
if var.is_array():
if stmt.is_derived():
self.create_write_call(subrobj, callname,
entity_name, stmt, var)
else: # intrinsic type
if var.is_explicit_shape_array():
self.create_write_intrinsic(
subrobj, entity_name, stmt, var)
callname = None
else: # implicit array
self.create_write_call(subrobj, callname,
entity_name, stmt, var)
else: # scalar
if stmt.is_derived():
if var.is_allocatable() or var.is_pointer():
self.create_write_call(subrobj, callname,
entity_name, stmt, var)
else:
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname(
) == stmt.name and len(req.res_stmts) > 0:
res = req.res_stmts[0]
callname = get_dtype_writename(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
part_append_comment(subrobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statement to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_write_call(
subrobj, callname, entity_name, stmt,
var)
else: # intrinsic type
self.create_write_intrinsic(
subrobj, entity_name, stmt, var)
callname = None
if node.kgen_stmt.ancestors(
)[0] != item.kgen_stmt.ancestors()[0] and callname:
# add use
pnode = node.kgen_parent
checks = lambda n: n.kgen_match_class==statements.Use and n.kgen_stmt and n.kgen_stmt.isonly and \
callname in n.kgen_stmt.items
if (
id(pnode), callname
) not in self.state_created_use_items and not part_has_node(
pnode, USE_PART, checks):
attrs = {
'name': item.kgen_stmt.ancestors()[0].name,
'isonly': True,
'items': [callname]
}
part_append_gensnode(pnode,
USE_PART,
statements.Use,
attrs=attrs)
self.state_created_use_items.append(
(id(pnode), callname))
pnode.kgen_stmt.top.used4genstate = True
part_append_comment(subrobj, EXEC_PART, '')
# create public stmt
if parent.kgen_match_class in [
block_statements.Program, block_statements.Module
]:
attrs = {'items': [subrname]}
part_append_gensnode(parent,
DECL_PART,
statements.Public,
attrs=attrs)
def create_subr_write_typedecl_in_parentblock(self, node):
stmt = node.kgen_stmt
argintype = []
localintype = []
localouttype = []
for uname, req in KGGenType.get_state_in(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if self.check_intent(entity_name, stmt):
if (entity_name, STATE_PBLOCK_WRITE_IN_ARGS) not in argintype:
argintype.append((entity_name, STATE_PBLOCK_WRITE_IN_ARGS))
elif (entity_name,
STATE_PBLOCK_WRITE_IN_LOCALS) not in localintype and (
entity_name,
STATE_PBLOCK_WRITE_IN_ARGS) not in argintype:
localintype.append(
(uname.firstpartname(), STATE_PBLOCK_WRITE_IN_LOCALS))
for uname, req in KGGenType.get_state_out(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if (entity_name,
STATE_PBLOCK_WRITE_OUT_LOCALS) not in localouttype:
localouttype.append(
(uname.firstpartname(), STATE_PBLOCK_WRITE_OUT_LOCALS))
if (entity_name, STATE_PBLOCK_WRITE_IN_ARGS) in argintype: continue
if (entity_name, STATE_PBLOCK_WRITE_IN_LOCALS) not in localintype:
localintype.append(
(uname.firstpartname(), STATE_PBLOCK_WRITE_IN_LOCALS))
vartypes = {
'argintype': argintype,
'localintype': localintype,
'localouttype': localouttype
}
# for state
is_class_derived = check_class_derived(stmt)
for vartypename, vartype in vartypes.iteritems():
for entity_name, partid in vartype:
var = stmt.get_variable(entity_name)
subrname = get_typedecl_writename(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_write_call(node.kgen_kernel_id, partid,
subrname, entity_name, stmt,
var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name,
node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
if vartypename == 'argintype' or var.is_pointer():
self.create_write_call(node.kgen_kernel_id,
partid, subrname,
entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name,
node.kgen_parent, var,
stmt)
self.state_created_subrs.append(subrname)
else:
self.create_write_intrinsic(
node.kgen_kernel_id, partid, entity_name,
stmt, var)
else: # implicit array
self.create_write_call(node.kgen_kernel_id, partid,
subrname, entity_name, stmt,
var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name,
node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived or var.is_pointer(
):
if var.is_allocatable() or var.is_pointer(
) or var.is_pointer():
self.create_write_call(node.kgen_kernel_id, partid,
subrname, entity_name, stmt,
var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name,
node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname() == stmt.name and len(
req.res_stmts) > 0:
res = req.res_stmts[0]
subrname = get_dtype_writename(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
namedpart_append_comment(node.kgen_kernel_id, partid, \
'ERROR: "%s" is not resolved. Call statements to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_write_call(node.kgen_kernel_id,
partid, subrname,
entity_name, stmt, var)
else: # intrinsic type
self.create_write_intrinsic(node.kgen_kernel_id,
partid, entity_name, stmt,
var)
def create_read_subr(self, subrname, entity_name, parent, var, stmt, allocate=False):
checks = lambda n: isinstance(n.kgen_stmt, block_statements.Subroutine) and n.name==subrname
if subrname not in self.kernel_created_subrs and not part_has_node(parent, SUBP_PART, checks):
if is_remove_state(entity_name, stmt): return
self.kernel_created_subrs.append(subrname)
checks = lambda n: n.kgen_isvalid and n.kgen_match_class==statements.Contains
if not parent in kernel_gencore_contains and not part_has_node(parent, CONTAINS_PART, checks):
part_append_comment(parent, CONTAINS_PART, '')
part_append_genknode(parent, CONTAINS_PART, statements.Contains)
part_append_comment(parent, CONTAINS_PART, '')
kernel_gencore_contains.append(parent)
part_append_comment(parent, SUBP_PART, 'write state subroutine for %s'%subrname)
attrs = {'name': subrname, 'args': ['var', 'kgen_unit', 'printname', 'printvar']}
subrobj = part_append_genknode(parent, SUBP_PART, block_statements.Subroutine, attrs=attrs)
part_append_comment(parent, SUBP_PART, '')
# variable A
#import pdb; pdb.set_trace()
attrspec = ['INTENT(INOUT)']
if var.is_allocatable() or allocate: attrspec.append('ALLOCATABLE')
if var.is_pointer(): attrspec.append('POINTER')
if var.is_array(): attrspec.append('DIMENSION(%s)'% ','.join(':'*var.rank))
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, 'selector':stmt.selector, 'entity_decls': ['var']}
part_append_genknode(subrobj, DECL_PART, stmt.__class__, attrs=attrs)
# kgen_unit
attrs = {'type_spec': 'INTEGER', 'attrspec': ['INTENT(IN)'], 'entity_decls': ['kgen_unit']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
# printname
attrs = {'type_spec': 'CHARACTER', 'attrspec': ['INTENT(IN)'], 'selector':('*', None), 'entity_decls': ['printname']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Character, attrs=attrs)
# printvar
attrs = {'type_spec': 'LOGICAL', 'attrspec': ['INTENT(IN)', 'OPTIONAL'], 'selector':(None, None), 'entity_decls': ['printvar']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Character, attrs=attrs)
# kgen_istrue
attrs = {'type_spec': 'LOGICAL', 'entity_decls': ['kgen_istrue']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Logical, attrs=attrs)
attrs = {'type_spec': 'REAL', 'entity_decls': ['kgen_array_sum'], 'selector': (None, '8')}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Real, attrs=attrs)
# array index A
if var.is_array():
attrs = {'type_spec': 'INTEGER', 'entity_decls': [ 'idx%d'%(d+1) for d in range(var.rank) ]}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
attrs = {'type_spec': 'INTEGER', 'attrspec': ['DIMENSION(2,%d)'%var.rank], 'entity_decls': [ 'kgen_bound' ]}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
part_append_comment(subrobj, DECL_PART, '')
pobj = gen_read_istrue(subrobj, var, 'var')
part_append_comment(subrobj, EXEC_PART, '')
if var.is_array():
bound_args = []
for dim in range(var.rank):
attrs = {'items': ['kgen_bound(1, %d)'%(dim+1)], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
attrs = {'items': ['kgen_bound(2, %d)'%(dim+1)], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
#bound_args.append('kgen_bound(2,%d)-kgen_bound(1,%d)+1'%(dim+1, dim+1))
bound_args.append('kgen_bound(1,%d):kgen_bound(2,%d)'%(dim+1, dim+1))
if var.is_allocatable() or var.is_pointer() or allocate:
attrs = {'items': ['var(%s)'%', '.join(bound_args)]}
part_append_genknode(pobj, EXEC_PART, statements.Allocate, attrs=attrs)
if stmt.is_derived():
indexes = [ 'idx%d'%(d+1) for d in range(var.rank) ]
str_indexes = ','.join(indexes)
#tostr_indexes = ','.join([ 'kgen_tostr(idx)' for idx in indexes])
prevobj = pobj
doobjs = []
for d in range(var.rank):
attrs = {'loopcontrol': 'idx%(d)d=kgen_bound(1,%(d)d), kgen_bound(2,%(d)d)'%{'d':d+1}}
doobj = part_append_genknode(prevobj, EXEC_PART, block_statements.Do, attrs=attrs)
doobjs.append(doobj)
prevobj = doobj
attrs = {'expr': 'PRESENT( printvar ) .AND. printvar'}
ifpvarobj = part_append_genknode(doobjs[-1], EXEC_PART, block_statements.IfThen, attrs=attrs)
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
callname = get_dtype_readname(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
part_append_comment(ifpvarobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', 'printname // "(%s)"'%str_indexes, '.TRUE.']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
part_append_genknode(ifpvarobj, EXEC_PART, statements.Else)
pstr = '.TRUE.' if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')) else '.FALSE.'
attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', 'printname // "(%s)"'%str_indexes, pstr]}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
else: # intrinsic type
attrs = {'items': ['var'], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
if stmt.is_numeric():
attrs = {'designator': 'kgen_array_sumcheck', 'items': ['printname', 'kgen_array_sum', 'DBLE(SUM(var, mask=(var .eq. var)))', '.TRUE.']}
part_append_genknode(pobj, EXEC_PART, statements.Call, attrs=attrs)
attrs = {'expr': 'PRESENT( printvar ) .AND. printvar'}
ifpvarobj = part_append_genknode(pobj, EXEC_PART, block_statements.IfThen, attrs=attrs)
if stmt.is_numeric():
attrs = {'items': ['"KGEN DEBUG: DBLE(SUM(" // printname // ")) = "', 'DBLE(SUM(var, mask=(var .eq. var)))']}
else:
attrs = {'items': ['"KGEN DEBUG: " // printname // " = "', 'var']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Write, attrs=attrs)
if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')):
part_append_genknode(ifpvarobj, EXEC_PART, statements.Else)
if stmt.is_numeric():
attrs = {'items': ['"KGEN DEBUG: DBLE(SUM(" // printname // ")) = "', 'DBLE(SUM(var, mask=(var .eq. var)))']}
else:
attrs = {'items': ['"KGEN DEBUG: " // printname // " = "', 'var']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Write, attrs=attrs)
else: # scalar
if var.is_allocatable() or var.is_pointer() or allocate:
attrs = {'items': ['var']}
part_append_genknode(pobj, EXEC_PART, statements.Allocate, attrs=attrs)
if stmt.is_derived():
attrs = {'expr': 'PRESENT( printvar ) .AND. printvar'}
ifpvarobj = part_append_genknode(pobj, EXEC_PART, block_statements.IfThen, attrs=attrs)
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
callname = get_dtype_readname(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
part_append_comment(ifpvarobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
attrs = {'designator': callname, 'items': ['var', 'kgen_unit', 'printname', '.TRUE.']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
part_append_genknode(ifpvarobj, EXEC_PART, statements.Else)
pstr = '.TRUE.' if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')) else '.FALSE.'
attrs = {'designator': callname, 'items': ['var', 'kgen_unit', 'printname', pstr]}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
else: # intrinsic type
attrs = {'items': ['var'], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
attrs = {'expr': 'PRESENT( printvar ) .AND. printvar'}
ifpvarobj = part_append_genknode(pobj, EXEC_PART, block_statements.IfThen, attrs=attrs)
attrs = {'items': ['"KGEN DEBUG: " // printname // " = "', 'var']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Write, attrs=attrs)
if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')):
part_append_genknode(ifpvarobj, EXEC_PART, statements.Else)
attrs = {'items': ['"KGEN DEBUG: " // printname // " = "', 'var']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Write, attrs=attrs)
def create_subr_write_typedecl_in_parentblock(self, node):
stmt = node.kgen_stmt
argintype = []
localintype = []
localouttype = []
for uname, req in KGGenType.get_state_in(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if self.check_intent(entity_name, stmt):
if (entity_name,STATE_PBLOCK_WRITE_IN_ARGS) not in argintype:
argintype.append((entity_name, STATE_PBLOCK_WRITE_IN_ARGS))
elif (entity_name,STATE_PBLOCK_WRITE_IN_LOCALS) not in localintype and (entity_name,STATE_PBLOCK_WRITE_IN_ARGS) not in argintype:
localintype.append((uname.firstpartname(), STATE_PBLOCK_WRITE_IN_LOCALS))
for uname, req in KGGenType.get_state_out(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if (entity_name,STATE_PBLOCK_WRITE_OUT_LOCALS) not in localouttype:
localouttype.append((uname.firstpartname(), STATE_PBLOCK_WRITE_OUT_LOCALS))
if (entity_name,STATE_PBLOCK_WRITE_IN_ARGS) in argintype: continue
if (entity_name,STATE_PBLOCK_WRITE_IN_LOCALS) not in localintype:
localintype.append((uname.firstpartname(), STATE_PBLOCK_WRITE_IN_LOCALS))
vartypes = { 'argintype': argintype, 'localintype': localintype, 'localouttype': localouttype }
# for state
is_class_derived = check_class_derived(stmt)
for vartypename, vartype in vartypes.iteritems():
for entity_name, partid in vartype:
var = stmt.get_variable(entity_name)
subrname = get_typedecl_writename(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_write_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
if vartypename=='argintype' or var.is_pointer():
self.create_write_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else:
self.create_write_intrinsic(node.kgen_kernel_id, partid, entity_name, stmt, var)
else: # implicit array
self.create_write_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived or var.is_pointer():
if var.is_allocatable() or var.is_pointer() or var.is_pointer():
self.create_write_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, node.kgen_parent, var, stmt)
self.state_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
subrname = get_dtype_writename(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
namedpart_append_comment(node.kgen_kernel_id, partid, \
'ERROR: "%s" is not resolved. Call statements to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_write_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
else: # intrinsic type
self.create_write_intrinsic(node.kgen_kernel_id, partid, entity_name, stmt, var)
def create_subr_read_typedecl_in_parentblock(self, node):
stmt = node.kgen_stmt
argintype = []
localintype = []
localouttype = []
for uname, req in KGGenType.get_state_in(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if self.check_intent(entity_name, stmt):
if (entity_name, DRIVER_READ_IN_ARGS) not in argintype:
argintype.append((entity_name, DRIVER_READ_IN_ARGS))
if not entity_name in getinfo(
'kernel_driver_callsite_args'):
getinfo('kernel_driver_callsite_args').append(
entity_name)
# add typedecl in driver
attrs = {
'type_spec': stmt.__class__.__name__.upper(),
'selector': stmt.selector,
'entity_decls': [entity_name]
}
attrspec = []
if var.is_array():
attrspec.append('DIMENSION(%s)' %
','.join(':' * var.rank))
if not var.is_pointer(): attrspec.append('ALLOCATABLE')
# deallocate
if var.is_pointer(): attrspec.append('POINTER')
attrs['attrspec'] = attrspec
namedpart_append_genknode(node.kgen_kernel_id,
DRIVER_DECL_PART,
stmt.__class__,
attrs=attrs)
if hasattr(stmt, 'unknowns'):
for uname, req in stmt.unknowns.iteritems():
if len(req.res_stmts) > 0:
if req.res_stmts[
-1].__class__ == statements.Use:
checks = lambda n: n.kgen_match_class==statements.Use and n.kgen_stmt and n.kgen_stmt.name==req.res_stmts[-1].name \
and ( n.kgen_stmt.isonly and uname.firstpartname() in [ item.split('=>')[0].strip() for item in n.kgen_stmt.items])
if not namedpart_has_node(
node.kgen_kernel_id,
DRIVER_USE_PART, checks):
item_name = uname.firstpartname()
for new_name, old_name in req.res_stmts[
-1].renames:
if new_name == item_name:
item_name = '%s => %s' % (
new_name, old_name)
break
if not (req.res_stmts[-1].name,
item_name
) in self.driver_created_uses:
attrs = {
'name': req.res_stmts[-1].name,
'isonly': True,
'items': [item_name]
}
namedpart_append_genknode(
node.kgen_kernel_id,
DRIVER_USE_PART,
statements.Use,
attrs=attrs)
self.driver_created_uses.append(
(req.res_stmts[-1].name,
item_name))
if stmt.is_derived(
) and stmt.name == uname.firstpartname(
):
readname = get_dtype_readname(
req.res_stmts[0])
if not (
req.res_stmts[-1].name,
readname
) in self.driver_created_uses:
attrs = {
'name':
req.res_stmts[-1].name,
'isonly': True,
'items': [readname]
}
namedpart_append_genknode(
node.kgen_kernel_id,
DRIVER_USE_PART,
statements.Use,
attrs=attrs)
self.driver_created_uses.append(
(req.res_stmts[-1].name,
readname))
else:
if req.res_stmts[
0].genkpair.kgen_parent != node.kgen_parent:
checks = lambda n: n.kgen_match_class==statements.Use and n.kgen_stmt and n.kgen_stmt.name==get_topname(req.res_stmts[-1]) and \
( n.kgen_stmt.isonly and uname.firstpartname() in [ item.split('=>')[0].strip() for item in n.kgen_stmt.items])
if not namedpart_has_node(
node.kgen_kernel_id,
DRIVER_USE_PART, checks):
item_name = uname.firstpartname()
for new_name, old_name in req.res_stmts[
-1].renames:
if new_name == item_name:
item_name = '%s => %s' % (
new_name, old_name)
break
if not (
get_topname(
req.res_stmts[-1]),
item_name
) in self.driver_created_uses:
attrs = {
'name':
get_topname(
req.res_stmts[-1]),
'isonly':
True,
'items': [item_name]
}
namedpart_append_genknode(
node.kgen_kernel_id,
DRIVER_USE_PART,
statements.Use,
attrs=attrs)
self.driver_created_uses.append(
(get_topname(
req.res_stmts[-1]),
item_name))
if stmt.is_derived(
) and stmt.name == uname.firstpartname(
):
readname = get_dtype_readname(
req.res_stmts[-1])
if not (
get_topname(
req.res_stmts[-1]),
readname
) in self.driver_created_uses:
attrs = {
'name':
get_topname(
req.res_stmts[-1]),
'isonly':
True,
'items': [readname]
}
namedpart_append_genknode(
node.kgen_kernel_id,
DRIVER_USE_PART,
statements.Use,
attrs=attrs)
self.driver_created_uses.append(
(get_topname(
req.res_stmts[-1]),
readname))
elif (entity_name,
KERNEL_PBLOCK_READ_IN_LOCALS) not in localintype and (
entity_name, DRIVER_READ_IN_ARGS) not in argintype:
localintype.append(
(uname.firstpartname(), KERNEL_PBLOCK_READ_IN_LOCALS))
for uname, req in KGGenType.get_state_out(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if (entity_name,
KERNEL_PBLOCK_READ_OUT_LOCALS) not in localouttype:
localouttype.append(
(uname.firstpartname(), KERNEL_PBLOCK_READ_OUT_LOCALS))
if (entity_name, DRIVER_READ_IN_ARGS) in argintype: continue
if (entity_name, KERNEL_PBLOCK_READ_IN_LOCALS) not in localintype:
localintype.append(
(uname.firstpartname(), KERNEL_PBLOCK_READ_IN_LOCALS))
localvartypes = {
'localintype': localintype,
'localouttype': localouttype
}
def get_attrs(attrspec, allowed_attrs):
attrspec = []
for attr in stmt.attrspec:
if any(
attr.startswith(allowed_attr)
for allowed_attr in allowed_attrs):
attrspec.append(attr)
return attrspec
def get_decls(names, decls, prefix=''):
import re
entity_decls = []
for decl in decls:
ename = re.split('\(|\*|=', decl)[0].strip()
if ename in names:
entity_decls.append(prefix + decl)
return entity_decls
def get_enames(names, decls, prefix=''):
import re
entity_enames = []
for decl in decls:
ename = re.split('\(|\*|=', decl)[0].strip()
if ename in names:
entity_enames.append(prefix + ename)
return entity_enames
if len(argintype) > 0:
attrspec = get_attrs(
stmt.attrspec,
['pointer', 'allocatable', 'dimension', 'target'])
attrspec.append('INTENT(INOUT)')
argin_names = [argin_name for argin_name, pname in argintype]
entity_decls = get_decls(argin_names, stmt.entity_decls)
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
if stmt.is_derived():
node.type_spec = 'TYPE'
else:
node.type_spec = stmt.__class__.__name__.upper()
node.attrspec = attrspec
node.selector = stmt.selector
node.entity_decls = entity_decls
node.kgen_use_tokgen = True
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
if len(localintype) == 0 and len(argintype) == 0 and len(
localouttype) == 0:
node.kgen_forced_line = False
elif len(localintype) > 0:
attrspec = get_attrs(
stmt.attrspec,
['pointer', 'allocatable', 'dimension', 'target'])
localin_names = [
localin_name for localin_name, pname in localintype
]
entity_decls = get_decls(localin_names, stmt.entity_decls)
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
if stmt.is_derived():
node.type_spec = 'TYPE'
else:
node.type_spec = stmt.__class__.__name__.upper()
node.attrspec = attrspec
node.selector = stmt.selector
node.entity_decls = entity_decls
node.kgen_use_tokgen = True
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
local_allocate = False
if len(localouttype) > 0:
for localout_name, partid in localouttype:
attrspec = get_attrs(stmt.attrspec, ['pointer', 'allocatable'])
var = stmt.get_variable(localout_name)
if var.is_array():
if var.is_explicit_shape_array():
attrspec.append('dimension(%s)' % ','.join([
':'.join(slice) for slice in var.get_array_spec()
]))
else:
attrspec.append('dimension(%s)' %
','.join([':'] * var.rank))
if 'allocatable' not in attrspec and 'pointer' not in attrspec:
local_allocate = True
attrspec.append('allocatable')
#localout_names = [ localout_name for localout_name, pname in localouttype]
#entity_decls = get_decls(localout_names, stmt.entity_decls, prefix='kgenref_')
#entity_enames = get_enames(localout_names, stmt.entity_decls, prefix='kgenref_')
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': [ 'kgenref_%s'%localout_name ]}
#'selector':stmt.selector, 'entity_decls': entity_decls}
part_append_genknode(node.kgen_parent,
DECL_PART,
stmt.__class__,
attrs=attrs)
# for kernel - local variables
is_class_derived = check_class_derived(stmt)
for vartypename, vartype in localvartypes.iteritems():
for entity_name, partid in vartype:
if vartypename == 'localouttype': ename_prefix = 'kgenref_'
else: ename_prefix = ''
var = stmt.get_variable(entity_name)
subrname = get_typedecl_readname(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_read_call(node.kgen_kernel_id,
partid,
subrname,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname,
entity_name,
node.kgen_parent,
var,
stmt,
ename_prefix=ename_prefix,
allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
if var.is_pointer():
self.create_read_call(
node.kgen_kernel_id,
partid,
subrname,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname,
entity_name,
node.kgen_parent,
var,
stmt,
ename_prefix=ename_prefix,
allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else:
self.create_read_intrinsic(
node.kgen_kernel_id,
partid,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
else: # implicit array
self.create_read_call(node.kgen_kernel_id,
partid,
subrname,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname,
entity_name,
node.kgen_parent,
var,
stmt,
ename_prefix=ename_prefix,
allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived or var.is_pointer(
):
if var.is_allocatable() or var.is_pointer():
self.create_read_call(node.kgen_kernel_id,
partid,
subrname,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname,
entity_name,
node.kgen_parent,
var,
stmt,
ename_prefix=ename_prefix,
allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname() == stmt.name and len(
req.res_stmts) > 0:
res = req.res_stmts[0]
subrname = get_dtype_readname(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
namedpart_append_comment(node.kgen_kernel_id, partid, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_read_call(
node.kgen_kernel_id,
partid,
subrname,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
else: # intrinsic type
self.create_read_intrinsic(node.kgen_kernel_id,
partid,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
# for kernel - argument variables
for entity_name, partid in argintype:
var = stmt.get_variable(entity_name)
subrname = get_typedecl_readname(stmt, entity_name)
if var.is_array():
self.create_read_call(node.kgen_kernel_id, partid, subrname,
entity_name, stmt, var)
if subrname not in self.driver_created_subrs:
create_read_subr(subrname,
entity_name,
shared_objects['driver_object'],
var,
stmt,
allocate=True)
self.driver_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived or var.is_pointer():
if var.is_allocatable() or var.is_pointer():
self.create_read_call(node.kgen_kernel_id,
partid,
subrname,
entity_name,
stmt,
var,
ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname,
entity_name,
node.kgen_parent,
var,
stmt,
ename_prefix=ename_prefix)
self.kernel_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname() == stmt.name and len(
req.res_stmts) > 0:
res = req.res_stmts[0]
subrname = get_dtype_readname(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s' % stmt.name
namedpart_append_comment(node.kgen_kernel_id, partid, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_read_call(node.kgen_kernel_id, partid,
subrname, entity_name, stmt,
var)
else: # intrinsic type
self.create_read_intrinsic(node.kgen_kernel_id, partid,
entity_name, stmt, var)
def create_subr_read_typedecl_in_parentblock(self, node):
stmt = node.kgen_stmt
argintype = []
localintype = []
localouttype = []
for uname, req in KGGenType.get_state_in(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if self.check_intent(entity_name, stmt):
if (entity_name,DRIVER_READ_IN_ARGS) not in argintype:
argintype.append((entity_name, DRIVER_READ_IN_ARGS))
if not entity_name in getinfo('kernel_driver_callsite_args'):
getinfo('kernel_driver_callsite_args').append(entity_name)
# add typedecl in driver
attrs={'type_spec':stmt.__class__.__name__.upper(), 'selector':stmt.selector, 'entity_decls': [entity_name]}
attrspec = []
if var.is_array():
attrspec.append('DIMENSION(%s)'%','.join(':'*var.rank))
if not var.is_pointer(): attrspec.append('ALLOCATABLE')
# deallocate
if var.is_pointer(): attrspec.append('POINTER')
attrs['attrspec'] = attrspec
namedpart_append_genknode(node.kgen_kernel_id, DRIVER_DECL_PART, stmt.__class__, attrs=attrs)
if hasattr(stmt, 'unknowns'):
for uname, req in stmt.unknowns.iteritems():
if len(req.res_stmts)>0:
if req.res_stmts[-1].__class__==statements.Use:
checks = lambda n: n.kgen_match_class==statements.Use and n.kgen_stmt and n.kgen_stmt.name==req.res_stmts[-1].name \
and ( n.kgen_stmt.isonly and uname.firstpartname() in [ item.split('=>')[0].strip() for item in n.kgen_stmt.items])
if not namedpart_has_node(node.kgen_kernel_id, DRIVER_USE_PART, checks):
item_name = uname.firstpartname()
for new_name, old_name in req.res_stmts[-1].renames:
if new_name==item_name:
item_name = '%s => %s'%(new_name, old_name)
break
if not (req.res_stmts[-1].name, item_name) in self.driver_created_uses:
attrs = {'name':req.res_stmts[-1].name, 'isonly': True, 'items':[item_name]}
namedpart_append_genknode(node.kgen_kernel_id, DRIVER_USE_PART, statements.Use, attrs=attrs)
self.driver_created_uses.append((req.res_stmts[-1].name, item_name))
if stmt.is_derived() and stmt.name==uname.firstpartname():
readname = get_dtype_readname(req.res_stmts[0])
if not (req.res_stmts[-1].name, readname) in self.driver_created_uses:
attrs = {'name':req.res_stmts[-1].name, 'isonly': True, 'items':[readname]}
namedpart_append_genknode(node.kgen_kernel_id, DRIVER_USE_PART, statements.Use, attrs=attrs)
self.driver_created_uses.append((req.res_stmts[-1].name, readname))
else:
if req.res_stmts[0].genkpair.kgen_parent!=node.kgen_parent:
checks = lambda n: n.kgen_match_class==statements.Use and n.kgen_stmt and n.kgen_stmt.name==get_topname(req.res_stmts[-1]) and \
( n.kgen_stmt.isonly and uname.firstpartname() in [ item.split('=>')[0].strip() for item in n.kgen_stmt.items])
if not namedpart_has_node(node.kgen_kernel_id, DRIVER_USE_PART, checks):
item_name = uname.firstpartname()
for new_name, old_name in req.res_stmts[-1].renames:
if new_name==item_name:
item_name = '%s => %s'%(new_name, old_name)
break
if not (get_topname(req.res_stmts[-1]), item_name) in self.driver_created_uses:
attrs = {'name':get_topname(req.res_stmts[-1]), 'isonly': True, 'items':[item_name]}
namedpart_append_genknode(node.kgen_kernel_id, DRIVER_USE_PART, statements.Use, attrs=attrs)
self.driver_created_uses.append((get_topname(req.res_stmts[-1]), item_name))
if stmt.is_derived() and stmt.name==uname.firstpartname():
readname = get_dtype_readname(req.res_stmts[-1])
if not (get_topname(req.res_stmts[-1]), readname) in self.driver_created_uses:
attrs = {'name':get_topname(req.res_stmts[-1]), 'isonly': True, 'items':[readname]}
namedpart_append_genknode(node.kgen_kernel_id, DRIVER_USE_PART, statements.Use, attrs=attrs)
self.driver_created_uses.append((get_topname(req.res_stmts[-1]), readname))
elif (entity_name,KERNEL_PBLOCK_READ_IN_LOCALS) not in localintype and (entity_name,DRIVER_READ_IN_ARGS) not in argintype:
localintype.append((uname.firstpartname(), KERNEL_PBLOCK_READ_IN_LOCALS))
for uname, req in KGGenType.get_state_out(stmt.geninfo):
entity_name = uname.firstpartname()
var = stmt.get_variable(entity_name)
if var.is_parameter(): continue
if is_remove_state(entity_name, stmt): continue
if (entity_name,KERNEL_PBLOCK_READ_OUT_LOCALS) not in localouttype:
localouttype.append((uname.firstpartname(), KERNEL_PBLOCK_READ_OUT_LOCALS))
if (entity_name,DRIVER_READ_IN_ARGS) in argintype: continue
if (entity_name,KERNEL_PBLOCK_READ_IN_LOCALS) not in localintype:
localintype.append((uname.firstpartname(), KERNEL_PBLOCK_READ_IN_LOCALS))
localvartypes = { 'localintype': localintype, 'localouttype': localouttype }
def get_attrs(attrspec, allowed_attrs):
attrspec = []
for attr in stmt.attrspec:
if any( attr.startswith(allowed_attr) for allowed_attr in allowed_attrs):
attrspec.append(attr)
return attrspec
def get_decls(names, decls, prefix=''):
import re
entity_decls = []
for decl in decls:
ename = re.split('\(|\*|=', decl)[0].strip()
if ename in names:
entity_decls.append(prefix+decl)
return entity_decls
def get_enames(names, decls, prefix=''):
import re
entity_enames = []
for decl in decls:
ename = re.split('\(|\*|=', decl)[0].strip()
if ename in names:
entity_enames.append(prefix+ename)
return entity_enames
if len(argintype)>0:
attrspec = get_attrs(stmt.attrspec, ['pointer', 'allocatable', 'dimension', 'target'])
attrspec.append('INTENT(INOUT)')
argin_names = [ argin_name for argin_name, pname in argintype]
entity_decls = get_decls(argin_names, stmt.entity_decls)
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
if stmt.is_derived():
node.type_spec = 'TYPE'
else:
node.type_spec = stmt.__class__.__name__.upper()
node.attrspec = attrspec
node.selector = stmt.selector
node.entity_decls = entity_decls
node.kgen_use_tokgen = True
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
if len(localintype)==0 and len(argintype)==0 and len(localouttype)==0:
node.kgen_forced_line = False
elif len(localintype)>0:
attrspec = get_attrs(stmt.attrspec, ['pointer', 'allocatable', 'dimension', 'target'])
localin_names = [ localin_name for localin_name, pname in localintype]
entity_decls = get_decls(localin_names, stmt.entity_decls)
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
if stmt.is_derived():
node.type_spec = 'TYPE'
else:
node.type_spec = stmt.__class__.__name__.upper()
node.attrspec = attrspec
node.selector = stmt.selector
node.entity_decls = entity_decls
node.kgen_use_tokgen = True
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
local_allocate = False
if len(localouttype)>0:
for localout_name, partid in localouttype:
attrspec = get_attrs(stmt.attrspec, ['pointer', 'allocatable'])
var = stmt.get_variable(localout_name)
if var.is_array():
if var.is_explicit_shape_array():
attrspec.append('dimension(%s)'%','.join(var.shape))
else:
attrspec.append('dimension(%s)'%','.join([':']*var.rank))
if 'allocatable' not in attrspec and 'pointer' not in attrspec:
local_allocate = True
attrspec.append('allocatable')
#localout_names = [ localout_name for localout_name, pname in localouttype]
#entity_decls = get_decls(localout_names, stmt.entity_decls, prefix='kgenref_')
#entity_enames = get_enames(localout_names, stmt.entity_decls, prefix='kgenref_')
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': [ 'kgenref_%s'%localout_name ]}
#'selector':stmt.selector, 'entity_decls': entity_decls}
part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
# for kernel - local variables
is_class_derived = check_class_derived(stmt)
for vartypename, vartype in localvartypes.iteritems():
for entity_name, partid in vartype:
if vartypename=='localouttype': ename_prefix = 'kgenref_'
else: ename_prefix = ''
var = stmt.get_variable(entity_name)
subrname = get_typedecl_readname(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var, ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, node.kgen_parent, var, stmt, ename_prefix=ename_prefix, allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
if var.is_pointer():
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var, ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, node.kgen_parent, var, stmt, ename_prefix=ename_prefix, allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else:
self.create_read_intrinsic(node.kgen_kernel_id, partid, entity_name, stmt, var, ename_prefix=ename_prefix)
else: # implicit array
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var, ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, node.kgen_parent, var, stmt, ename_prefix=ename_prefix, allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived or var.is_pointer():
if var.is_allocatable() or var.is_pointer():
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var, ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, node.kgen_parent, var, stmt, ename_prefix=ename_prefix, allocate=local_allocate)
self.kernel_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
subrname = get_dtype_readname(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
namedpart_append_comment(node.kgen_kernel_id, partid, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var, ename_prefix=ename_prefix)
else: # intrinsic type
self.create_read_intrinsic(node.kgen_kernel_id, partid, entity_name, stmt, var, ename_prefix=ename_prefix)
# for kernel - argument variables
for entity_name, partid in argintype:
var = stmt.get_variable(entity_name)
subrname = get_typedecl_readname(stmt, entity_name)
if var.is_array():
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
if subrname not in self.driver_created_subrs:
create_read_subr(subrname, entity_name, shared_objects['driver_object'], var, stmt, allocate=True)
self.driver_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived or var.is_pointer():
if var.is_allocatable() or var.is_pointer():
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var, ename_prefix=ename_prefix)
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, node.kgen_parent, var, stmt, ename_prefix=ename_prefix)
self.kernel_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
subrname = get_dtype_readname(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
namedpart_append_comment(node.kgen_kernel_id, partid, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_read_call(node.kgen_kernel_id, partid, subrname, entity_name, stmt, var)
else: # intrinsic type
self.create_read_intrinsic(node.kgen_kernel_id, partid, entity_name, stmt, var)
def create_read_subr(self, subrname, entity_name, parent, var, stmt, allocate=False):
checks = lambda n: isinstance(n.kgen_stmt, block_statements.Subroutine) and n.name==subrname
if subrname not in self.kernel_created_subrs and not part_has_node(parent, SUBP_PART, checks):
if is_remove_state(entity_name, stmt): return
self.kernel_created_subrs.append(subrname)
checks = lambda n: n.kgen_isvalid and n.kgen_match_class==statements.Contains
if not parent in kernel_gencore_contains and not part_has_node(parent, CONTAINS_PART, checks):
part_append_comment(parent, CONTAINS_PART, '')
part_append_genknode(parent, CONTAINS_PART, statements.Contains)
part_append_comment(parent, CONTAINS_PART, '')
kernel_gencore_contains.append(parent)
part_append_comment(parent, SUBP_PART, 'write state subroutine for %s'%subrname)
attrs = {'name': subrname, 'args': ['var', 'kgen_unit', 'printvar']}
subrobj = part_append_genknode(parent, SUBP_PART, block_statements.Subroutine, attrs=attrs)
part_append_comment(parent, SUBP_PART, '')
# variable A
#import pdb; pdb.set_trace()
attrspec = ['INTENT(INOUT)']
if var.is_allocatable() or allocate: attrspec.append('ALLOCATABLE')
if var.is_pointer(): attrspec.append('POINTER')
if var.is_array(): attrspec.append('DIMENSION(%s)'% ','.join(':'*var.rank))
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, 'selector':stmt.selector, 'entity_decls': ['var']}
part_append_genknode(subrobj, DECL_PART, stmt.__class__, attrs=attrs)
# kgen_unit
attrs = {'type_spec': 'INTEGER', 'attrspec': ['INTENT(IN)'], 'entity_decls': ['kgen_unit']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
# printvar
attrs = {'type_spec': 'CHARACTER', 'attrspec': ['INTENT(IN)', 'OPTIONAL'], 'selector':('*', None), 'entity_decls': ['printvar']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Character, attrs=attrs)
# kgen_istrue
attrs = {'type_spec': 'LOGICAL', 'entity_decls': ['kgen_istrue']}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Logical, attrs=attrs)
attrs = {'type_spec': 'REAL', 'entity_decls': ['kgen_array_sum'], 'selector': (None, '8')}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Real, attrs=attrs)
# array index A
if var.is_array():
attrs = {'type_spec': 'INTEGER', 'entity_decls': [ 'idx%d'%(d+1) for d in range(var.rank) ]}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
attrs = {'type_spec': 'INTEGER', 'attrspec': ['DIMENSION(2,%d)'%var.rank], 'entity_decls': [ 'kgen_bound' ]}
part_append_genknode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
part_append_comment(subrobj, DECL_PART, '')
pobj = gen_read_istrue(subrobj, var, 'var')
part_append_comment(subrobj, EXEC_PART, '')
if var.is_array():
bound_args = []
for dim in range(var.rank):
attrs = {'items': ['kgen_bound(1, %d)'%(dim+1)], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
attrs = {'items': ['kgen_bound(2, %d)'%(dim+1)], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
#bound_args.append('kgen_bound(2,%d)-kgen_bound(1,%d)+1'%(dim+1, dim+1))
bound_args.append('kgen_bound(1,%d):kgen_bound(2,%d)'%(dim+1, dim+1))
if var.is_allocatable() or var.is_pointer() or allocate:
attrs = {'items': ['var(%s)'%', '.join(bound_args)]}
part_append_genknode(pobj, EXEC_PART, statements.Allocate, attrs=attrs)
if stmt.is_derived():
indexes = [ 'idx%d'%(d+1) for d in range(var.rank) ]
str_indexes = ','.join(indexes)
#tostr_indexes = ','.join([ 'kgen_tostr(idx)' for idx in indexes])
prevobj = pobj
doobjs = []
for d in range(var.rank):
attrs = {'loopcontrol': 'idx%(d)d=kgen_bound(1,%(d)d), kgen_bound(2,%(d)d)'%{'d':d+1}}
doobj = part_append_genknode(prevobj, EXEC_PART, block_statements.Do, attrs=attrs)
doobjs.append(doobj)
prevobj = doobj
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_genknode(doobjs[-1], EXEC_PART, block_statements.IfThen, attrs=attrs)
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
callname = get_dtype_readname(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
part_append_comment(ifpvarobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
#attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', 'printvar // "(", %s, ")"'%tostr_indexes]}
attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', 'printvar // "(%s)"'%str_indexes]}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
part_append_genknode(ifpvarobj, EXEC_PART, statements.Else)
if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')):
#attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', '"%s(", %s, ")"'%(entity_name, tostr_indexes)]}
attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit', '"%s(%s)"'%(entity_name, str_indexes)]}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
else:
attrs = {'designator': callname, 'items': ['var(%s)'%str_indexes, 'kgen_unit']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
else: # intrinsic type
attrs = {'items': ['var'], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
if stmt.is_numeric():
if isinstance(stmt, typedecl_statements.Real):
attrs = {'designator': 'kgen_array_sumcheck', 'items': ['"%s"'%entity_name, 'kgen_array_sum', 'REAL(SUM(var, mask=(var .eq. var)), 8)', '.TRUE.']}
else:
attrs = {'designator': 'kgen_array_sumcheck', 'items': ['"%s"'%entity_name, 'kgen_array_sum', 'REAL(SUM(var), 8)', '.TRUE.']}
part_append_genknode(pobj, EXEC_PART, statements.Call, attrs=attrs)
if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')):
if stmt.is_numeric() and var.is_array():
attrs = {'items': ['"** KGEN DEBUG: " // "REAL(SUM(%s), 8) **"'%entity_name, 'REAL(SUM(var), 8)']}
else:
attrs = {'items': ['"** KGEN DEBUG: " // "%s **" // NEW_LINE("A")'%entity_name, 'var']}
part_append_genknode(pobj, EXEC_PART, statements.Write, attrs=attrs)
else:
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_genknode(pobj, EXEC_PART, block_statements.IfThen, attrs=attrs)
if stmt.is_numeric() and var.is_array():
attrs = {'items': ['"** KGEN DEBUG: REAL(SUM(" // printvar // "), 8) **"', 'REAL(SUM(var), 8)']}
else:
attrs = {'items': ['"** KGEN DEBUG: " // printvar // " **" // NEW_LINE("A")', 'var']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Write, attrs=attrs)
else: # scalar
if var.is_allocatable() or var.is_pointer() or allocate:
attrs = {'items': ['var']}
part_append_genknode(pobj, EXEC_PART, statements.Allocate, attrs=attrs)
if stmt.is_derived():
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_genknode(pobj, EXEC_PART, block_statements.IfThen, attrs=attrs)
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
callname = get_dtype_readname(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
part_append_comment(ifpvarobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
attrs = {'designator': callname, 'items': ['var', 'kgen_unit', 'printvar // " %s "'%entity_name]}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
part_append_genknode(ifpvarobj, EXEC_PART, statements.Else)
if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')):
attrs = {'designator': callname, 'items': ['var', 'kgen_unit', '"%s"'%entity_name]}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
else:
attrs = {'designator': callname, 'items': ['var', 'kgen_unit']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Call, attrs=attrs)
else: # intrinsic type
attrs = {'items': ['var'], 'specs': ['UNIT = kgen_unit']}
part_append_genknode(pobj, EXEC_PART, statements.Read, attrs=attrs)
if any(match_namepath(pattern, pack_exnamepath(stmt, entity_name), internal=False) for pattern in getinfo('print_var_names')):
attrs = {'items': ['"** KGEN DEBUG: " // "%s **" // NEW_LINE("A")'%entity_name, 'var']}
part_append_genknode(pobj, EXEC_PART, statements.Write, attrs=attrs)
else:
attrs = {'expr': 'PRESENT( printvar )'}
ifpvarobj = part_append_genknode(pobj, EXEC_PART, block_statements.IfThen, attrs=attrs)
attrs = {'items': ['"** KGEN DEBUG: " // printvar // " **" // NEW_LINE("A")', 'var']}
part_append_genknode(ifpvarobj, EXEC_PART, statements.Write, attrs=attrs)
def create_subr_write_typedecl_in_module(self, node):
parent = node.kgen_parent
stmt = node.kgen_stmt
raw_entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state(stmt.geninfo)])
entity_names = [ e for e in raw_entity_names if not stmt.get_variable(e).is_parameter() ]
raw_out_entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state_out(stmt.geninfo)])
out_entity_names = [ e for e in raw_out_entity_names if not stmt.get_variable(e).is_parameter() ]
#entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state(stmt.geninfo)])
#out_entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state_out(stmt.geninfo)])
is_class_derived = check_class_derived(stmt)
for entity_name, entity_decl in zip(entity_names, stmt.entity_decls):
if node.kgen_parent.name+entity_name in self.state_extern_writes: continue
if is_remove_state(entity_name, stmt): continue
self.state_extern_writes.append(node.kgen_parent.name+entity_name)
var = stmt.get_variable(entity_name)
subrname = get_typedecl_writename(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_write_call(self.state_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(self.state_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, parent, var, stmt)
self.state_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
self.create_write_intrinsic(self.state_externs_subrs[node.kgen_parent][0], entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_intrinsic(self.state_externs_subrs[node.kgen_parent][1], entity_name, stmt, var)
else: # implicit array
self.create_write_call(self.state_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(self.state_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, parent, var, stmt)
self.state_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived:
if var.is_allocatable() or var.is_pointer():
self.create_write_call(self.state_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(self.state_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var)
if subrname not in self.state_created_subrs:
create_write_subr(subrname, entity_name, parent, var, stmt)
self.state_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if ( is_class_derived and uname.firstpartname()==stmt.selector[1]) or uname.firstpartname()==stmt.name:
#if uname.firstpartname()==stmt.name:
if len(req.res_stmts)>0:
res = req.res_stmts[0]
subrname = get_dtype_writename(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
namedpart_append_comment(self.state_externs_subrs[node.kgen_parent][0], EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_write_call(self.state_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_call(self.state_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var)
else: # intrinsic type
self.create_write_intrinsic(self.state_externs_subrs[node.kgen_parent][0], entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_write_intrinsic(self.state_externs_subrs[node.kgen_parent][1], entity_name, stmt, var)
def create_subr_read_typedecl_in_module(self, node):
parent = node.kgen_parent
stmt = node.kgen_stmt
raw_entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state(stmt.geninfo)])
entity_names = [ e for e in raw_entity_names if not stmt.get_variable(e).is_parameter() ]
raw_out_entity_names = set([ uname.firstpartname() for uname, req in KGGenType.get_state_out(stmt.geninfo)])
out_entity_names = [ e for e in raw_out_entity_names if not stmt.get_variable(e).is_parameter() ]
def get_attrs(attrspec, allowed_attrs):
attrspec = []
for attr in stmt.attrspec:
if any( attr.startswith(allowed_attr) for allowed_attr in allowed_attrs):
attrspec.append(attr)
return attrspec
def get_decls(names, decls, prefix=''):
import re
entity_decls = []
for decl in decls:
ename = re.split('\(|\*|=', decl)[0].strip()
if ename in names:
entity_decls.append(prefix+decl)
return entity_decls
if len(entity_names)==0:
node.kgen_forced_line = False
elif len(entity_names)!=len(stmt.entity_decls):
attrspec = get_attrs(stmt.attrspec, ['pointer', 'allocatable', 'dimension', 'public', 'target'])
entity_decls = get_decls(entity_names, stmt.entity_decls)
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
if stmt.is_derived():
node.type_spec = 'TYPE'
else:
node.type_spec = stmt.__class__.__name__.upper()
node.attrspec = attrspec
node.selector = stmt.selector
node.entity_decls = entity_decls
node.kgen_use_tokgen = True
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
#part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
if len(out_entity_names)>0:
attrspec = get_attrs(stmt.attrspec, ['pointer', 'allocatable', 'dimension'])
entity_decls = get_decls(out_entity_names, stmt.entity_decls, prefix='kgenref_')
attrs = {'type_spec': stmt.__class__.__name__.upper(), 'attrspec': attrspec, \
'selector':stmt.selector, 'entity_decls': entity_decls}
part_append_genknode(node.kgen_parent, DECL_PART, stmt.__class__, attrs=attrs)
is_class_derived = check_class_derived(stmt)
for entity_name, entity_decl in zip(entity_names, stmt.entity_decls):
if node.kgen_parent.name+entity_name in self.kernel_extern_reads: continue
if is_remove_state(entity_name, stmt): continue
self.kernel_extern_reads.append(node.kgen_parent.name+entity_name)
var = stmt.get_variable(entity_name)
subrname = get_typedecl_readname(stmt, entity_name)
if var.is_array():
if is_zero_array(var, stmt): continue
if stmt.is_derived() or is_class_derived:
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var, prefix='kgenref_')
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, parent, var, stmt)
self.kernel_created_subrs.append(subrname)
else: # intrinsic type
if var.is_explicit_shape_array():
self.create_read_intrinsic(self.kernel_externs_subrs[node.kgen_parent][0], entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_intrinsic(self.kernel_externs_subrs[node.kgen_parent][1], entity_name, stmt, var, prefix='kgenref_')
else: # implicit array
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var, prefix='kgenref_')
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, parent, var, stmt)
self.kernel_created_subrs.append(subrname)
else: # scalar
if stmt.is_derived() or is_class_derived:
if var.is_allocatable() or var.is_pointer():
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var, prefix='kgenref_')
if subrname not in self.kernel_created_subrs:
create_read_subr(subrname, entity_name, parent, var, stmt)
self.kernel_created_subrs.append(subrname)
else:
subrname = None
for uname, req in stmt.unknowns.iteritems():
if ( is_class_derived and uname.firstpartname()==stmt.selector[1]) or uname.firstpartname()==stmt.name:
#if uname.firstpartname()==stmt.name:
if len(req.res_stmts)>0:
res = req.res_stmts[0]
subrname = get_dtype_readname(res)
break
if subrname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
namedpart_append_comment(self.kernel_externs_subrs[node.kgen_parent][0], EXEC_PART, \
'ERROR: "%s" is not resolved. Call statements to read "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][0], subrname, entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_call(self.kernel_externs_subrs[node.kgen_parent][1], subrname, entity_name, stmt, var, prefix='kgenref_')
else: # intrinsic type
self.create_read_intrinsic(self.kernel_externs_subrs[node.kgen_parent][0], entity_name, stmt, var)
if entity_name in out_entity_names:
self.create_read_intrinsic(self.kernel_externs_subrs[node.kgen_parent][1], entity_name, stmt, var, prefix='kgenref_')
def create_dtype_write_subr(self, node):
assert node.kgen_stmt, 'None kgen statement'
subrname = get_dtype_writename(node.kgen_stmt)
if subrname is None: return
parent = node.kgen_parent
checks = lambda n: isinstance(n.kgen_stmt, block_statements.Subroutine) and n.name==subrname
if not part_has_node(parent, SUBP_PART, checks):
checks = lambda n: n.kgen_match_class==statements.Contains
if not parent in state_gencore_contains and not part_has_node(parent, CONTAINS_PART, checks):
part_append_comment(parent, CONTAINS_PART, '')
part_append_gensnode(parent, CONTAINS_PART, statements.Contains)
part_append_comment(parent, CONTAINS_PART, '')
state_gencore_contains.append(parent)
part_append_comment(parent, SUBP_PART, 'read state subroutine for %s'%subrname)
attrs = {'prefix': 'RECURSIVE', 'name': subrname, 'args': ['var', 'kgen_unit', 'printvar']}
subrobj = part_append_gensnode(parent, SUBP_PART, block_statements.Subroutine, attrs=attrs)
part_append_comment(parent, SUBP_PART, '')
# variable
attrs = {'type_spec': 'TYPE', 'attrspec': ['INTENT(IN)'], 'selector':(None, node.name), 'entity_decls': ['var']}
part_append_gensnode(subrobj, DECL_PART, typedecl_statements.Type, attrs=attrs)
# kgen_unit
attrs = {'type_spec': 'INTEGER', 'attrspec': ['INTENT(IN)'], 'entity_decls': ['kgen_unit']}
part_append_gensnode(subrobj, DECL_PART, typedecl_statements.Integer, attrs=attrs)
# printvar
attrs = {'type_spec': 'CHARACTER', 'attrspec': ['INTENT(IN)', 'OPTIONAL'], 'selector':('*', None), 'entity_decls': ['printvar']}
part_append_gensnode(subrobj, DECL_PART, typedecl_statements.Character, attrs=attrs)
# kgen_istrue
attrs = {'type_spec': 'LOGICAL', 'entity_decls': ['kgen_istrue']}
part_append_gensnode(subrobj, DECL_PART, typedecl_statements.Logical, attrs=attrs)
attrs = {'type_spec': 'REAL', 'entity_decls': ['kgen_array_sum'], 'selector': (None, '8')}
part_append_gensnode(subrobj, DECL_PART, typedecl_statements.Real, attrs=attrs)
part_append_comment(subrobj, DECL_PART, '')
#comp_part = get_part(node, TYPE_COMP_PART)
comp_part = get_part(node, TYPE_PART)
for item in comp_part:
if not hasattr(item, 'kgen_stmt'): continue
if not isinstance(item.kgen_stmt, typedecl_statements.TypeDeclarationStatement): continue
stmt = item.kgen_stmt
entity_names = [ get_entity_name(decl) for decl in stmt.entity_decls ]
for entity_name, entity_decl in zip(entity_names, stmt.entity_decls):
if is_remove_state(entity_name, stmt): continue
node.kgen_stmt.top.used4genstate = True
var = stmt.get_variable(entity_name)
callname = get_typedecl_writename(stmt, entity_name)
if var.is_array():
if stmt.is_derived():
self.create_write_call(subrobj, callname, entity_name, stmt, var)
else: # intrinsic type
if var.is_explicit_shape_array():
self.create_write_intrinsic(subrobj, entity_name, stmt, var)
else: # implicit array
self.create_write_call(subrobj, callname, entity_name, stmt, var)
else: # scalar
if stmt.is_derived():
if var.is_allocatable() or var.is_pointer():
self.create_write_call(subrobj, callname, entity_name, stmt, var)
else:
callname = None
for uname, req in stmt.unknowns.iteritems():
if uname.firstpartname()==stmt.name and len(req.res_stmts)>0:
res = req.res_stmts[0]
callname = get_dtype_writename(res)
break
if callname is None:
print 'WARNING: Can not find Type resolver for %s'%stmt.name
part_append_comment(subrobj, EXEC_PART, \
'ERROR: "%s" is not resolved. Call statement to write "%s" is not created here.'%\
(stmt.name, stmt.name))
else:
self.create_write_call(subrobj, callname, entity_name, stmt, var)
else: # intrinsic type
self.create_write_intrinsic(subrobj, entity_name, stmt, var)
part_append_comment(subrobj, EXEC_PART, '')
# create public stmt
if parent.kgen_match_class in [ block_statements.Program, block_statements.Module ]:
attrs = {'items': [subrname]}
part_append_gensnode(parent, DECL_PART, statements.Public, attrs=attrs)
