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)