"""
Interface to the config_compilers.xml file. This class inherits from GenericXML.py
"""
from CIME.XML.standard_module_setup import *
from CIME.XML.generic_xml import GenericXML
from CIME.XML.files import Files
from CIME.XML.compilerblock import CompilerBlock
from CIME.BuildTools.macrowriterbase import write_macros_file_v1
from CIME.BuildTools.makemacroswriter import MakeMacroWriter
from CIME.BuildTools.cmakemacroswriter import CMakeMacroWriter
from CIME.BuildTools.macroconditiontree import merge_optional_trees
import six
logger = logging.getLogger(__name__)
[docs]class Compilers(GenericXML):
def __init__(self, machobj, infile=None, compiler=None, mpilib=None, files=None, version=None):
"""
initialize an object
"""
if infile is None:
if files is None:
files = Files()
infile = files.get_value("COMPILERS_SPEC_FILE")
schema = files.get_schema("COMPILERS_SPEC_FILE")
GenericXML.__init__(self, infile, schema)
self._machobj = machobj
if version is not None:
# this is used in scripts_regression_tests to force version 2, it should not be used otherwise
self._version = version
else:
self._version = self.get_version()
self.machine = machobj.get_machine_name()
self.os = machobj.get_value("OS")
if compiler is None:
compiler = machobj.get_default_compiler()
self.compiler = compiler
if mpilib is None:
if compiler is None:
mpilib = machobj.get_default_MPIlib()
else:
mpilib = machobj.get_default_MPIlib(attributes={'compiler':compiler})
self.mpilib = mpilib
self.compiler_nodes = None # Listed from last to first
#Append the contents of $HOME/.cime/config_compilers.xml if it exists
#This could cause problems if node matchs are repeated when only one is expected
infile = os.path.join(os.environ.get("HOME"),".cime","config_compilers.xml")
if os.path.exists(infile):
GenericXML.read(self, infile)
if self.compiler is not None:
self.set_compiler(compiler)
if self._version > 1.0:
schema_db = GenericXML(infile=schema)
compiler_vars = schema_db.get_child("{http://www.w3.org/2001/XMLSchema}group", attributes={"name":"compilerVars"})
choice = schema_db.get_child(name="{http://www.w3.org/2001/XMLSchema}choice", root=compiler_vars)
self.flag_vars = set(schema_db.get(elem, "name") for elem in schema_db.get_children(root=choice, attributes={"type":"flagsVar"}))
[docs] def get_compiler(self):
"""
Return the name of the compiler
"""
return self.compiler
[docs] def get_optional_compiler_node(self, nodename, attributes=None):
"""
Return data on a node for a compiler
"""
expect(self.compiler_nodes is not None, "Compiler not set, use parent get_node?")
for compiler_node in self.compiler_nodes:
result = self.get_optional_child(name=nodename, attributes=attributes, root=compiler_node)
if result is not None:
return result
return None
def _is_compatible(self, compiler_node, compiler, machine, os_, mpilib):
for xmlid, value in [ ("COMPILER", compiler), ("MACH", machine), ("OS", os_), ("MPILIB", mpilib) ]:
if value is not None and self.has(compiler_node, xmlid) and value != self.get(compiler_node, xmlid):
return False
return True
[docs] def set_compiler(self, compiler, machine=None, os_=None, mpilib=None):
"""
Sets the compiler block in the Compilers object
>>> from CIME.XML.machines import Machines
>>> compobj = Compilers(Machines(machine="melvin"))
>>> compobj.set_compiler("gnu")
>>> compobj.get_compiler()
'gnu'
"""
machine = machine if machine else self.machine
os_ = os_ if os_ else self.os
mpilib = mpilib if mpilib else self.mpilib
if self.compiler != compiler or self.machine != machine or self.os != os_ or self.mpilib != mpilib or self.compiler_nodes is None:
self.compiler_nodes = []
nodes = self.get_children(name="compiler")
for node in nodes:
if self._is_compatible(node, compiler, machine, os_, mpilib):
self.compiler_nodes.append(node)
self.compiler_nodes.reverse()
self.compiler = compiler
self.machine = machine
self.os = os_
self.mpilib = mpilib
#pylint: disable=arguments-differ
[docs] def get_value(self, name, attribute=None, resolved=True, subgroup=None):
"""
Get Value of fields in the config_compilers.xml file
"""
expect(self.compiler_nodes is not None, "Compiler object has no compiler defined")
expect(subgroup is None, "This class does not support subgroups")
value = None
node = self.get_optional_compiler_node(name, attributes=attribute)
if node is not None:
value = self.text(node)
if value is None:
# if all else fails
#pylint: disable=assignment-from-none
value = GenericXML.get_value(self, name)
if resolved:
if value is not None:
value = self.get_resolved_value(value)
elif name in os.environ:
value = os.environ[name]
return value
[docs] def write_macros_file(self, macros_file="Macros.make", output_format="make", xml=None):
if self._version <= 1.0:
# Parse the xml settings into the $macros hash structure
# put conditional settings in the _COND_ portion of the hash
# and handle them seperately
macros = {"_COND_" : {}}
# Do worst matches first
for compiler_node in reversed(self.compiler_nodes):
_add_to_macros(self, compiler_node, macros)
write_macros_file_v1(macros, self.compiler, self.os,
self.machine, macros_file=macros_file,
output_format=output_format)
else:
if output_format == "make":
format_ = "Makefile"
elif output_format == "cmake":
format_ = "CMake"
else:
format_ = output_format
if isinstance(macros_file, six.string_types):
with open(macros_file, "w") as macros:
self._write_macros_file_v2(format_, macros)
else:
self._write_macros_file_v2(format_, macros_file, xml)
def _write_macros_file_v2(self, build_system, output, xml=None):
"""Write a Macros file for this machine.
Arguments:
build_system - Format of the file to be written. Currently the only
valid values are "Makefile" and "CMake".
output - Text I/O object (inheriting from io.TextIOBase) that
output should be written to. Typically, this will be the
Macros file, opened for writing.
"""
# Set up writer for this build system.
if build_system == "Makefile":
writer = MakeMacroWriter(output)
elif build_system == "CMake":
writer = CMakeMacroWriter(output)
else:
expect(False,
"Unrecognized build system provided to write_macros: " +
build_system)
# Start processing the file.
value_lists = dict()
node_list = []
if xml is None:
node_list = self.get_children(name="compiler")
else:
gen_xml = GenericXML()
gen_xml.read_fd(xml)
node_list = gen_xml.get_children(name="compiler")
for compiler_elem in node_list:
block = CompilerBlock(writer, compiler_elem, self._machobj, self)
# If this block matches machine settings, use it.
if block.matches_machine():
block.add_settings_to_lists(self.flag_vars, value_lists)
# Now that we've scanned through the input, output the variable
# settings.
vars_written = set()
while value_lists:
# Variables that are ready to be written.
ready_variables = [
var_name for var_name in value_lists
if value_lists[var_name].depends <= vars_written
]
expect(len(ready_variables) > 0,
"The file {} has bad <var> references. "
"Check for circular references or variables that "
"are in a <var> tag but not actually defined.".format(self.filename))
big_normal_tree = None
big_append_tree = None
for var_name in ready_variables:
# Note that we're writing this variable.
vars_written.add(var_name)
# Make the conditional trees and write them out.
normal_tree, append_tree = \
value_lists[var_name].to_cond_trees()
big_normal_tree = merge_optional_trees(normal_tree,
big_normal_tree)
big_append_tree = merge_optional_trees(append_tree,
big_append_tree)
# Remove this variable from the list of variables to handle
# next iteration.
del value_lists[var_name]
if big_normal_tree is not None:
big_normal_tree.write_out(writer)
if big_append_tree is not None:
big_append_tree.write_out(writer)
def _add_to_macros(db, node, macros):
for child in db.get_children(root=node):
name = db.name(child)
attrib = db.attrib(child)
value = db.text(child)
if not attrib:
if name.startswith("ADD_"):
basename = name[4:]
if basename in macros:
macros[basename] = "{} {}".format(macros[basename], value)
elif name in macros:
macros[name] = "{} {}".format(macros[name], value)
else:
macros[name] = value
else:
macros[name] = value
else:
cond_macros = macros["_COND_"]
for key, value2 in attrib.items():
if key not in cond_macros:
cond_macros[key] = {}
if value2 not in cond_macros[key]:
cond_macros[key][value2] = {}
cond_macros = cond_macros[key][value2]
cond_macros[name] = value