def __WriteGitSection(self, binPath): if (self._host.Platform == "Windows"): gitPath = binPath / "git.exe" else: gitPath = binPath / "git" if not gitPath.exists(): raise ConfigurationException( "Executable '{0!s}' not found.".format( gitPath)) from FileNotFoundError(str(gitPath)) # get version and backend output = check_output([str(gitPath), "--version"], universal_newlines=True) version = None versionRegExpStr = r"^git version (\d+\.\d+\.\d+).*" versionRegExp = re_compile(versionRegExpStr) for line in output.split('\n'): if version is None: match = versionRegExp.match(line) if match is not None: version = match.group(1) if (version is None): raise ConfigurationException( "Version number not found in '{0!s} --version' output.".format( gitPath)) self._host.PoCConfig[self._section]['Version'] = version
def QueryConfiguration(self, query): if (query == "ModelSim:InstallationDirectory"): result = self._GetModelSimInstallationDirectory() elif (query == "ModelSim:BinaryDirectory"): result = self._GetModelSimBinaryDirectory() elif (query == "Xilinx.ISE:SettingsFile"): result = self._GetXilinxISESettingsFile() elif (query == "Xilinx.Vivado:SettingsFile"): result = self._GetXilinxVivadoSettingsFile() else: parts = query.split(":") if (len(parts) == 2): sectionName = parts[0] optionName = parts[1] try: result = self.PoCConfig[sectionName][optionName] except KeyError as ex: raise ConfigurationException( "Requested setting '{0}:{1}' not found.".format( sectionName, optionName)) from ex else: raise ConfigurationException( "Syntax error in query string '{0}'".format(query)) if isinstance(result, Path): result = str(result) return result
def __CheckDiamondVersion(self, binPath, version): if (self._host.Platform == "Windows"): tclShellPath = binPath / "pnmainc.exe" else: tclShellPath = binPath / "pnmainc" if not tclShellPath.exists(): raise ConfigurationException( "Executable '{0!s}' not found.".format( tclShellPath)) from FileNotFoundError(str(tclShellPath)) try: output = check_output([str(tclShellPath), "???"], stderr=STDOUT, universal_newlines=True) except CalledProcessError as ex: output = ex.output for line in output.split('\n'): if str(version) in line: break else: raise ConfigurationException( "Diamond version mismatch. Expected version {0}.".format( version)) self._host.PoCConfig[self._section]['Version'] = version
def __WriteGHDLSection(self, binPath): if (self._host.Platform == "Windows"): ghdlPath = binPath / "ghdl.exe" else: ghdlPath = binPath / "ghdl" if not ghdlPath.exists(): raise ConfigurationException("Executable '{0!s}' not found.".format(ghdlPath)) from FileNotFoundError( str(ghdlPath)) # get version and backend output = check_output([str(ghdlPath), "-v"], universal_newlines=True) version = None backend = None versionRegExpStr = r"^GHDL (.+?) " versionRegExp = re_compile(versionRegExpStr) backendRegExpStr = r"(?i).*(mcode|gcc|llvm).* code generator" backendRegExp = re_compile(backendRegExpStr) for line in output.split('\n'): if version is None: match = versionRegExp.match(line) if match is not None: version = match.group(1) if backend is None: match = backendRegExp.match(line) if match is not None: backend = match.group(1).lower() if ((version is None) or (backend is None)): raise ConfigurationException("Version number or back-end name not found in '{0!s} -v' output.".format(ghdlPath)) self._host.PoCConfig[self._section]['Version'] = version self._host.PoCConfig[self._section]['Backend'] = backend
def _GetModelSimVersion(self, binPath): if (self._host.Platform == "Windows"): vsimPath = binPath / "vsim.exe" else: vsimPath = binPath / "vsim" if not vsimPath.exists(): raise ConfigurationException("Executable '{0!s}' not found.".format(vsimPath)) from FileNotFoundError( str(vsimPath)) # get version and backend try: output = check_output([str(vsimPath), "-version"], universal_newlines=True) except OSError as ex: raise ConfigurationException("Error while accessing '{0!s}'.".format(vsimPath)) from ex version = None versionRegExpStr = r"^.* vsim (.+?) " versionRegExp = re_compile(versionRegExpStr) for line in output.split('\n'): if version is None: match = versionRegExp.match(line) if match is not None: version = match.group(1) print(self._section, version) self._host.PoCConfig[self._section]['Version'] = version
def __CheckQuartusVersion(self, binPath, version): if (self._host.Platform == "Windows"): quartusPath = binPath / "quartus_sh.exe" else: quartusPath = binPath / "quartus_sh" if not quartusPath.exists(): raise ConfigurationException("Executable '{0!s}' not found.".format(quartusPath)) \ from FileNotFoundError(str(quartusPath)) output = check_output([str(quartusPath), "-v"], universal_newlines=True, stderr=STDOUT) if "Version {0}".format(version) not in output: raise ConfigurationException("Quartus version mismatch. Expected version {0}.".format(version))
def _CheckModelSimVersion(self, binPath, version): if (self._host.Platform == "Windows"): vsimPath = binPath / "vsim.exe" else: vsimPath = binPath / "vsim" if not vsimPath.exists(): raise ConfigurationException("Executable '{0!s}' not found.".format(vsimPath)) from FileNotFoundError( str(vsimPath)) output = check_output([str(vsimPath), "-version"], universal_newlines=True) if str(version) not in output: raise ConfigurationException("QuestaSim version mismatch. Expected version {0}.".format(version))
def __CheckActiveHDLVersion(self, binPath, version): """Compare the given Active-HDL version with the tool's version string.""" # TODO: use vsim abstraction? if (self._host.Platform == "Windows"): vsimPath = binPath / "vsim.exe" else: vsimPath = binPath / "vsim" if not vsimPath.exists(): raise ConfigurationException("Executable '{0!s}' not found.".format(vsimPath)) \ from FileNotFoundError(str(vsimPath)) output = check_output([str(vsimPath), "-version"], universal_newlines=True) if str(version) not in output: raise ConfigurationException("Active-HDL version mismatch. Expected version {0}.".format(version))
def __UninstallGitHooks(self): self._host.LogNormal(" Uninstalling Git hooks...") pocInstallationPath = Path( self._host.PoCConfig['INSTALL.PoC']['InstallationDirectory']) hookRunnerPath = pocInstallationPath / "tools/git/hooks/run-hook.sh" gitDirectoryPath = self.__GetGitDirectory() gitHookDirectoryPath = gitDirectoryPath / "hooks" for hookName in ["pre-commit"]: gitHookPath = gitHookDirectoryPath / hookName if gitHookPath.exists(): if (gitHookPath.is_symlink() and (gitHookPath.resolve() == hookRunnerPath)): self._host.LogNormal( " '{0}' hook is configured for PoC. Deleting.".format( hookName)) try: gitHookPath.unlink() except OSError as ex: raise ConfigurationException( "Cannot remove '{0!s}'.".format( gitHookPath)) from ex else: # TODO: check if file was copied -> Hash compare? self._host.LogWarning( " '{0}' hook is in use by another script. Skipping.". format(hookName))
def __init__(self, host, boardName=None, device=None): # Board members if (boardName is None): boardName = "GENERIC" elif (boardName == ""): raise ValueError("Parameter 'board' is empty.") elif (not isinstance(boardName, str)): raise ValueError("Parameter 'board' is not of type str.") boardName = boardName.lower() if (boardName == "custom"): if (device is None): raise ValueError("Parameter 'device' is None.") elif isinstance(device, Device): self.__device = device else: self.__device = Device(device) else: boardSectionName = None for board in host.PoCConfig['BOARDS']: if (board.lower() == boardName): boardSectionName = host.PoCConfig['BOARDS'][ board] # real board name boardName = boardSectionName.split('.')[1] break else: raise ConfigurationException( "Unknown board '{0}'".format(boardName)) deviceName = host.PoCConfig[boardSectionName]['FPGA'] self.__device = Device(deviceName) self.__boardName = boardName
def CreateFiles(self): solutionConfigPath = self._path / ".poc" if (not self._path.is_absolute()): solutionConfigPath = self._host.Directories.Root / solutionConfigPath try: solutionConfigPath.mkdir(parents=True) except OSError as ex: raise ConfigurationException( "Error while creating '{0!s}'.".format( solutionConfigPath)) from ex solutionConfigFile = solutionConfigPath / self.__SOLUTION_CONFIG_FILE__ with solutionConfigFile.open('w') as fileHandle: fileContent = dedent("""\ [SOLUTION.{slnID}] DefaultLibrary = """.format(slnID=self._id)) fileHandle.write(fileContent) solutionDefaultFile = solutionConfigPath / self.__SOLUTION_DEFAULT_FILE__ with solutionDefaultFile.open('w') as fileHandle: fileContent = dedent("""\ [SOLUTION.DEFAULTS] """) fileHandle.write(fileContent)
def __CheckVivadoVersion(self, binPath, version): if (self._host.Platform == "Windows"): vivadoPath = binPath / "vivado.bat" else: vivadoPath = binPath / "vivado" if not vivadoPath.exists(): raise ConfigurationException( "Executable '{0!s}' not found.".format( vivadoPath)) from FileNotFoundError(str(vivadoPath)) output = check_output([str(vivadoPath), "-version"], universal_newlines=True) if str(version) not in output: raise ConfigurationException( "Vivado version mismatch. Expected version {0}.".format( version))
def __CheckISEVersion(self, binPath): # check for ISE 14.7 if (self._host.Platform == "Windows"): fusePath = binPath / "fuse.exe" else: fusePath = binPath / "fuse" if not fusePath.exists(): raise ConfigurationException( "Executable '{0!s}' not found.".format( fusePath)) from FileNotFoundError(str(fusePath)) output = check_output([str(fusePath), "--version"], universal_newlines=True) if "P.20131013" not in output: raise ConfigurationException( "ISE version mismatch. Expected version 14.7 (P.20131013).")
def _DecodeLatticeLFE(self, deviceString): self.__vendor = Vendors.Lattice self.__family = LatticeFamilies.ECP self.__generation = int(deviceString[3:4]) if (self.__generation == 3): self._DecodeLatticeECP3(deviceString) elif (self.__generation == 5): self._DecodeLatticeECP5(deviceString) else: raise ConfigurationException("Unknown Lattice ECP generation.")
def _ConfigureScriptDirectory(self): """Updates section with value from _template and returns directory as Path object.""" # unresolved = self._template[self._host.Platform][self._section]['ScriptDirectory'] # self._host.PoCConfig[self._section]['ScriptDirectory'] = unresolved # create entry scriptPath = Path(self._host.PoCConfig[self._section]['ScriptDirectory']) # resolve entry if (not scriptPath.exists()): raise ConfigurationException("{0!s} script directory '{1!s}' does not exist.".format(self, scriptPath)) \ from NotADirectoryError(str(scriptPath))
def _DecodeXilinx(self, deviceString): self.__vendor = Vendors.Xilinx self.__generation = int(deviceString[2:3]) familyToken = deviceString[3:4].lower() for fam in XilinxFamilies: if fam.Token == familyToken: self.__family = fam break else: raise ConfigurationException("Unknown Xilinx device family.") deviceRegExpStr = r"(?P<st1>[a-z]{0,2})" # device subtype - part 1 deviceRegExpStr += r"(?P<no>\d{1,4})" # device number deviceRegExpStr += r"(?P<st2>[aent]{0,2})" # device subtype - part 2 deviceRegExpStr += r"(?P<sg>[-1-5]{2})" # speed grade deviceRegExpStr += r"(?P<pack>[a-z]{1,3})" # package deviceRegExpStr += r"(?P<pins>\d{1,4})" # pin count deviceRegExp = re_compile(deviceRegExpStr) deviceRegExpMatch = deviceRegExp.match(deviceString[4:].lower()) if (deviceRegExpMatch is not None): subtype = deviceRegExpMatch.group('st1') + deviceRegExpMatch.group( 'st2') package = deviceRegExpMatch.group('pack') if (subtype != ""): try: self.__subtype = XilinxSubTypes[subtype.upper()] except KeyError as ex: raise ConfigurationException( "Unknown subtype '{0}'.".format(subtype)) from ex else: self.__subtype = XilinxSubTypes.NoSubType self.__number = int(deviceRegExpMatch.group('no')) self.__speedGrade = int(deviceRegExpMatch.group('sg')) try: self.__package = Packages[package.upper()] except KeyError as ex: raise ConfigurationException( "Unknown package '{0}'.".format(package)) from ex self.__pinCount = int(deviceRegExpMatch.group('pins')) else: raise ConfigurationException("RegExp mismatch.")
def __InstallGitHooks(self): self._host.LogNormal(" Installing Git hooks...") pocInstallationPath = Path( self._host.PoCConfig['INSTALL.PoC']['InstallationDirectory']) hookRunnerPath = pocInstallationPath / "tools/git/hooks/run-hook.sh" if (not hookRunnerPath.exists()): raise ConfigurationException( "Runner script '{0!s}' not found.".format( hookRunnerPath)) from FileNotFoundError( str(hookRunnerPath)) gitDirectoryPath = self.__GetGitDirectory() gitHookDirectoryPath = gitDirectoryPath / "hooks" for hookName in ["pre-commit"]: gitHookPath = gitHookDirectoryPath / hookName if gitHookPath.exists(): if (gitHookPath.is_symlink() and (gitHookPath.resolve() == hookRunnerPath)): self._host.LogNormal( " '{0}' hook is already configured for PoC.".format( hookName)) else: self._host.LogWarning( " '{0}' hook is already in use by another script.". format(hookName)) else: self._host.LogNormal( " Setting '{0}' hook for PoC...".format(hookName)) self._host.LogDebug("symlink '{0!s}' -> '{1!s}'.".format( gitHookPath, hookRunnerPath)) try: gitHookPath.symlink_to(hookRunnerPath) except OSError as ex: # if symlink fails, do a copy as backup solution if getattr(ex, 'winerror', None) == 1314: self._host.LogDebug("copy '{0!s}' to '{1!s}'.".format( hookRunnerPath, gitHookPath)) try: shutil_copy(str(hookRunnerPath), str(gitHookPath)) except OSError as ex2: raise ConfigurationException() from ex2
def Path(self): cur = self result = [] while True: result.insert(0, cur) cur = cur.Parent if isinstance(cur, Library): break else: raise ConfigurationException("Hierarchy error. Expected Library.") return result
def _DecodeAltera(self, deviceString): self.__vendor = Vendors.Altera deviceRegExpStr = r"(?P<gen>\d{1,2})" # generation deviceRegExpStr += r"(?P<fam>[acms])" # family deviceRegExpStr += r"(?P<st>(ls|e|g|x|t|gs|gx|gt|gz|sx|st)?)" # subtype deviceRegExp = re_compile(deviceRegExpStr) deviceRegExpMatch = deviceRegExp.match(deviceString[2:].lower()) if (deviceRegExpMatch is not None): self.__generation = int(deviceRegExpMatch.group('gen')) family = deviceRegExpMatch.group('fam') for fam in AlteraFamilies: if fam.Token == family: self.__family = fam break else: raise ConfigurationException("Unknown Altera device family.") subtype = deviceRegExpMatch.group('st') if (subtype != ""): d = { "g": "gx", "x": "sx", "t": "gt" } # re-name for Stratix 10 and Arria 10 if subtype in d: subtype = d[subtype] try: self.__subtype = AlteraSubTypes[subtype.upper()] except KeyError as ex: raise ConfigurationException( "Unknown subtype '{0}'.".format(subtype)) from ex else: self.__subtype = AlteraSubTypes.NoSubType else: raise ConfigurationException("RegExp mismatch.")
def __init__(self, host, fqn, defaultLibrary="PoC", defaultType=EntityTypes.Source): self.__host = host self.__type = None self.__parts = [] if (fqn is None): raise ValueError("Parameter 'fqn' is None.") if (fqn == ""): raise ValueError("Parameter 'fqn' is empty.") # extract EntityType splitList1 = fqn.split(":") if (len(splitList1) == 1): self.__type = defaultType entity = fqn elif (len(splitList1) == 2): self.__type = EntityTypes(splitList1[0]) entity = splitList1[1] else: raise ValueError("Argument 'fqn' has to many ':' signs.") # extract parts parts = entity.split(".") if (parts[0].lower() not in self.__host.Root): parts.insert(0, defaultLibrary) # check and resolve parts cur = self.__host.Root self.__parts.append(cur) last = len(parts) - 1 for pos, part in enumerate(parts): if ((pos == last) and ("*" in part)): pe = StarWildCard(host, part, "----", cur) self.__parts.append(pe) elif ((pos == last) and ("?" in part)): pe = AskWildCard(host, part, "----", cur) self.__parts.append(pe) else: try: pe = cur[part] except KeyError: raise ConfigurationException( "PoC entity '{GREEN}{good}{RED}.{bad}{NOCOLOR}' not found." .format(good=(".".join(parts[:pos])), bad=(".".join(parts[pos:])), **Init.Foreground)) self.__parts.append(pe) cur = pe
def _ConfigureBinaryDirectory(self): """Updates section with value from _template and returns directory as Path object.""" binPath = super()._ConfigureBinaryDirectory() # unresolved = self._template[self._host.Platform][self._section]['BinaryDirectory2'] # self._host.PoCConfig[self._section]['BinaryDirectory2'] = unresolved # create entry defaultPath = Path(self._host.PoCConfig[self._section] ['BinaryDirectory2']) # resolve entry binPath2 = defaultPath # may be more complex in the future if (not binPath2.exists()): raise ConfigurationException("{0!s} 2nd binary directory '{1!s}' does not exist.".format(self, binPath2)) \ from NotADirectoryError(str(binPath2)) return binPath
def _DecodeLatticeECP5(self, deviceString): self.__device = LatticeDevices.ECP5 familyToken = deviceString[4:6].lower() if (familyToken == "u-"): self.__subtype = LatticeSubTypes.U self.__number = int(deviceString[6:8]) self.__speedGrade = int(deviceString[10:11]) self.__package = Packages.CABGA self.__pinCount = 381 # TODO: implement other packages and pin counts elif (familyToken == "um"): self.__subtype = LatticeSubTypes.UM self.__number = int(deviceString[7:9]) self.__speedGrade = int(deviceString[11:12]) self.__package = Packages.CABGA self.__pinCount = 381 # TODO: implement other packages and pin counts else: raise ConfigurationException("Unknown Lattice ECP5 subtype.")
def __GetGitDirectory(self): try: gitRevParse = self._git.GetGitRevParse() gitRevParse.RevParseParameters[gitRevParse.SwitchGitDir] = True gitDirectory = gitRevParse.Execute() gitDirectoryPath = Path(gitDirectory) except CommonException as ex: raise ConfigurationException() from ex # WORKAROUND: GIT REV-PARSE # if the Git repository isn't a Git submodule AND the current working # directory is the Git top-level directory, then 'rev-parse' returns a # relative path, otherwise the path is already absolute. if (not gitDirectoryPath.is_absolute()): pocInstallationPath = Path( self._host.PoCConfig['INSTALL.PoC']['InstallationDirectory']) gitDirectoryPath = pocInstallationPath / gitDirectoryPath return gitDirectoryPath
def RunPostConfigurationTasks(self): if (len(self._host.PoCConfig[self._section]) == 0): return # exit if not configured precompiledDirectory = self._host.PoCConfig['CONFIG.DirectoryNames']['PrecompiledFiles'] vSimSimulatorFiles = self._host.PoCConfig['CONFIG.DirectoryNames']['QuestaSimFiles'] vsimPath = self._host.Directories.Root / precompiledDirectory / vSimSimulatorFiles modelsimIniPath = vsimPath / "modelsim.ini" if not modelsimIniPath.exists(): if not vsimPath.exists(): try: vsimPath.mkdir(parents=True) except OSError as ex: raise ConfigurationException("Error while creating '{0!s}'.".format(vsimPath)) from ex with modelsimIniPath.open('w') as fileHandle: fileContent = dedent("""\ [Library] others = $MODEL_TECH/../modelsim.ini """) fileHandle.write(fileContent)
def _LazyLoadable_Load(self): super()._LazyLoadable_Load() self._name = self._host.PoCConfig[self._configSection]['Name'] self._path = self._host.Directories.Root / self._host.PoCConfig[ self._configSection]['Path'] solutionConfigPath = self._path / ".poc" if (not self._path.is_absolute()): solutionConfigPath = self._host.Directories.Root / solutionConfigPath configFiles = [ solutionConfigPath / self.__SOLUTION_CONFIG_FILE__, solutionConfigPath / self.__SOLUTION_DEFAULT_FILE__ ] for configFile in configFiles: if (not configFile.exists()): raise ConfigurationException( "Solution configuration file '{0!s}' not found.".format( configFile)) from FileNotFoundError(str(configFile)) self._host.PoCConfig.read(str(configFile)) # load projects for option in self._host.PoCConfig[self._configSection]: project = None if (self._host.PoCConfig[self._configSection][option] == "ISEProject"): project = ISEProject(self._host, option, self) elif (self._host.PoCConfig[self._configSection][option] == "VivadoProject"): project = VivadoProject(self._host, option, self) elif (self._host.PoCConfig[self._configSection][option] == "QuartusProject"): project = QuartusProject(self._host, option, self) elif (self._host.PoCConfig[self._configSection][option] == "LatticeProject"): project = LatticeProject(self._host, option, self) if (project is not None): self._projects[option.lower()] = project
def __InstallGitFilters(self): self._host.LogNormal(" Installing Git filters...") normalizeScript = "tools/git/filters/normalize.pl" pocInstallationPath = Path( self._host.PoCConfig['INSTALL.PoC']['InstallationDirectory']) normalizeScriptPath = pocInstallationPath / normalizeScript if (not normalizeScriptPath.exists()): raise ConfigurationException( "Normalize script '{0!s}' not found.".format( normalizeScriptPath)) from FileNotFoundError( str(normalizeScriptPath)) try: commonCleanParameters = normalizeScript + " clean" commonSmudgeParameters = normalizeScript + " smudge" for fileFormat in [None, "rest", "vhdl"]: filterName = "normalize" cleanParameters = commonCleanParameters smudgeParameters = commonSmudgeParameters if (fileFormat is not None): filterName += "_" + fileFormat cleanParameters += " " + fileFormat smudgeParameters += " " + fileFormat git = self._git.GetGitConfig() git.ConfigParameters[git.ValueFilterClean] = filterName git.ConfigParameters[ git.ValueFilterParameters] = cleanParameters git.Execute() git = self._git.GetGitConfig() git.ConfigParameters[git.ValueFilterSmudge] = filterName git.ConfigParameters[ git.ValueFilterParameters] = smudgeParameters git.Execute() except CommonException: return False
def __init__(self, deviceString): # Device members self.__vendor = Vendors.Unknown self.__family = GenericFamilies.Unknown self.__device = GenericDevices.Unknown self.__generation = 0 self.__subtype = GenericSubTypes.Unknown self.__number = 0 self.__speedGrade = 0 self.__package = Packages.Unknown self.__pinCount = 0 self.__deviceString = deviceString if (not isinstance(deviceString, str)): raise ValueError("Parameter 'deviceString' is not of type str.") if ((deviceString is None) or (deviceString == "")): raise ValueError("Parameter 'deviceString' is empty.") # vendor = GENERIC # ========================================================================== if (deviceString[0:2].lower() == "ge"): self._DecodeGeneric() # ge - Generic FPGA device elif (deviceString[0:2].lower() == "xc"): self._DecodeXilinx( deviceString) # xc - Xilinx devices (XC = Xilinx Commercial) elif (deviceString[0:2].lower() == "ep"): self._DecodeAltera(deviceString) # ep - Altera devices elif (deviceString[0:3].lower() == "ice"): self._DecodeLatticeICE(deviceString) # ice - Lattice iCE series elif (deviceString[0:3].lower() == "lcm"): self._DecodeLatticeLCM(deviceString) # lcm - Lattice MachXO series elif (deviceString[0:3].lower() == "lfe"): self._DecodeLatticeLFE(deviceString) # lfe - Lattice ECP series else: raise ConfigurationException( "Unknown manufacturer code in device string '{0}'".format( deviceString))
def __WriteGtkWaveSection(self, binPath): if (self._host.Platform == "Windows"): gtkwPath = binPath / "gtkwave.exe" else: gtkwPath = binPath / "gtkwave" if not gtkwPath.exists(): raise ConfigurationException( "Executable '{0!s}' not found.".format( gtkwPath)) from FileNotFoundError(str(gtkwPath)) # get version and backend output = check_output([str(gtkwPath), "--version"], universal_newlines=True) version = None versionRegExpStr = r"^GTKWave Analyzer v(.+?) " versionRegExp = re_compile(versionRegExpStr) for line in output.split('\n'): if version is None: match = versionRegExp.match(line) if match is not None: version = match.group(1) self._host.PoCConfig[self._section]['Version'] = version
def VivadoNetlist(self): if (len(self._vivadoNetlist) == 0): raise ConfigurationException( "No Vivado netlist configured for '{0!s}'.".format(self)) return self._vivadoNetlist[0]
def CGNetlist(self): if (len(self._coreGenNetlist) == 0): raise ConfigurationException( "No CoreGen netlist configured for '{0!s}'.".format(self)) return self._coreGenNetlist[0]