def parse_preamble_data(statements, pobj, spec_name, endmatch, logger):
"""Parse module variables or DDT definitions from a module preamble
or parse program variables from the beginning of a program.
"""
inspec = True
mheaders = list()
var_dict = VarDictionary(spec_name)
psrc = ParseSource(spec_name, 'MODULE', pobj)
active_table = None
while inspec and (statements is not None):
while len(statements) > 0:
statement = statements.pop(0)
# End program or module
pmatch = endmatch.match(statement)
asmatch = arg_table_start_re.match(statement)
type_def = fortran_type_definition(statement)
if asmatch is not None:
active_table = asmatch.group(1).lower()
elif (pmatch is not None) or is_contains_statement(
statement, inspec):
# We are done with the specification
inspec = False
if len(var_dict.variable_list()) > 0:
mheader = MetadataHeader(title=spec_name,
type_in='MODULE',
module=spec_name,
var_dict=var_dict,
logger=logger)
mheaders.append(mheader)
# End if
break
elif (type_def is not None) and (type_def[0].lower()
== active_table):
statements, ddt = parse_type_def(statements, type_def,
spec_name, pobj, logger)
mheaders.append(ddt)
active_table = None
else:
# We should have a variable definition to add
if ((not is_comment_statement(statement, logger)) and
(not parse_use_statement({}, statement, pobj, logger))
and (active_table == spec_name)):
vars = parse_fortran_var_decl(statement,
psrc,
logger=logger)
for var in vars:
var_dict.add_variable(var)
# End for
# End if
# End if
# End while
if inspec and (len(statements) == 0):
statements = read_statements(pobj)
# End if
# End while
return statements, mheaders
def __init__(self,
parse_object=None,
title=None,
type_in=None,
module=None,
var_dict=None,
property_table=False,
logger=None):
self._pobj = parse_object
"""If <parse_object> is not None, initialize from the current file and
location in <parse_object>.
If <parse_object> is None, initialize from <title>, <type>, <module>,
and <var_dict>. Note that if <parse_object> is not None, <title>,
<type>, <module>, and <var_dict> are ignored.
"""
if parse_object is None:
if title is None:
raise ParseInternalError('MetadataHeader requires a title')
else:
self._table_title = title
# End if
if type_in is None:
raise ParseInternalError(
'MetadataHeader requires a header type')
else:
self._header_type = type
# End if
if module is None:
raise ParseInternalError(
'MetadataHeader requires a module name')
else:
self._module_name = module
# End if
# Initialize our ParseSource parent
super(MetadataHeader, self).__init__(self.title, self.header_type,
self._pobj)
self._variables = VarDictionary(self.title, logger=logger)
for var in var_dict.variable_list(): # Let this crash if no dict
self._variables.add_variable(var)
# End for
else:
self.__init_from_file__(parse_object, property_table, logger)
# End if
# Categorize the variables
self._var_intents = {'in': list(), 'out': list(), 'inout': list()}
for var in self.variable_list():
intent = var.get_prop_value('intent')
if intent is not None:
self._var_intents[intent].append(var)
def parse_type_def(statements, type_def, mod_name, pobj, logger):
"""Parse a type definition from <statements> and return the
remaining statements along with a MetadataTable object representing
the type's variables."""
psrc = ParseSource(mod_name, 'ddt', pobj)
seen_contains = False
mheader = None
var_dict = VarDictionary(type_def[0])
inspec = True
while inspec and (statements is not None):
while len(statements) > 0:
statement = statements.pop(0)
# End program or module
pmatch = _END_TYPE_RE.match(statement)
if pmatch is not None:
# We hit the end of the type, make a header
mheader = MetadataTable(table_name_in=type_def[0],
table_type_in='ddt',
module=mod_name, var_dict=var_dict,
logger=logger)
inspec = False
elif is_contains_statement(statement, inspec):
seen_contains = True
elif not seen_contains:
# Comment of variable
if ((not is_comment_statement(statement)) and
(not parse_use_statement(statement, logger))):
dvars = parse_fortran_var_decl(statement, psrc,
logger=logger)
for var in dvars:
var_dict.add_variable(var)
# End for
# End if
else:
# We are just skipping lines until the end type
pass
# End if
# End while
if inspec and (len(statements) == 0):
statements = read_statements(pobj)
# End if
# End while
return statements, mheader
def parse_type_def(statements, type_def, mod_name, pobj, logger):
psrc = ParseSource(mod_name, 'DDT', pobj)
seen_contains = False
mheader = None
var_dict = VarDictionary(type_def[0])
inspec = True
while inspec and (statements is not None):
while len(statements) > 0:
statement = statements.pop(0)
# End program or module
pmatch = end_type_re.match(statement)
if pmatch is not None:
# We hit the end of the type, make a header
mheader = MetadataHeader(title=type_def[0],
type_in='DDT',
module=mod_name,
var_dict=var_dict,
logger=logger)
inspec = False
elif is_contains_statement(statement, inspec):
seen_contains = True
elif not seen_contains:
# Comment of variable
if ((not is_comment_statement(statement, logger)) and
(not parse_use_statement({}, statement, pobj, logger))):
vars = parse_fortran_var_decl(statement,
psrc,
logger=logger)
for var in vars:
var_dict.add_variable(var)
# End for
# End if
else:
# We are just skipping lines until the end type
pass
# End if
# End while
if inspec and (len(statements) == 0):
statements = read_statements(pobj)
# End if
# End while
return statements, mheader
def write_host_cap(host_model, api, output_dir, logger):
###############################################################################
"""Write an API to allow <host_model> to call any configured CCPP suite"""
module_name = "{}_ccpp_cap".format(host_model.name)
cap_filename = os.path.join(output_dir, '{}.F90'.format(module_name))
if logger is not None:
msg = 'Writing CCPP Host Model Cap for {} to {}'
logger.info(msg.format(host_model.name, cap_filename))
# End if
header = _HEADER.format(host_model=host_model.name)
with FortranWriter(cap_filename, 'w', header, module_name) as cap:
# Write module use statements
maxmod = len(KINDS_MODULE)
cap.write(' use {kinds}'.format(kinds=KINDS_MODULE), 1)
modules = host_model.variable_locations()
if modules:
mlen = max([len(x[0]) for x in modules])
maxmod = max(maxmod, mlen)
# End if
mlen = max([len(x.module) for x in api.suites])
maxmod = max(maxmod, mlen)
maxmod = max(maxmod, len(CONST_DDT_MOD))
for mod in modules:
mspc = (maxmod - len(mod[0]))*' '
cap.write("use {}, {}only: {}".format(mod[0], mspc, mod[1]), 1)
# End for
mspc = ' '*(maxmod - len(CONST_DDT_MOD))
cap.write("use {}, {}only: {}".format(CONST_DDT_MOD, mspc,
CONST_DDT_NAME), 1)
cap.write_preamble()
max_suite_len = 0
for suite in api.suites:
max_suite_len = max(max_suite_len, len(suite.module))
# End for
cap.write("! Public Interfaces", 1)
# CCPP_STATE_MACH.transitions represents the host CCPP interface
for stage in CCPP_STATE_MACH.transitions():
stmt = "public :: {host_model}_ccpp_physics_{stage}"
cap.write(stmt.format(host_model=host_model.name, stage=stage), 1)
# End for
API.declare_inspection_interfaces(cap)
# Write the host-model interfaces for constituents
reg_name = constituent_register_subname(host_model)
cap.write("public :: {}".format(reg_name), 1)
numconsts_name = constituent_num_consts_funcname(host_model)
cap.write("public :: {}".format(numconsts_name), 1)
copyin_name = constituent_copyin_subname(host_model)
cap.write("public :: {}".format(copyin_name), 1)
copyout_name = constituent_copyout_subname(host_model)
cap.write("public :: {}".format(copyout_name), 1)
cap.write("", 0)
cap.write("! Private module variables", 1)
const_dict = add_constituent_vars(cap, host_model, api.suites, logger)
cap.end_module_header()
for stage in CCPP_STATE_MACH.transitions():
# Create a dict of local variables for stage
host_local_vars = VarDictionary("{}_{}".format(host_model.name,
stage))
# Create part call lists
# Look for any loop-variable mismatch
for suite in api.suites:
spart_list = suite_part_list(suite, stage)
for spart in spart_list:
spart_args = spart.call_list.variable_list()
for sp_var in spart_args:
stdname = sp_var.get_prop_value('standard_name')
hvar = const_dict.find_variable(standard_name=stdname,
any_scope=True)
if hvar is None:
errmsg = 'No host model variable for {} in {}'
raise CCPPError(errmsg.format(stdname, spart.name))
# End if
# End for (loop over part variables)
# End for (loop of suite parts)
# End for (loop over suites)
run_stage = stage == 'run'
# All interfaces need the suite name
apivars = [_SUITE_NAME_VAR]
if run_stage:
# Only the run phase needs a suite part name
apivars.append(_SUITE_PART_VAR)
# End if
# Create a list of dummy arguments with correct intent settings
callvars = host_model.call_list(stage) # Host interface dummy args
hdvars = list()
subst_dict = {}
for hvar in callvars:
protected = hvar.get_prop_value('protected')
stdname = hvar.get_prop_value('standard_name')
if stdname in CCPP_LOOP_VAR_STDNAMES:
protected = True # Cannot modify a loop variable
# End if
if protected:
subst_dict['intent'] = 'in'
else:
subst_dict['intent'] = 'inout'
# End if
hdvars.append(hvar.clone(subst_dict,
source_name=_API_SRC_NAME))
# End for
lnames = [x.get_prop_value('local_name') for x in apivars + hdvars]
api_vlist = ", ".join(lnames)
cap.write(_SUBHEAD.format(api_vars=api_vlist,
host_model=host_model.name,
stage=stage), 1)
# Write out any suite part use statements
for suite in api.suites:
mspc = (max_suite_len - len(suite.module))*' '
spart_list = suite_part_list(suite, stage)
for spart in spart_list:
stmt = "use {}, {}only: {}"
cap.write(stmt.format(suite.module, mspc, spart.name), 2)
# End for
# End for
# Write out any host model DDT input var use statements
host_model.ddt_lib.write_ddt_use_statements(hdvars, cap, 2,
pad=max_suite_len)
cap.write("", 1)
# Write out dummy arguments
for var in apivars:
var.write_def(cap, 2, host_model)
# End for
for var in hdvars:
var.write_def(cap, 2, host_model)
# End for
for var in host_local_vars.variable_list():
var.write_def(cap, 2, host_model)
# End for
cap.write('', 0)
# Write out the body clauses
errmsg_name, errflg_name = api.get_errinfo_names()
# Initialize err variables
cap.write('{errflg} = 0'.format(errflg=errflg_name), 2)
cap.write('{errmsg} = ""'.format(errmsg=errmsg_name), 2)
else_str = ''
for suite in api.suites:
stmt = "{}if (trim(suite_name) == '{}') then"
cap.write(stmt.format(else_str, suite.name), 2)
if stage == 'run':
el2_str = ''
spart_list = suite_part_list(suite, stage)
for spart in spart_list:
pname = spart.name[len(suite.name)+1:]
stmt = "{}if (trim(suite_part) == '{}') then"
cap.write(stmt.format(el2_str, pname), 3)
call_str = suite_part_call_list(host_model, const_dict,
spart, True)
cap.write("call {}({})".format(spart.name, call_str), 4)
el2_str = 'else '
# End for
cap.write("else", 3)
emsg = "write({errmsg}, '(3a)')".format(errmsg=errmsg_name)
emsg += '"No suite part named ", '
emsg += 'trim(suite_part), '
emsg += '" found in suite {sname}"'.format(sname=suite.name)
cap.write(emsg, 4)
cap.write("{errflg} = 1".format(errflg=errflg_name), 4)
cap.write("end if", 3)
else:
spart = suite.phase_group(stage)
call_str = suite_part_call_list(host_model, const_dict,
spart, False)
stmt = "call {}_{}({})"
cap.write(stmt.format(suite.name, stage, call_str), 3)
# End if
else_str = 'else '
# End for
cap.write("else", 2)
emsg = "write({errmsg}, '(3a)')".format(errmsg=errmsg_name)
emsg += '"No suite named ", '
emsg += 'trim(suite_name), "found"'
cap.write(emsg, 3)
cap.write("{errflg} = 1".format(errflg=errflg_name), 3)
cap.write("end if", 2)
cap.write(_SUBFOOT.format(host_model=host_model.name,
stage=stage), 1)
# End for
# Write the API inspection routines (e.g., list of suites)
api.write_inspection_routines(cap)
# Write the constituent initialization interfaces
err_vars = host_model.find_error_variables()
const_obj_name = constituent_model_object_name(host_model)
cap.write("", 0)
const_names_name = constituent_model_const_stdnames(host_model)
const_indices_name = constituent_model_const_indices(host_model)
ConstituentVarDict.write_host_routines(cap, host_model, reg_name,
numconsts_name, copyin_name,
copyout_name, const_obj_name,
const_names_name,
const_indices_name,
api.suites, err_vars)
# End with
return cap_filename
def add_constituent_vars(cap, host_model, suite_list, logger):
###############################################################################
"""Create a DDT library containing array reference variables
for each constituent field for all suites in <suite_list>.
Create and return a dictionary containing an index variable for each of the
constituents as well as the variables from the DDT object.
Also, write declarations for these variables to <cap>.
Since the constituents are in a DDT (ccpp_constituent_properties_t),
create a metadata table with the required information, then parse it
to create the dictionary.
"""
# First create a MetadataTable for the constituents DDT
stdname_layer = "ccpp_constituents_num_layer_consts"
stdname_interface = "ccpp_constituents_num_interface_consts"
stdname_2d = "ccpp_constituents_num_2d_consts"
horiz_dim = "horizontal_dimension"
vert_layer_dim = "vertical_layer_dimension"
vert_interface_dim = "vertical_interface_dimension"
array_layer = "vars_layer"
array_interface = "vars_interface"
array_2d = "vars_2d"
# Table preamble (leave off ccpp-table-properties header)
ddt_mdata = [
#"[ccpp-table-properties]",
" name = {}".format(CONST_DDT_NAME), " type = ddt",
"[ccpp-arg-table]",
" name = {}".format(CONST_DDT_NAME), " type = ddt",
"[ num_layer_vars ]",
" standard_name = {}".format(stdname_layer),
" units = count", " dimensions = ()", " type = integer",
"[ num_interface_vars ]",
" standard_name = {}".format(stdname_interface),
" units = count", " dimensions = ()", " type = integer",
"[ num_2d_vars ]",
" standard_name = {}".format(stdname_2d),
" units = count", " dimensions = ()", " type = integer",
"[ {} ]".format(array_layer),
" standard_name = ccpp_constituents_array_of_layer_consts",
" units = none",
" dimensions = ({}, {}, {})".format(horiz_dim, vert_layer_dim,
stdname_layer),
" type = real", " kind = kind_phys",
"[ {} ]".format(array_interface),
" standard_name = ccpp_constituents_array_of_interface_consts",
" units = none",
" dimensions = ({}, {}, {})".format(horiz_dim,
vert_interface_dim,
stdname_interface),
" type = real", " kind = kind_phys",
"[ {} ]".format(array_2d),
" standard_name = ccpp_constituents_array_of_2d_consts",
" units = none",
" dimensions = ({}, {})".format(horiz_dim, stdname_2d),
" type = real", " kind = kind_phys"]
# Add entries for each constituent (once per standard name)
const_stdnames = set()
for suite in suite_list:
if logger is not None:
lmsg = "Adding constituents from {} to {}"
logger.debug(lmsg.format(suite.name, host_model.name))
# end if
scdict = suite.constituent_dictionary()
for cvar in scdict.variable_list():
std_name = cvar.get_prop_value('standard_name')
if std_name not in const_stdnames:
# Add a metadata entry for this constituent
# Check dimensions and figure vertical dimension
# Currently, we only support variables with first dimension,
# horizontal_dimension, and second (optional) dimension,
# vertical_layer_dimension or vertical_interface_dimension
dims = cvar.get_dimensions()
if (len(dims) < 1) or (len(dims) > 2):
emsg = "Unsupported constituent dimensions, '{}'"
dimstr = "({})".format(", ".join(dims))
raise CCPPError(emsg.format(dimstr))
# end if
hdim = dims[0].split(':')[-1]
if hdim != 'horizontal_dimension':
emsg = "Unsupported first constituent dimension, '{}', "
emsg += "must be 'horizontal_dimension'"
raise CCPPError(emsg.format(hdim))
# end if
if len(dims) > 1:
vdim = dims[1].split(':')[-1]
if vdim == vert_layer_dim:
cvar_array_name = array_layer
elif vdim == vert_interface_dim:
cvar_array_name = array_interface
else:
emsg = "Unsupported vertical constituent dimension, "
emsg += "'{}', must be '{}' or '{}'"
raise CCPPError(emsg.format(vdim, vert_layer_dim,
vert_interface_dim))
# end if
else:
cvar_array_name = array_2d
# end if
# First, create an index variable for <cvar>
ind_std_name = "index_of_{}".format(std_name)
loc_name = "{}(:,:,{})".format(cvar_array_name, ind_std_name)
ddt_mdata.append("[ {} ]".format(loc_name))
ddt_mdata.append(" standard_name = {}".format(std_name))
units = cvar.get_prop_value('units')
ddt_mdata.append(" units = {}".format(units))
dimstr = "({})".format(", ".join(dims))
ddt_mdata.append(" dimensions = {}".format(dimstr))
vtype = cvar.get_prop_value('type')
vkind = cvar.get_prop_value('kind')
ddt_mdata.append(" type = {} | kind = {}".format(vtype, vkind))
const_stdnames.add(std_name)
# end if
# end for
# end for
# Parse this table using a fake filename
parse_obj = ParseObject("{}_constituent_mod.meta".format(host_model.name),
ddt_mdata)
ddt_table = MetadataTable(parse_object=parse_obj, logger=logger)
ddt_name = ddt_table.sections()[0].title
ddt_lib = DDTLibrary('{}_constituent_ddtlib'.format(host_model.name),
ddts=ddt_table.sections(), logger=logger)
# A bit of cleanup
del parse_obj
del ddt_mdata
# Now, create the "host constituent module" dictionary
const_dict = VarDictionary("{}_constituents".format(host_model.name),
parent_dict=host_model)
# Add in the constituents object
prop_dict = {'standard_name' : "ccpp_model_constituents_object",
'local_name' : constituent_model_object_name(host_model),
'dimensions' : '()', 'units' : "None", 'ddt_type' : ddt_name}
const_var = Var(prop_dict, _API_SOURCE)
const_var.write_def(cap, 1, const_dict)
ddt_lib.collect_ddt_fields(const_dict, const_var)
# Declare variable for the constituent standard names array
max_csname = max([len(x) for x in const_stdnames]) if const_stdnames else 0
num_const_fields = len(const_stdnames)
cs_stdname = constituent_model_const_stdnames(host_model)
const_list = sorted(const_stdnames)
if const_list:
const_strs = ['"{}{}"'.format(x, ' '*(max_csname - len(x)))
for x in const_list]
cs_stdame_initstr = " = (/ " + ", ".join(const_strs) + " /)"
else:
cs_stdame_initstr = ""
# end if
cap.write("character(len={}) :: {}({}){}".format(max_csname, cs_stdname,
num_const_fields,
cs_stdame_initstr), 1)
# Declare variable for the constituent standard names array
array_name = constituent_model_const_indices(host_model)
cap.write("integer :: {}({}) = -1".format(array_name, num_const_fields), 1)
# Add individual variables for each index var to the const_dict
for index, std_name in enumerate(const_list):
ind_std_name = "index_of_{}".format(std_name)
ind_loc_name = "{}({})".format(array_name, index + 1)
prop_dict = {'standard_name' : ind_std_name,
'local_name' : ind_loc_name, 'dimensions' : '()',
'units' : 'index', 'protected' : "True",
'type' : 'integer', 'kind' : ''}
ind_var = Var(prop_dict, _API_SOURCE)
const_dict.add_variable(ind_var)
# end for
# Add vertical dimensions for DDT call strings
pver = host_model.find_variable(standard_name=vert_layer_dim,
any_scope=False)
if pver is not None:
prop_dict = {'standard_name' : vert_layer_dim,
'local_name' : pver.get_prop_value('local_name'),
'units' : 'count', 'type' : 'integer',
'protected' : 'True', 'dimensions' : '()'}
if const_dict.find_variable(standard_name=vert_layer_dim,
any_scope=False) is None:
ind_var = Var(prop_dict, _API_SOURCE)
const_dict.add_variable(ind_var)
# end if
# end if
pver = host_model.find_variable(standard_name=vert_interface_dim,
any_scope=False)
if pver is not None:
prop_dict = {'standard_name' : vert_interface_dim,
'local_name' : pver.get_prop_value('local_name'),
'units' : 'count', 'type' : 'integer',
'protected' : 'True', 'dimensions' : '()'}
if const_dict.find_variable(standard_name=vert_interface_dim,
any_scope=False) is None:
ind_var = Var(prop_dict, _API_SOURCE)
const_dict.add_variable(ind_var)
# end if
# end if
return const_dict
ParseContext(filename="host_cap.F90"))
_SUITE_NAME_VAR = Var({'local_name':'suite_name',
'standard_name':'suite_name',
'intent':'in', 'type':'character',
'kind':'len=*', 'units':'', 'protected':'True',
'dimensions':'()'}, _API_SOURCE)
_SUITE_PART_VAR = Var({'local_name':'suite_part',
'standard_name':'suite_part',
'intent':'in', 'type':'character',
'kind':'len=*', 'units':'', 'protected':'True',
'dimensions':'()'}, _API_SOURCE)
# Used to prevent loop substitution lookups
_BLANK_DICT = VarDictionary(_API_SRC_NAME)
###############################################################################
def suite_part_list(suite, stage):
###############################################################################
"""Return a list of all the suite parts for this stage"""
run_stage = stage == 'run'
if run_stage:
spart_list = list()
for spart in suite.groups:
if suite.is_run_group(spart):
spart_list.append(spart)
# End if
# End for
else:
spart_list = [suite.phase_group(stage)]
def __init__(self, meta_tables, name_in, logger):
self.__name = name_in
self.__var_locations = {} # Local name to module map
self.__loop_vars = None # Loop control vars in interface calls
self.__used_variables = None # Local names which have been requested
self.__deferred_finds = None # Used variables that were missed at first
# First, process DDT headers
meta_headers = list()
for sect in [x.sections() for x in meta_tables.values()]:
meta_headers.extend(sect)
# end for
# Initialize our dictionaries
# Initialize variable dictionary
super(HostModel, self).__init__(self.name, logger=logger)
self.__ddt_lib = DDTLibrary(
'{}_ddts'.format(self.name),
ddts=[d for d in meta_headers if d.header_type == 'ddt'],
logger=logger)
self.__ddt_dict = VarDictionary("{}_ddt_vars".format(self.name),
parent_dict=self,
logger=logger)
# Now, process the code headers by type
self.__metadata_tables = meta_tables
for header in [h for h in meta_headers if h.header_type != 'ddt']:
title = header.title
if logger is not None:
msg = 'Adding {} {} to host model'
logger.debug(msg.format(header.header_type, title))
# End if
if header.header_type == 'module':
# Set the variable modules
modname = header.title
for var in header.variable_list():
self.add_variable(var)
lname = var.get_prop_value('local_name')
self.__var_locations[lname] = modname
self.ddt_lib.check_ddt_type(var, header, lname=lname)
if var.is_ddt():
self.ddt_lib.collect_ddt_fields(self.__ddt_dict, var)
# End if
# End for
elif header.header_type == 'host':
if self.__name is None:
# Grab the first host name we see
self.__name = header.name
# End if
for var in header.variable_list():
self.add_variable(var)
self.ddt_lib.check_ddt_type(var, header)
if var.is_ddt():
self.ddt_lib.collect_ddt_fields(self.__ddt_dict, var)
# End if
# End for
loop_vars = header.variable_list(std_vars=False,
loop_vars=True,
consts=False)
if loop_vars:
# loop_vars are part of the host-model interface call
# at run time. As such, they override the host-model
# array dimensions.
self.__loop_vars = VarDictionary(self.name)
# End if
for hvar in loop_vars:
std_name = hvar.get_prop_value('standard_name')
if std_name not in self.__loop_vars:
self.__loop_vars.add_variable(hvar)
else:
ovar = self.__loop_vars[std_name]
ctx1 = context_string(ovar.context)
ctx2 = context_string(hvar.context)
lname1 = ovar.get_prop_value('local_name')
lname2 = hvar.get_prop_value('local_name')
errmsg = ("Duplicate host loop var for {n}:\n"
" Dup: {l1}{c1}\n Orig: {l2}{c2}")
raise CCPPError(
errmsg.format(n=self.name,
l1=lname1,
c1=ctx1,
l2=lname2,
c2=ctx2))
# End if
# End for
else:
errmsg = "Invalid host model metadata header type, {} ({}){}"
errmsg += "\nType must be 'module' or 'host'"
ctx = context_string(header.context)
raise CCPPError(
errmsg.format(header.title, header.header_type, ctx))
# End if
# End while
if self.name is None:
errmsg = 'No name found for host model, add a host metadata entry'
raise CCPPError(errmsg)
# End if
# Finally, turn on the use meter so we know which module variables
# to 'use' in a host cap.
self.__used_variables = set() # Local names which have been requested
self.__deferred_finds = set(
) # Used variables that were missed at first
def parse_scheme_metadata(statements, pobj, spec_name, table_name, logger):
"Parse dummy argument information from a subroutine"
psrc = None
mheader = None
var_dict = None
scheme_name = None
# Find the subroutine line, should be first executable statement
inpreamble = False
insub = True
while insub and (statements is not None):
while len(statements) > 0:
statement = statements.pop(0)
smatch = subroutine_re.match(statement)
esmatch = end_subroutine_re.match(statement)
pmatch = endmodule_re.match(statement)
asmatch = arg_table_start_re.match(statement)
if asmatch is not None:
# We have run off the end of something, hope that is okay
# Put this statement back for the caller to deal with
statements.insert(0, statement)
insub = False
break
elif (pmatch is not None):
# We have run off the end of the module, hope that is okay
pobj.leave_region('MODULE', region_name=spec_name)
insub = False
break
elif smatch is not None:
scheme_name = smatch.group(1)
inpreamble = scheme_name == table_name
if inpreamble:
if smatch.group(2) is not None:
scheme_args = [
x.strip().lower()
for x in smatch.group(2).split(',')
]
else:
scheme_args = list()
# End if
scheme_set = set(scheme_args)
var_dict = VarDictionary(scheme_name)
psrc = ParseSource(scheme_name, 'SCHEME', pobj)
# End if
elif inpreamble:
# Process a preamble statement (use or argument declaration)
if esmatch is not None:
inpreamble = False
insub = False
elif ((not is_comment_statement(statement, logger)) and
(not parse_use_statement({}, statement, pobj, logger))
and ('intent' in statement.lower())):
vars = parse_fortran_var_decl(statement,
psrc,
logger=logger)
for var in vars:
lname = var.get_prop_value('local_name').lower()
if lname in scheme_set:
scheme_set.remove(lname)
else:
raise ParseSyntaxError('dummy argument',
token=lname,
context=pobj)
# End if
var_dict.add_variable(var)
# End for
# End if
# End if
# End while
if insub and (len(statements) == 0):
statements = read_statements(pobj)
# End if
# End while
if (scheme_name is not None) and (var_dict is not None):
mheader = MetadataHeader(title=scheme_name,
type_in='SCHEME',
module=spec_name,
var_dict=var_dict,
logger=logger)
# End if
return statements, mheader
def __init_from_file__(self, parse_object, logger):
# Read the table preamble, assume the caller already figured out
# the first line of the header using the table_start method.
curr_line, curr_line_num = self._pobj.next_line()
self._table_title = None
self._header_type = None
self._module_name = None
while (curr_line
is not None) and (not self.variable_start(curr_line)) and (
not MetadataHeader.table_start(curr_line)):
for property in self.parse_config_line(curr_line):
# Manually parse name, type, and module properties
key = property[0].strip().lower()
value = property[1].strip()
if key == 'name':
self._table_title = value
elif key == 'type':
if value not in ['module', 'scheme', 'ddt']:
raise ParseSyntaxError("metadata table type",
token=value,
context=self._pobj)
# End if
self._header_type = value
elif key == 'module':
if value == "None":
raise ParseSyntaxError("metadata table, no module",
context=self._pobj)
else:
self._module_name = value
# End if
else:
raise ParseSyntaxError("metadata table start property",
token=value,
context=self._pobj)
# End if
# End for
curr_line, curr_line_num = self._pobj.next_line()
# End while
if self.title is None:
raise ParseSyntaxError("metadata header start, no table name",
token=curr_line,
context=self._pobj)
elif self.header_type is None:
raise ParseSyntaxError("metadata header start, no table type",
token=curr_line,
context=self._pobj)
elif self.header_type == "ddt":
register_fortran_ddt_name(self.title)
# End if
# Initialize our ParseSource parent
super(MetadataHeader, self).__init__(self.title, self.header_type,
self._pobj)
# Read the variables
valid_lines = True
self._variables = VarDictionary(self.title, logger=logger)
while valid_lines:
newvar, curr_line = self.parse_variable(curr_line)
valid_lines = newvar is not None
if valid_lines:
self._variables.add_variable(newvar)
# Check to see if we hit the end of the table
valid_lines = not MetadataHeader.table_start(curr_line)
def parse_scheme_metadata(statements, pobj, spec_name, table_name, logger):
"Parse dummy argument information from a subroutine"
psrc = None
mheader = None
var_dict = None
scheme_name = None
# Find the subroutine line, should be first executable statement
inpreamble = False
insub = True
if logger is not None:
ctx = context_string(pobj, nodir=True)
msg = "Parsing specification of {}{}"
logger.debug(msg.format(table_name, ctx))
# End if
ctx = context_string(pobj) # Save initial context with directory
vdict = None # Initialized when we parse the subroutine arguments
while insub and (statements is not None):
while statements:
statement = statements.pop(0)
smatch = _SUBROUTINE_RE.match(statement)
esmatch = _END_SUBROUTINE_RE.match(statement)
pmatch = _ENDMODULE_RE.match(statement)
asmatch = _ARG_TABLE_START_RE.match(statement)
if asmatch is not None:
# We have run off the end of something, hope that is okay
# Put this statement back for the caller to deal with
statements.insert(0, statement)
insub = False
break
# End if
if pmatch is not None:
# We have run off the end of the module, hope that is okay
pobj.leave_region('MODULE', region_name=spec_name)
insub = False
break
# End if
if smatch is not None:
scheme_name = smatch.group(1)
inpreamble = scheme_name.lower() == table_name.lower()
if inpreamble:
if smatch.group(2) is not None:
smstr = smatch.group(2).strip()
if len(smstr) > 0:
smlist = smstr.strip().split(',')
else:
smlist = list()
# End if
scheme_args = [x.strip().lower() for x in smlist]
else:
scheme_args = list()
# End if
# Create a dict template with all the scheme's arguments
# in the correct order
vdict = OrderedDict()
for arg in scheme_args:
if len(arg) == 0:
errmsg = 'Empty argument{}'
raise ParseInternalError(errmsg.format(pobj))
# End if
if arg in vdict:
errmsg = 'Duplicate dummy argument, {}'
raise ParseSyntaxError(errmsg.format(arg),
context=pobj)
# End if
vdict[arg] = None
# End for
psrc = ParseSource(scheme_name, 'scheme', pobj)
# End if
elif inpreamble:
# Process a preamble statement (use or argument declaration)
if esmatch is not None:
inpreamble = False
insub = False
elif ((not is_comment_statement(statement)) and
(not parse_use_statement(statement, logger)) and
is_dummy_argument_statement(statement)):
dvars = parse_fortran_var_decl(statement, psrc,
logger=logger)
for var in dvars:
lname = var.get_prop_value('local_name').lower()
if lname in vdict:
if vdict[lname] is not None:
emsg = "Error: duplicate dummy argument, {}"
raise ParseSyntaxError(emsg.format(lname),
context=pobj)
# End if
vdict[lname] = var
else:
raise ParseSyntaxError('dummy argument',
token=lname, context=pobj)
# End if
# End for
# End if
# End if
# End while
if insub and (len(statements) == 0):
statements = read_statements(pobj)
# End if
# End while
# Check for missing declarations
missing = list()
if vdict is None:
errmsg = 'Subroutine, {}, not found{}'
raise CCPPError(errmsg.format(scheme_name, ctx))
# End if
for lname in vdict.keys():
if vdict[lname] is None:
missing.append(lname)
# End if
# End for
if len(missing) > 0:
errmsg = 'Missing local_variables, {} in {}'
raise CCPPError(errmsg.format(missing, scheme_name))
# End if
var_dict = VarDictionary(scheme_name, variables=vdict)
if (scheme_name is not None) and (var_dict is not None):
mheader = MetadataTable(table_name_in=scheme_name,
table_type_in='scheme', module=spec_name,
var_dict=var_dict, logger=logger)
# End if
return statements, mheader
def parse_preamble_data(statements, pobj, spec_name, endmatch, logger):
"""Parse module variables or DDT definitions from a module preamble
or parse program variables from the beginning of a program.
"""
inspec = True
mheaders = list()
var_dict = VarDictionary(spec_name)
psrc = ParseSource(spec_name, 'MODULE', pobj)
active_table = None
if logger is not None:
ctx = context_string(pobj, nodir=True)
msg = "Parsing preamble variables of {}{}"
logger.debug(msg.format(spec_name, ctx))
# End if
while inspec and (statements is not None):
while len(statements) > 0:
statement = statements.pop(0)
# End program or module
pmatch = endmatch.match(statement)
asmatch = _ARG_TABLE_START_RE.match(statement)
type_def = fortran_type_definition(statement)
if asmatch is not None:
active_table = asmatch.group(1)
elif (pmatch is not None) or is_contains_statement(statement,
inspec):
# We are done with the specification
inspec = False
# Put statement back so caller knows where we are
statements.insert(0, statement)
# Add the header (even if we found no variables)
mheader = MetadataTable(table_name_in=spec_name,
table_type_in='module',
module=spec_name,
var_dict=var_dict, logger=logger)
mheaders.append(mheader)
if logger is not None:
ctx = context_string(pobj, nodir=True)
msg = 'Adding header {}{}'
logger.debug(msg.format(mheader.table_name, ctx))
break
elif ((type_def is not None) and
(type_def[0].lower() == active_table.lower())):
# Put statement back so caller knows where we are
statements.insert(0, statement)
statements, ddt = parse_type_def(statements, type_def,
spec_name, pobj, logger)
if ddt is None:
ctx = context_string(pobj, nodir=True)
msg = "No DDT found at '{}'{}"
raise CCPPError(msg.format(statement, ctx))
# End if
mheaders.append(ddt)
if logger is not None:
ctx = context_string(pobj, nodir=True)
msg = 'Adding DDT {}{}'
logger.debug(msg.format(ddt.table_name, ctx))
# End if
active_table = None
elif active_table is not None:
# We should have a variable definition to add
if ((not is_comment_statement(statement)) and
(not parse_use_statement(statement, logger)) and
(active_table.lower() == spec_name.lower())):
dvars = parse_fortran_var_decl(statement, psrc,
logger=logger)
for var in dvars:
var_dict.add_variable(var)
# End for
# End if
# End if (else we are not in an active table so just skip)
# End while
if inspec and (len(statements) == 0):
statements = read_statements(pobj)
# End if
# End while
return statements, mheaders
'dimensions':'()'}, _API_SOURCE, _API_DUMMY_RUN_ENV)
_SUITE_PART_VAR = Var({'local_name':'suite_part',
'standard_name':'suite_part',
'intent':'in', 'type':'character',
'kind':'len=*', 'units':'', 'protected':'True',
'dimensions':'()'}, _API_SOURCE, _API_DUMMY_RUN_ENV)
###############################################################################
# Used for creating blank dictionary
_MVAR_DUMMY_RUN_ENV = CCPPFrameworkEnv(None, ndict={'host_files':'',
'scheme_files':'',
'suites':''})
# Used to prevent loop substitution lookups
_BLANK_DICT = VarDictionary(_API_SRC_NAME, _MVAR_DUMMY_RUN_ENV)
###############################################################################
def suite_part_list(suite, stage):
###############################################################################
"""Return a list of all the suite parts for this stage"""
run_stage = stage == 'run'
if run_stage:
spart_list = list()
for spart in suite.groups:
if suite.is_run_group(spart):
spart_list.append(spart)
# End if
# End for
else:
spart_list = [suite.phase_group(stage)]
def __init_from_file__(self, parse_object, property_table, logger):
# Read the table preamble, assume the caller already figured out
# the first line of the header using the table_start method.
curr_line, curr_line_num = self._pobj.next_line()
self._table_title = None
self._header_type = None
self._module_name = None
self._dependencies = []
relative_path_local = ''
self._property_table = property_table
while (curr_line
is not None) and (not self.variable_start(curr_line)) and (
not MetadataHeader.table_start(curr_line)):
for property in self.parse_config_line(curr_line):
# Manually parse name, type, and module properties
key = property[0].strip().lower()
value = property[1].strip()
if key == 'name':
self._table_title = value
elif key == 'type':
if value not in ['module', 'scheme', 'ddt']:
raise ParseSyntaxError("metadata table type",
token=value,
context=self._pobj)
# End if
self._header_type = value
elif key == 'module':
if value == "None":
raise ParseSyntaxError("metadata table, no module",
context=self._pobj)
else:
self._module_name = value
# End if
elif key == 'dependencies':
if not (value == "None" or value == ""):
# Remove trailing comma, remove white spaces from each list element
self._dependencies += [
v.strip() for v in value.rstrip(",").split(",")
]
elif key == 'relative_path':
relative_path_local = value.strip()
else:
raise ParseSyntaxError("metadata table start property",
token=value,
context=self._pobj)
# End if
# End for
curr_line, curr_line_num = self._pobj.next_line()
# End while
if self.title is None:
raise ParseSyntaxError("metadata header start, no table name",
token=curr_line,
context=self._pobj)
elif self.header_type is None:
raise ParseSyntaxError("metadata header start, no table type",
token=curr_line,
context=self._pobj)
elif self.header_type == "ddt":
register_fortran_ddt_name(self.title)
# End if
# Add relative path to dependencies
if self.dependencies and relative_path_local:
self._dependencies = [
os.path.join(relative_path_local, v) for v in self.dependencies
]
# Initialize our ParseSource parent
super(MetadataHeader, self).__init__(self.title, self.header_type,
self._pobj)
# Read the variables
valid_lines = True
self._variables = VarDictionary(self.title, logger=logger)
while valid_lines:
newvar, curr_line = self.parse_variable(curr_line)
valid_lines = newvar is not None
if valid_lines:
self._variables.add_variable(newvar)
# Check to see if we hit the end of the table
valid_lines = not MetadataHeader.table_start(curr_line)