def __init__(self, data=None):
if data is None:
data = utils.yaml_fread(sys.argv[1])
self.config = data.get("parameters")
self.files_root = data.get("files_root")
self.vlnv = data.get("vlnv")
# Edalize decide core_file dir. generator creates file
self.core_file = self.vlnv.split(":")[2] + ".core"
def __init__(self, core_file, cache_root="", generated=False):
self.core_file = core_file
basename = os.path.basename(self.core_file)
self.core_root = os.path.dirname(self.core_file)
# Populated by CoreDB._solve(). TODO: Find a better solution for that.
self.direct_deps = []
try:
_root = Root(utils.yaml_fread(self.core_file))
except KeyError as e:
raise SyntaxError(f"Unknown item {e}")
except (yaml.scanner.ScannerError,
yaml.constructor.ConstructorError) as e:
raise SyntaxError(str(e))
except AttributeError as e:
raise SyntaxError("Error while trying to parse the core file: " +
str(e))
for i in _root.members:
setattr(self, i, getattr(_root, i))
for i in _root.lists:
setattr(self, i, getattr(_root, i))
for i in _root.dicts:
setattr(self, i, getattr(_root, i))
self.export_files = []
if not self.name:
raise SyntaxError("Missing 'name' parameter")
self.sanitized_name = self.name.sanitized_name
for fs in self.filesets.values():
if fs.file_type:
for f in fs.files:
if not f.file_type:
f.file_type = str(fs.file_type)
if fs.logical_name:
for f in fs.files:
if not f.logical_name:
f.logical_name = str(fs.logical_name)
if self.provider:
self.files_root = os.path.join(cache_root, self.sanitized_name)
# Ugly hack. Don't like injecting vars
# How about a setup function or setters?
self.provider.core_root = self.core_root
self.provider.files_root = self.files_root
else:
self.files_root = self.core_root
self.is_generated = generated
def run_backend(
cm,
export,
do_configure,
do_build,
do_run,
flags,
system_name,
system,
backendargs,
build_root_arg,
verbose,
):
tool_error = (
"No tool was supplied on command line or found in '{}' core description"
)
core = _get_core(cm, system)
try:
tool = core.get_tool(flags)
except SyntaxError as e:
logger.error(str(e))
exit(1)
if not tool:
logger.error(tool_error.format(system))
exit(1)
flags["tool"] = tool
build_root = build_root_arg or os.path.join(cm.config.build_root,
core.name.sanitized_name)
logger.debug(f"Setting build_root to {build_root}")
if export:
export_root = os.path.join(build_root, "src")
else:
export_root = None
try:
work_root = os.path.join(build_root, core.get_work_root(flags))
except SyntaxError as e:
logger.error(e.msg)
exit(1)
eda_api_file = os.path.join(work_root,
core.name.sanitized_name + ".eda.yml")
if not os.path.exists(eda_api_file):
do_configure = True
try:
backend_class = get_edatool(tool)
except ImportError:
logger.error(f"Backend {tool!r} not found")
exit(1)
edalizer = Edalizer(
toplevel=core.name,
flags=flags,
core_manager=cm,
cache_root=cm.config.cache_root,
work_root=work_root,
export_root=export_root,
system_name=system_name,
)
if do_configure:
try:
edalizer.run()
edam = edalizer.edalize
parsed_args = edalizer.parse_args(backend_class, backendargs, edam)
edalizer.add_parsed_args(backend_class, parsed_args)
except SyntaxError as e:
logger.error(e.msg)
exit(1)
except RuntimeError as e:
logger.error("Setup failed : {}".format(str(e)))
exit(1)
edalizer.to_yaml(eda_api_file)
else:
edam = yaml_fread(eda_api_file)
parsed_args = edalizer.parse_args(backend_class, backendargs, edam)
# Frontend/backend separation
try:
backend = backend_class(edam=edam,
work_root=work_root,
verbose=verbose)
except RuntimeError as e:
logger.error(str(e))
exit(1)
except FileNotFoundError as e:
logger.error(f'Could not find EDA API file "{e.filename}"')
exit(1)
if do_configure:
try:
backend.configure([])
print("")
except RuntimeError as e:
logger.error("Failed to configure the system")
logger.error(str(e))
exit(1)
if do_build:
try:
backend.build()
except RuntimeError as e:
logger.error("Failed to build {} : {}".format(
str(core.name), str(e)))
exit(1)
if do_run:
try:
backend.run(parsed_args)
except RuntimeError as e:
logger.error("Failed to run {} : {}".format(
str(core.name), str(e)))
exit(1)
