This Python package is maintained by Patrick Lehmann.|br| https://Paebbels.GitHub.io/

---

|SHIELD:svg:Gitter:pyIPCMI|

---

IP Core Management Infrastructure

PoC - “Pile of Cores” provides implementations for often required hardware functions such as Arithmetic Units, Caches, Clock-Domain-Crossing Circuits, FIFOs, RAM wrappers, and I/O Controllers. The hardware modules are typically provided as VHDL or Verilog source code, so it can be easily re-used in a variety of hardware designs.

All hardware modules use a common set of VHDL packages to share new VHDL types, sub-programs and constants. Additionally, a set of simulation helper packages eases the writing of testbenches. Because PoC hosts a huge amount of IP cores, all cores are grouped into sub-namespaces to build a better hierachy.

Various simulation and synthesis tool chains are supported to interoperate with PoC. To generalize all supported free and commercial vendor tool chains, PoC is shipped with a Python based infrastructure to offer a command line based frontend.

News

See Change Log for latest updates.

Cite the PoC-Library

The PoC-Library hosted at GitHub.com. Please use the following biblatex entry to cite us:

# BibLaTex example entry
@online{poc,
  title={{PoC - Pile of Cores}},
  author={{Chair of VLSI Design, Diagnostics and Architecture}},
  organization={{Technische Universität Dresden}},
  year={2016},
  url={https://github.com/VLSI-EDA/PoC},
  urldate={2016-10-28},
}

---

This document was generated on Jun 18, 2018 - 00:15.

What is pyIPCMI?

PoC - “Pile of Cores” provides implementations for often required hardware functions such as Arithmetic Units, Caches, Clock-Domain-Crossing Circuits, FIFOs, RAM wrappers, and I/O Controllers. The hardware modules are typically provided as VHDL or Verilog source code, so it can be easily re-used in a variety of hardware designs.

All hardware modules use a common set of VHDL packages to share new VHDL types, sub-programs and constants. Additionally, a set of simulation helper packages eases the writing of testbenches. Because PoC hosts a huge amount of IP cores, all cores are grouped into sub-namespaces to build a better hierachy.

Various simulation and synthesis tool chains are supported to interoperate with PoC. To generalize all supported free and commercial vendor tool chains, PoC is shipped with a Python based Infrastruture to offer a command line based frontend.

The PoC-Library pursues the following five goals:

• independence in the platform, target, vendor and tool chain
• generic, efficient, resource sparing and fast implementations of IP cores
• optimized for several device architectures, if suitable
• supportive scripts to ease the IP core handling with all supported vendor tools on all listed operating systems
• ship all IP cores with testbenches for local and online verification

In detail the PoC-Library is:

• synthesizable for ASIC and FPGA devices, e.g. from Altera, Lattice, Xilinx, …,
• supports a wide range of simulation and synthesis tool chains, and is
• executable on several host platforms: Darwin, Linux or Windows.

This is achieved by using generic HDL descriptions, which work with most synthesis and simulation tools mentioned above. If this is not the case, then PoC uses vendor or tool dependent work-arounds. These work-arounds can be different implementations switched by VHDL generate statements as well as different source files containing modified implementations.

One special feature of PoC is it, that the user has not to take care of such implementation switchings. PoC’s IP cores decide on their own what’s the best implementation for the chosen target platform. For this feature, PoC implements a configuration package, which accepts a well-known development board name or a target device string. For example a FPGA device string is decoded into: vendor, device, generation, family, subtype, speed grade, pin count, etc. Out of these information, the PoC component can for example implement a vendor specific carry-chain description to speed up an algorithm or group computation units to effectively use 6-input LUTs.

What is the History of PoC?

In the past years, a lot of “IP cores” were developed at the chair of VLSI design [1] . This lose set of HDL designs was gathered in an old-fashioned CVS repository and grow over the years to a collection of basic HDL implementations like ALUs, FIFOs, UARTs or RAM controllers. For their final projects (bachelor, master, diploma thesis) students got access to PoC, so they could focus more on their main tasks than wasting time in developing and testing basic IP implementations from scratch. But the library was initially for internal and educational use only.

As a university chair for VLSI design, we have a wide range of different FPGA prototyping boards from various vendors and device families as well as generations. So most of the IP cores were developed for both major FPGA vendor platforms and their specific vendor tool chains. The main focus was to describe hardware in a more flexible and generic way, so that an IP core could be reused on multiple target platforms.

As the number of cores increased, the set of common functions and types increased too. In the end PoC is not only a collection of IP cores, its also shipped with a set of packages containing utility functions, new types and type conversions, which are used by most of the cores. This makes PoC a library, not only a collection of IPs.

As we started to search for ways to publish IP cores and maybe the whole PoC-Library, we found several platforms on the Internet, but none was very convincing. Some collective websites contained inactive projects, others were controlled by companies without the possibility to contribute and the majority was a long list of private projects with at most a handful of IP cores. Another disagreement were the used license types for these projects. We decided to use the Apache License, because it has no copyleft rule, a patent clause and allows commercial usage.

We transformed the old CVS repository into three Git repositories: An internal repository for the full set of IP cores (incl. classified code), a public one and a repository for examples, called PoC-Examples, both hosted on GitHub. PoC itself can be integrated into other HDL projects as a library directory or a Git submodule. The preferred usage is the submodule integration, which has the advantage of linked repository versions from hosting Git and the submodule Git. This is already exemplified by our PoC-Examples repository.

---

Footnotes

[1]	The PoC-Library is published and maintained by the Chair for VLSI Design, Diagnostics and Architecture - Faculty of Computer Science, Technische Universität Dresden, Germany http://tu-dresden.de/inf/vlsi-eda

Which Tool Chains are supported?

The PoC-Library and its Python-based infrastructure currently supports the following free and commercial vendor tool chains:

• Synthesis Tool Chains:
  • Altera Quartus
    Tested with Quartus-II ≥ 13.0.
    Tested with Quartus Prime ≥ 15.1.
  • Intel Quartus
    Tested with Quartus Prime ≥ 16.1.
  • Lattice Diamond
    Tested with Diamond ≥ 3.6.
  • Xilinx ISE
    Only ISE 14.7 inclusive Core Generator 14.7 is supported.
  • Xilinx PlanAhead
    Only PlanAhead 14.7 is supported.
  • Xilinx Vivado
    Tested with Vivado ≥ 2015.4.
    Due to a limited VHDL language support compared to ISE 14.7, some PoC IP cores need special work arounds. See the synthesis documention section for Vivado for more details.
• Simulation Tool Chains:
  • Aldec Active-HDL
    Tested with Active-HDL (or Student-Edition) ≥ 10.3
    Tested with Active-HDL Lattice Edition ≥ 10.2
  • Cocotb with Mentor QuestaSim backend
    Tested with Mentor QuestaSim 10.4d
  • Mentor Graphics ModelSim
    Tested with ModelSim PE (or Student Edition) ≥ 10.5c
    Tested with ModelSim SE ≥ 10.5c
    Tested with ModelSim Altera Edition 10.3d (or Starter Edition)
  • Mentor Graphics QuestaSim/ModelSim
    Tested with Mentor QuestaSim ≥ 10.4d
  • Xilinx ISE Simulator
    Tested with ISE Simulator (iSim) 14.7.
    The Python infrastructure supports isim, but PoC’s simulation helper packages and testbenches rely on VHDL-2008 features, which are not supported by isim.
  • Xilinx Vivado Simulator
    Tested with Vivado Simulator (xsim) ≥ 2016.3.
    The Python infrastructure supports xsim, but PoC’s simulation helper packages and testbenches rely on VHDL-2008 features, which are not fully supported by xsim, yet.
  • GHDL + GTKWave
    Tested with GHDL ≥ 0.34dev and GTKWave ≥ 3.3.70
    Due to ungoing development and bugfixes, we encourage to use the newest GHDL version.

Why should I use PoC?

Here is a brief list of advantages:

• We explicitly use the wording PoC-Library rather then collection, because PoC’s packages and IP cores build an ecosystem. Complex IP cores are build on-top of basic IP cores - they are no lose set of cores. The cores offer a clean interface and can be configured by many generic parameters.
• PoC is target independent: It’s possible to switch the target device or even the device vendor without switching the IP core.

Todo

Use a well tested set of packages to ease the use of VHDL

Use a well tested set of simulation helpers

Run testbenches in various simulators.

Run synthesis tests in varous synthesis tools.

Compare hardware usage for different target platfroms.

Supports simulation with vendor primitive libraries, ships with script to pre-compile vendor libraries.

Vendor tools have bugs, check you IP cores when a new tool release is available, before changing code base

Who uses PoC?

PoC has a related Git repository called PoC-Examples on GitHub. This repository hosts a list of example and reference implementations of the PoC-Library. Additional to reading an IP cores documention and viewing its characteristic stimulus waveform in a simulation, it can helper to investigate an IP core usage example from that repository.

• The Q27 Project
  27-Queens Puzzle: Massively Parellel Enumeration and Solution Counting
• Reconfigurable Cloud Computing Framework (RC2F)
  An FPGA computing framework for virtualization and cloud integration.
• PicoBlaze-Library
  The PicoBlaze-Library offers several PicoBlaze devices and code routines to extend a common PicoBlaze environment to a little System on a Chip (SoC or SoFPGA).
• PicoBlaze-Examples
  A SoFPGA reference implementation, based on the PoC-Library and the PicoBlaze-Library.

Quick Start Guide

This Quick Start Guide gives a fast and simple introduction into PoC. All topics can be found in the Using PoC section with much more details and examples.

Requirements and Dependencies

The PoC-Library comes with some scripts to ease most of the common tasks, like running testbenches or generating IP cores. PoC uses Python 3 as a platform independent scripting environment. All Python scripts are wrapped in Bash or PowerShell scripts, to hide some platform specifics of Darwin, Linux or Windows. See Requirements for further details.

PoC requires:

• A supported synthesis tool chain, if you want to synthezise IP cores.
• A supported simulator too chain, if you want to simulate IP cores.
• The Python 3 programming language and runtime, if you want to use PoC’s infrastructure.
• A shell to execute shell scripts:
  • Bash on Linux and OS X
  • PowerShell on Windows

PoC optionally requires:

• Git command line tools or
• Git User Interface, if you want to check out the latest ‘master’ or ‘release’ branch.

PoC depends on third part libraries:

• THIRD:Cocotb
  A coroutine based cosimulation library for writing VHDL and Verilog testbenches in Python.
• THIRD:OSVVM
  Open Source VHDL Verification Methodology.
• THIRD:UVVM
  Universal VHDL Verification Methodology.
• THIRD:VUnit
  An unit testing framework for VHDL.

All dependencies are available as GitHub repositories and are linked to PoC as Git submodules into the PoCRoot\lib directory. See Third Party Libraries for more details on these libraries.

Download

The PoC-Library can be downloaded as a zip-file (latest ‘master’ branch), cloned with git clone or embedded with git submodule add from GitHub. GitHub offers HTTPS and SSH as transfer protocols. See the Download page for further details. The installation directory is referred to as PoCRoot.

Protocol	Git Clone Command
HTTPS	git clone --recursive https://github.com/VLSI-EDA/PoC.git PoC
SSH	git clone --recursive ssh://git@github.com:VLSI-EDA/PoC.git PoC

Configuring PoC on a Local System

To explore PoC’s full potential, it’s required to configure some paths and synthesis or simulation tool chains. The following commands start a guided configuration process. Please follow the instructions on screen. It’s possible to relaunch the process at any time, for example to register new tools or to update tool versions. See Configuration for more details. Run the following command line instructions to configure PoC on your local system:

cd PoCRoot
.\poc.ps1 configure

Use the keyboard buttons: Y to accept, N to decline, P to skip/pass a step and Return to accept a default value displayed in brackets.

Integration

The PoC-Library is meant to be integrated into other HDL projects. Therefore it’s recommended to create a library folder and add the PoC-Library as a Git submodule. After the repository linking is done, some short configuration steps are required to setup paths, tool chains and the target platform. The following command line instructions show a short example on how to integrate PoC.

1. Adding the Library as a Git submodule

The following command line instructions will create the folder lib\PoC\ and clone the PoC-Library as a Git submodule into that folder. ProjectRoot is the directory of the hosting Git. A detailed list of steps can be found at Integration.

cd ProjectRoot
mkdir lib | cd
git submodule add https://github.com:VLSI-EDA/PoC.git PoC
cd PoC
git remote rename origin github
cd ..\..
git add .gitmodules lib\PoC
git commit -m "Added new git submodule PoC in 'lib\PoC' (PoC-Library)."

2. Configuring PoC

The PoC-Library should be configured to explore its full potential. See Configuration for more details. The following command lines will start the configuration process:

cd ProjectRoot
.\lib\PoC\poc.ps1 configure

3. Creating PoC’s my_config.vhdl and my_project.vhdl Files

The PoC-Library needs two VHDL files for its configuration. These files are used to determine the most suitable implementation depending on the provided target information. Copy the following two template files into your project’s source folder. Rename these files to *.vhdl and configure the VHDL constants in the files:

cd ProjectRoot
cp lib\PoC\src\common\my_config.vhdl.template src\common\my_config.vhdl
cp lib\PoC\src\common\my_project.vhdl.template src\common\my_project.vhdl

my_config.vhdl defines two global constants, which need to be adjusted:

constant MY_BOARD            : string := "CHANGE THIS"; -- e.g. Custom, ML505, KC705, Atlys
constant MY_DEVICE           : string := "CHANGE THIS"; -- e.g. None, XC5VLX50T-1FF1136, EP2SGX90FF1508C3

my_project.vhdl also defines two global constants, which need to be adjusted:

constant MY_PROJECT_DIR      : string := "CHANGE THIS"; -- e.g. d:/vhdl/myproject/, /home/me/projects/myproject/"
constant MY_OPERATING_SYSTEM : string := "CHANGE THIS"; -- e.g. WINDOWS, LINUX

Further informations are provided at Creating my_config/my_project.vhdl.

4. Adding PoC’s Common Packages to a Synthesis or Simulation Project

PoC is shipped with a set of common packages, which are used by most of its modules. These packages are stored in the PoCRoot\src\common directory. PoC also provides a VHDL context in common.vhdl , which can be used to reference all packages at once.

5. Adding PoC’s Simulation Packages to a Simulation Project

Simulation projects additionally require PoC’s simulation helper packages, which are located in the PoCRoot\src\sim directory. Because some VHDL version are incompatible among each other, PoC uses version suffixes like *.v93.vhdl or *.v08.vhdl in the file name to denote the supported VHDL version of a file.

6. Compiling Shipped IP Cores

Some IP Cores are shipped are pre-configured vendor IP Cores. If such IP cores shall be used in a HDL project, it’s recommended to use PoC to create, compile and if needed patch these IP cores. See Synthesis for more details.

Run a Simulation

The following quick example uses the GHDL Simulator to analyze, elaborate and simulate a testbench for the module arith_prng (Pseudo Random Number Generator - PRNG). The VHDL file arith_prng.vhdl is located at PoCRoot\src\arith and virtually a member in the PoC.arith namespace. So the module can be identified by an unique name: PoC.arith.prng, which is passed to the frontend script.

Example:

cd PoCRoot
.\poc.ps1 ghdl PoC.arith.prng

The CLI command ghdl chooses GHDL Simulator as the simulator and passes the fully qualified PoC entity name PoC.arith.prng as a parameter to the tool. All required source file are gathered and compiled to an executable. Afterwards this executable is launched in CLI mode and its outputs are displayed in console:

Each testbench uses PoC’s simulation helper packages to count asserts and to track active stimuli and checker processes. After a completed simulation run, an report is written to STDOUT or the simulator’s console. Note the line SIMULATION RESULT = PASSED. For each simulated PoC entity, a line in the overall report is created. It lists the runtime per testbench and the simulation status (... ERROR, FAILED, NO ASSERTS or PASSED). See Simulation for more details.

Run a Synthesis

The following quick example uses the Xilinx Systesis Tool (XST) to synthesize a netlist for IP core arith_prng (Pseudo Random Number Generator - PRNG). The VHDL file arith_prng.vhdl is located at PoCRoot\src\arith and virtually a member in the PoC.arith namespace. So the module can be identified by an unique name: PoC.arith.prng, which is passed to the frontend script.

Example:

cd PoCRoot
.\poc.ps1 xst PoC.arith.prng --board=KC705

The CLI command xst chooses Xilinx Synthesis Tool as the synthesizer and passes the fully qualified PoC entity name PoC.arith.prng as a parameter to the tool. Additionally, the development board name is required to load the correct my_config.vhdl file. All required source file are gathered and synthesized to a netlist.

Updating

The PoC-Library can be updated by using git fetch and git merge.

cd PoCRoot
# update the local repository
git fetch --prune
# review the commit tree and messages, using the 'treea' alias
git treea
# if all changes are OK, do a fast-forward merge
git merge

See also

Running one or more testbenches

The installation can be checked by running one or more of PoC’s testbenches.

Running one or more netlist generation flows

The installation can also be checked by running one or more of PoC’s synthesis flows.

Get Involved

A first step might be to use and explore PoC and it’s infrastructure in an own project. Moreover, we encurage to read our online help which covers all aspects from quickstart example up to detailed IP core documentation. While using PoC, you might discover issues or missing feature. Please report them as listed below. If you have an interresting project, please send us feedback or get listed on our Who uses PoC? page.

If you are more familiar with PoC and it’s components, you might start asking youself how components internally work. Please read our more advanced topics in the online help, read our inline source code comments or start a discussion on Gitter to ask us directly.

Now you should be very familiar with our work and you might be interessted in developing own components and contribute them to the main repository. See the next section for detailed instructions on the Git fork, commit, push and pull-request flow.

PoC ships some third-party libraries. If you are interessted in getting your library or components shipped as part of PoC or as a third-party components, please contact us.

Report a Bug

Please report issues of any kind in our Git provider’s issue tracker. This allows us to categorize issues into groups and assign developers to them. You can track the issue’s state and see how it’s getting solved. All enhancements and feature requests are tracked on GitHub at GitHub Issues.

Feature Request

Please report missing features of any kind. We are allways looking forward to provide a full feature set. Please use our Git provider’s issue tracker to report enhancements and feature requests, so you can track the request’s status and implementation. All enhancements and feature requests are tracked on GitHub at GitHub Issues.

Talk to us on Gitter

You can chat with us on Gitter in our Giiter Room VLSI-EDA/PoC. You can use Gitter for free with your existing GitHub or Twitter account.

Contributers License Agreement

We require all contributers to sign a Contributor License Agreement (CLA). If you don’t know whatfore a CLA is needed and how it prevents legal issues on both sides, read this short blog post. PoC uses the Apache Contributor License Agreement to match the Apache License 2.0.

So to get started, sign the Contributor License Agreement (CLA) at CLAHub.com. You can authenticate yourself with an existing GitHub account.

Contribute to PoC

Contibuting source code via Git is very easy. We don’t provide direct write access to our repositories. Git offers the fork and pull-request philosophy, which means: You clone a repository, provide your changes in your own repository and notify us about outstanding changes via a pull-requests. We will then review your proposed changes and integrate them into our repository.

Steps 1 to 5 are done only once for setting up a forked repository.

1. Fork the PoC Repository

Git repositories can be cloned on a Git provider’s server. This procedure is called forking. This allows Git providers to track the repository’s network, check if repositories are related to each other and notify if pull-requests are available.

Fork our repository VLSI-EDA/PoC on GitHub into your or your’s Git organisation’s account. In the following the forked repository is referenced as <username>/PoC.

2. Clone the new Fork

Clone this new fork to your machine. See Downloading via Git clone for more details on how to clone PoC. If you have already cloned PoC, then you can setup the new fork as an additional remote. You should set VLSI-EDA/PoC as fetch target and the new fork <username>/PoC as push target.

Shell Commands for Cloning:

cd GitRoot
git clone --recursive "ssh://git@github.com:<username>/PoC.git" PoC
cd PoC
git remote rename origin github
git remote add upstream "ssh://git@github.com:VLSI-EDA/PoC.git"
git fetch --prune --tags

Shell Commands for Editing an existing Clone:

cd PoCRoot
git remote rename github upstream
git remote add github "ssh://git@github.com:<username>/PoC.git"
git fetch --prune --tags

These commands work for Git submodules too.

3. Checkout a Branch

Checkout the master or release branch and maybe stash outstanding changes.

cd PoCRoot
git checkout release

4. Setup PoC for Developers

Run PoC’s configuration routines and setup the developer tools.

cd PoCRoot
.\PoC.ps1 configure git

5. Create your own master Branch

Each developer has his own master branch. So create one and check it out.

cd PoCRoot
git branch <username>/master
git checkout <username>/master
git push github <username>/master

If PoC’s branches are moving forward, you can update your own master branch by merging changes into your branch.

6. Create your Feature Branch

Each new feature or bugfix is developed on a feature branch. Examples for branch names:

Branch name	Description
bugfix-utils	Fixes a bug in utils.vhdl.
docs-spelling	Fixes the documentation.
spi-controller	A new SPI controller implementation.

cd PoCRoot
git branch <username>/<feature>
git checkout <username>/<feature>
git push github <username>/<feature>

7. Commit and Push Changes

Commit your porposed changes onto your feature branch and push all changes to GitHub.

cd PoCRoot
# git add ....
git commit -m "Fixed a bug in function bounds() in utils.vhdl."
git push github <username>/<feature>

8. Create a Pull-Request

Go to your forked repository and klick on “Compare and Pull-Request” or go to our PoC repository and create a new pull request.

If this is your first Pull-Request, you need to sign our Contributers License Agreement (CLA).

9. Keep your master up-to-date

Todo

undocumented

Give us Feedback

Please send us feedback about the PoC documentation, our IP cores or your user story on how you use PoC.

List of Contributers

Contributor [1]	Contact E-Mail
Genßler, Paul	paul.genssler@tu-dresden.de
Köhler, Steffen	steffen.koehler@tu-dresden.de
Lehmann, Patrick [2]	patrick.lehmann@tu-dresden.de; paebbels@gmail.com
Preußer, Thomas B. [2]	thomas.preusser@tu-dresden.de; thomas.preusser@utexas.edu
Reichel, Peter	peter.reichel@eas.iis.fraunhofer.de; peter@peterreichel.info
Schirok, Jan	janschirok@gmx.net
Voß, Jens	jens.voss@mailbox.tu-dresden.de
Zabel, Martin [2]	martin.zabel@tu-dresden.de

---

Footnotes

[1]	In alphabetical order.

[2]	(1, 2, 3) Maintainer.

Using PoC

PoC can be used in several ways, if all Requirements are fulfilled. Chose one of the following integration kinds:

• Stand-Alone IP Core Library:

  Download PoC as archive file (*.zip) from GitHub as latest branch copy or as tagged release file. IP cores can be copyed into one or more destination projects or the projects link to the selected IP core source files.

  Advantages:

  • Simple and fast setup, configuring PoC is optional.
  • Needs less disk space than a Git repository.
  • After a configuration, PoC’s additional features: simulation, synthesis, etc. can be used.

  Disadvantages:

  • Manual updating via download and file overwrites.
  • Updated IP cores need to be copyed again into the destination project.
  • Using different PoC versions in different projects is not possible.
  • No possibility to contribute bugfixes and extensions via Git pull requests.

  Next steps:
  1. See Downloads for how to download a stand-alone version (*.zip-file) of the PoC-Library.
  2. See Configuration for how to configure PoC on a local system.

• Stand-Alone IP Core Library cloned from Git:

  Download PoC via git clone from GitHub as latest branch copy. IP cores can be copyed into one or more destination projects or the projects link to the selected IP core source files.

  Advantages:

  • Simple and fast setup, configuring PoC is optional.
  • Access to the newest commits on a branch: New IP cores, new features, bugfixes.
  • Fast and simple updates via git pull.
  • After a configuration, PoC’s additional features: simulation, synthesis, etc. can be used.
  • Contribute bugfixes and extensions via Git pull requests.

  Disadvantages:

  • Updated IP cores need to be copyed again into the destination project.
  • Using different PoC versions in different projects is not possible

  Next steps:
  1. See Downloads for how to clone a stand-alone version of the PoC-Library.
  2. See Configuration for how to configure PoC on a local system.

• Embedded IP Core Library as Git Submodule:

  Integrate PoC as a Git submodule into the destination projects Git repository.

  Advantages:

  • Simple and fast setup, configuring PoC is optional, but recommended.
  • Access to the newest commits on a branch: New IP cores, new features, bugfixes.
  • Fast and simple updates via git pull.
  • After a configuration, PoC’s additional features: simulation, synthesis, etc. can be used.
  • Moreover, some PoC infrastructure features can be used in the hosting repository and project as well.
  • Contribute bugfixes and extensions via Git pull requests.
  • Version linking between hosting Git and PoC.

  Next steps:
  1. See Integration for how to integrate PoC as a Git submodule into an existing Git.
  2. See Configuration for how to configure PoC on a local system.

Requirements

The PoC-Library comes with some scripts to ease most of the common tasks, like running testbenches or generating IP cores. We choose to use Python 3 as a platform independent scripting environment. All Python scripts are wrapped in Bash or PowerShell scripts, to hide some platform specifics of Darwin, Linux or Windows.

Common requirements:

Programming Languages and Runtime Environments:

• Python 3 (≥ 3.5):

  • colorama
  • py-flags

  All Python requirements are listed in requirements.txt and can be installed via:
  sudo python3.5 -m pip install -r requirements.txt

Synthesis tool chains:

• Altera Quartus II ≥ 13.0 or
• Altera Quartus Prime ≥ 15.1 or
• Intel Quartus Prime ≥ 16.1 or
• Lattice Diamond ≥ 3.6 or
• Xilinx ISE 14.7 [1] or
• Xilinx Vivado ≥ 2016.3 [2]

Simulation tool chains

• Aldec Active-HDL (or Student Edition) or
• Aldec Active-HDL Lattice Edition or
• Mentor Graphics ModelSim PE (or Student Edition) or
• Mentor Graphics ModelSim SE or
• Mentor Graphics ModelSim Altera Edition or
• Mentor Graphics QuestaSim or
• Xilinx ISE Simulator 14.7 or
• Xilinx Vivado Simulator ≥ 2016.3 [3] or
• GHDL ≥ 0.34dev and GTKWave ≥ 3.3.70

Linux specific requirements:

Debian and Ubuntu specific:

• bash is configured as /bin/sh (read more)
  dpkg-reconfigure dash

Optional Tools on Linux:

Git

The command line tools to manage Git repositories. It’s possible to extend the shell prompt with Git information.

SmartGit

A Git client to handle complex Git flows in a GUI.

Generic Colouriser (grc) ≥ 1.9

Colorizes outputs of foreign scripts and programs. GRC is hosted on GitHub The latest *.deb installation packages can be downloaded here.

Mac OS specific requirements:

Bash ≥ 4.3

Mac OS is shipped with Bash 3.2. Use Homebrew to install an up-to-date Bash
brew install bash

coreutils

Mac OS’ readlink program has a different behavior than the Linux version. The coreutils package installs a GNU readlink clone called greadlink.
brew install coreutils

Optional Tools on Mac OS:

Git

The command line tools to manage Git repositories. It’s possible to extend the shell prompt with Git information.

SmartGit or SourceTree

A Git client to handle complex Git flows in a GUI.

Generic Colouriser (grc) ≥ 1.9

Colorizes outputs of foreign scripts and programs. GRC is hosted on GitHub
brew install Grc

Windows specific requirements:

PowerShell

• Allow local script execution (read more)
  PS> Set-ExecutionPolicy RemoteSigned
• PowerShell ≥ 5.0 (recommended)
  PowerShell 5.0 is shipped since Windows 10. It is a part if the Windows Management Framework 5.0 (WMF). Windows 7 and 8/8.1 can be updated to WMF 5.0. The package does not include PSReadLine, which is included in the Windows 10 PowerShell environment. Install PSReadLine manually:
  PS> Install-Module PSReadline.
• PowerShell 4.0
  PowerShell is shipped with Windows since Vista. If the required version not already included in Windows, it can be downloaded from Microsoft.com: WMF 4.0

Optional Tools on Windows:

PowerShell ≥ 4.0

• PSReadLine replaces the command line editing experience in PowerShell for versions 3 and up.
• PowerShell Community Extensions (PSCX) ≥ 3.2
  The latest PSCX can be downloaded from PowerShellGallery
  PS> Install-Module Pscx
  Note: PSCX ≥ 3.2.1 is required for PowerShell ≥ 5.0.

Git (MSys-Git)

The command line tools to manage Git repositories.

SmartGit or SourceTree

A Git client to handle complex Git flows in a GUI.

posh-git

PowerShell integration for Git
PS> Install-Module posh-git

---

Footnotes

[1]	Xilinx discontinued ISE since Oct. 2013. The last release was 14.7.

[2]	Due to numerous bugs in the Xilinx Vivado Synthesis (incl. 2016.1), PoC can offer only a restricted Vivado support. See PoC’s Vivado branch for a set of workarounds. The list of issues is documented on the Known Issues page.

[3]	Due to numerous bugs in the Xilinx Simulator (incl. 2016.1), PoC can offer only a restricted Vivado support. The list of issues is documented on the Known Issues page.

Downloading PoC

Downloading from GitHub

The PoC-Library can be downloaded as a zip-file from GitHub. See the following table, to choose your desired git branch.

Branch	Download Link
master	zip-file
release	zip-file

Downloading via git clone

The PoC-Library can be downloaded (cloned) with git clone from GitHub. GitHub offers the transfer protocols HTTPS and SSH. You should use SSH if you have a GitHub account and have already uploaded an OpenSSH public key to GitHub, otherwise use HTTPS if you have no account or you want to use login credentials.

The created folder <GitRoot>\PoC is used as <PoCRoot> in later instructions or on other pages in this documentation.

Protocol	GitHub Repository URL
HTTPS	https://github.com/VLSI-EDA/PoC.git
SSH	ssh://git@github.com:VLSI-EDA/PoC.git

On Linux

Command line instructions to clone the PoC-Library onto a Linux machine with HTTPS protocol:

cd GitRoot
git clone --recursive "https://github.com/VLSI-EDA/PoC.git" PoC
cd PoC
git remote rename origin github

Command line instructions to clone the PoC-Library onto a Linux machine machine with SSH protocol:

cd GitRoot
git clone --recursive "ssh://git@github.com:VLSI-EDA/PoC.git" PoC
cd PoC
git remote rename origin github

On OS X

Please see the Linux instructions.

On Windows

Note

All Windows command line instructions are intended for Windows PowerShell, if not marked otherwise. So executing the following instructions in Windows Command Prompt (cmd.exe) won’t function or result in errors! See the Requirements section on where to download or update PowerShell.

Command line instructions to clone the PoC-Library onto a Windows machine with HTTPS protocol:

cd GitRoot
git clone --recursive "https://github.com/VLSI-EDA/PoC.git" PoC
cd PoC
git remote rename origin github

Command line instructions to clone the PoC-Library onto a Windows machine with SSH protocol:

cd GitRoot
git clone --recursive "ssh://git@github.com:VLSI-EDA/PoC.git" PoC
cd PoC
git remote rename origin github

Note

The option --recursive performs a recursive clone operation for all linked git submodules. An additional git submodule init and git submodule update call is not needed anymore.

Downloading via git submodule add

The PoC-Library is meant to be integrated into other HDL projects (preferably Git versioned projects). Therefore it’s recommended to create a library folder and add the PoC-Library as a git submodule.

The following command line instructions will create a library folder :file:`lib` and clone PoC as a git submodule into the subfolder :file:`<ProjectRoot>libPoC`.

On Linux

Command line instructions to clone the PoC-Library onto a Linux machine with HTTPS protocol:

cd ProjectRoot
mkdir lib
git submodule add "https://github.com/VLSI-EDA/PoC.git" lib/PoC
cd lib/PoC
git remote rename origin github
cd ../..
git add .gitmodules lib/PoC
git commit -m "Added new git submodule PoC in 'lib/PoC' (PoC-Library)."

Command line instructions to clone the PoC-Library onto a Linux machine machine with SSH protocol:

cd ProjectRoot
mkdir lib
git submodule add "ssh://git@github.com:VLSI-EDA/PoC.git" lib/PoC
cd lib/PoC
git remote rename origin github
cd ../..
git add .gitmodules lib/PoC
git commit -m "Added new git submodule PoC in 'lib/PoC' (PoC-Library)."

On OS X

Please see the Linux instructions.

On Windows

Note

All Windows command line instructions are intended for Windows PowerShell, if not marked otherwise. So executing the following instructions in Windows Command Prompt (cmd.exe) won’t function or result in errors! See the Requirements section on where to download or update PowerShell.

Command line instructions to clone the PoC-Library onto a Windows machine with HTTPS protocol:

cd <ProjectRoot>
mkdir lib | cd
git submodule add "https://github.com/VLSI-EDA/PoC.git" PoC
cd PoC
git remote rename origin github
cd ..\..
git add .gitmodules lib\PoC
git commit -m "Added new git submodule PoC in 'lib\PoC' (PoC-Library)."

Command line instructions to clone the PoC-Library onto a Windows machine with SSH protocol:

cd <ProjectRoot>
mkdir lib | cd
git submodule add "ssh://git@github.com:VLSI-EDA/PoC.git" PoC
cd PoC
git remote rename origin github
cd ..\..
git add .gitmodules lib\PoC
git commit -m "Added new git submodule PoC in 'lib\PoC' (PoC-Library)."

Integrating PoC into Projects

As a Git submodule

The following command line instructions will integrate PoC into a existing Git repository and register PoC as a Git submodule. Therefore a directory lib\PoC\ is created and the PoC-Library is cloned as a Git submodule into that directory.

On Linux

cd ProjectRoot
mkdir lib
cd lib
git submodule add https://github.com/VLSI-EDA/PoC.git PoC
cd PoC
git remote rename origin github
cd ../..
git add .gitmodules lib\PoC
git commit -m "Added new git submodule PoC in 'lib/PoC' (PoC-Library)."

On OS X

Please see the Linux instructions.

On Windows

Note

All Windows command line instructions are intended for Windows PowerShell, if not marked otherwise. So executing the following instructions in Windows Command Prompt (cmd.exe) won’t function or result in errors! See the Requirements section on where to download or update PowerShell.

cd ProjectRoot
mkdir lib | cd
git submodule add https://github.com/VLSI-EDA/PoC.git PoC
cd PoC
git remote rename origin github
cd ..\..
git add .gitmodules lib\PoC
git commit -m "Added new git submodule PoC in 'lib\PoC' (PoC-Library)."

See also

Configuring PoC on a Local System

Create PoC’s VHDL Configuration Files

Configuring PoC’s Infrastructure

To explore PoC’s full potential, it’s required to configure some paths and synthesis or simulation tool chains. It’s possible to relaunch the process at any time, for example to register new tools or to update tool versions.

Overview

The setup process is started by invoking PoC’s frontend script with the command configure. Please follow the instructions on screen. Use the keyboard buttons: Y to accept, N to decline, P to skip/pass a step and Return to accept a default value displayed in brackets.

Optionally, a vendor or tool chain name can be passed to the configuration process to launch only its configuration routines.

On Linux:

cd ProjectRoot
./lib/PoC/poc.sh configure
# with tool chain name
./lib/PoC/poc.sh configure Xilinx.Vivado

On OS X

Please see the Linux instructions.

On Windows

Note

All Windows command line instructions are intended for Windows PowerShell, if not marked otherwise. So executing the following instructions in Windows Command Prompt (cmd.exe) won’t function or result in errors! See the Requirements section on where to download or update PowerShell.

cd ProjectRoot
.\lib\PoC\poc.ps1 configure
# with tool chain name
.\lib\PoC\poc.ps1 configure Xilinx.Vivado

Introduction screen:

PS D:\git\PoC> .\poc.ps1 configure
================================================================================
                         The PoC-Library - Service Tool
================================================================================
Explanation of abbreviations:
  Y - yes      P        - pass (jump to next question)
  N - no       Ctrl + C - abort (no changes are saved)
Upper case or value in '[...]' means default value
--------------------------------------------------------------------------------

Configuring PoC
  PoC version: v1.0.1 (found in git)
  Installation directory: D:\git\PoC (found in environment variable)

The PoC-Library

PoC itself has a fully automated configuration routine. It detects if PoC is under Git control. If so, it extracts the current version number from the latest Git tag. The installation directory is infered from $PoCRootDirectory setup by PoC.ps1 or poc.sh.

Configuring PoC
  PoC version: v1.0.1 (found in git)
  Installation directory: D:\git\PoC (found in environment variable)

Git

Note

Setting up Git and Git developer settings, is an advanced feature recommended for all developers interrested in providing Git pull requests or patches.

Configuring Git
  Git installation directory [C:\Program Files\Git]:
  Install Git mechanisms for PoC developers? [y/N/p]: y
  Install Git filters? [Y/n/p]:
  Installing Git filters...
  Install Git hooks? [Y/n/p]:
  Installing Git hooks...
  Setting 'pre-commit' hook for PoC...

Aldec

Configure the installation directory for all Aldec tools.

Configuring Aldec
  Are Aldec products installed on your system? [Y/n/p]: Y
  Aldec installation directory [C:\Aldec]:

Active-HDL

Configuring Aldec Active-HDL
  Is Aldec Active-HDL installed on your system? [Y/n/p]: Y
  Aldec Active-HDL version [10.3]:
  Aldec Active-HDL installation directory [C:\Aldec\Active-HDL]: C:\Aldec\Active-HDL-Student-Edition

Altera

Configure the installation directory for all Altera tools.

    Configuring Altera
Are Altera products installed on your system? [Y/n/p]: Y
Altera installation directory [C:\Altera]:

Quartus

Configuring Altera Quartus
  Is Altera Quartus-II or Quartus Prime installed on your system? [Y/n/p]: Y
  Altera Quartus version [15.1]: 16.0
  Altera Quartus installation directory [C:\Altera\16.0\quartus]:

ModelSim Altera Edition

Configuring ModelSim Altera Edition
  Is ModelSim Altera Edition installed on your system? [Y/n/p]: Y
  ModelSim Altera Edition installation directory [C:\Altera\15.0\modelsim_ae]: C:\Altera\16.0\modelsim_ase

Lattice

Configure the installation directory for all Lattice Semiconductor tools.

Configuring Lattice
  Are Lattice products installed on your system? [Y/n/p]: Y
  Lattice installation directory [D:\Lattice]:

Diamond

Configuring Lattice Diamond
  Is Lattice Diamond installed on your system? [Y/n/p]: >
  Lattice Diamond version [3.7]:
  Lattice Diamond installation directory [D:\Lattice\Diamond\3.7_x64]:

Active-HDL Lattice Edition

Configuring Active-HDL Lattice Edition
  Is Aldec Active-HDL installed on your system? [Y/n/p]: Y
  Active-HDL Lattice Edition version [10.2]:
  Active-HDL Lattice Edition installation directory [D:\Lattice\Diamond\3.7_x64\active-hdl]:

Mentor Graphics

Configure the installation directory for all mentor Graphics tools.

Configuring Mentor
  Are Mentor products installed on your system? [Y/n/p]: Y
  Mentor installation directory [C:\Mentor]:

QuestaSim

Configuring Mentor QuestaSim
  Is Mentor QuestaSim installed on your system? [Y/n/p]: Y
  Mentor QuestaSim version [10.4d]: 10.4c
  Mentor QuestaSim installation directory [C:\Mentor\QuestaSim\10.4c]: C:\Mentor\QuestaSim64\10.4c

Xilinx

Configure the installation directory for all Xilinx tools.

Configuring Xilinx
  Are Xilinx products installed on your system? [Y/n/p]: Y
  Xilinx installation directory [C:\Xilinx]:

ISE

If an Xilinx ISE environment is available and shall be configured in PoC, then answer the following questions:

Configuring Xilinx ISE
  Is Xilinx ISE installed on your system? [Y/n/p]: Y
  Xilinx ISE installation directory [C:\Xilinx\14.7\ISE_DS]:

Vivado

If an Xilinx ISE environment is available and shall be configured in PoC, then answer the following questions:

Configuring Xilinx Vivado
  Is Xilinx Vivado installed on your system? [Y/n/p]: Y
  Xilinx Vivado version [2016.2]:
  Xilinx Vivado installation directory [C:\Xilinx\Vivado\2016.2]:

GHDL

Configuring GHDL
  Is GHDL installed on your system? [Y/n/p]: Y
  GHDL installation directory [C:\Tools\GHDL\0.34dev]:

GTKWave

Configuring GTKWave
  Is GTKWave installed on your system? [Y/n/p]: Y
  GTKWave installation directory [C:\Tools\GTKWave\3.3.71]:

Hook Files

PoC’s wrapper scripts can be customized through pre- and post-hook file. See Wrapper Script Hook Files for more details.

Creating my_config/my_project.vhdl

The PoC-Library needs two VHDL files for its configuration. These files are used to determine the most suitable implementation depending on the provided platform information. These files are also used to select appropiate work arounds.

Create my_config.vhdl

The my_config.vhdl file can easily be created from the template file my_config.vhdl.template provided by PoC in PoCRoot\src\common. (View source on GitHub.) Copy this file into the project’s source directory and rename it to my_config.vhdl.

This file should be included in version control systems and shared with other systems. my_config.vhdl defines three global constants, which need to be adjusted:

constant MY_BOARD   : string  := "CHANGE THIS"; -- e.g. Custom, ML505, KC705, Atlys
constant MY_DEVICE  : string  := "CHANGE THIS"; -- e.g. None, XC5VLX50T-1FF1136, EP2SGX90FF1508C3
constant MY_VERBOSE : boolean := FALSE;         -- activate report statements in VHDL subprograms

The easiest way is to define a board name and set MY_DEVICE to None. So the device name is infered from the board information stored in PoCRoot\src\common\config.vhdl. If the requested board is not known to PoC or it’s custom made, then set MY_BOARD to Custom and MY_DEVICE to the full FPGA device string.

Example 1: A “Stratix II GX Audio Video Development Kit” board:

constant MY_BOARD  : string := "S2GXAV";  -- Stratix II GX Audio Video Development Kit
constant MY_DEVICE : string := "None";    -- infer from MY_BOARD

Example 2: A custom made Spartan-6 LX45 board:

constant MY_BOARD  : string := "Custom";
constant MY_DEVICE : string := "XC6SLX45-3CSG324";

Create my_project.vhdl

The my_project.vhdl file can also be created from a template file my_project.vhdl.template provided by PoC in PoCRoot\src\common.

The file should to be copyed into a projects source directory and renamed into my_project.vhdl. This file must not be included into version control systems – it’s private to a computer. my_project.vhdl defines two global constants, which need to be adjusted:

constant MY_PROJECT_DIR      : string := "CHANGE THIS"; -- e.g. "d:/vhdl/myproject/", "/home/me/projects/myproject/"
constant MY_OPERATING_SYSTEM : string := "CHANGE THIS"; -- e.g. "WINDOWS", "LINUX"

Example 1: A Windows System:

constant MY_PROJECT_DIR      : string := "D:/git/GitHub/PoC/";
constant MY_OPERATING_SYSTEM : string := "WINDOWS";

Example 2: A Debian System:

constant MY_PROJECT_DIR      : string := "/home/paebbels/git/GitHub/PoC/";
constant MY_OPERATING_SYSTEM : string := "LINUX";

See also

Running one or more testbenches

The installation can be checked by running one or more of PoC’s testbenches.

Running one or more netlist generation flows

The installation can also be checked by running one or more of PoC’s synthesis flows.

Adding IP Cores to a Project

Manually Addind IP Cores

Adding IP Cores to Altera Quartus

Todo

No documentation available.

Adding IP Cores to Lattice Diamond

Todo

No documentation available.

Adding IP Cores to Xilinx ISE

Todo

No documentation available.

Adding IP Cores to Xilinx Vivado

Todo

No documentation available.

Simulation

Overview

The Python Infrastructure shipped with the PoC-Library can launch manual, half-automated and fully automated testbenches. The testbench can be run in command line or GUI mode. If available, the used simulator is launched with pre-configured waveform files. This can be done by invoking one of PoC’s frontend script:

• poc.sh: poc.sh <common options> <simulator> <module> <simulator options>
  Use this fronend script on Darwin, Linux and Unix platforms.

• poc.ps1: poc.ps1 <common options> <simulator> <module> <simulator options>
  Use this frontend script Windows platforms.
  

  Attention

  All Windows command line instructions are intended for Windows PowerShell, if not marked otherwise. So executing the following instructions in Windows Command Prompt (cmd.exe) won’t function or result in errors!

See also

PoC Configuration

See the Configuration page on how to configure PoC and your installed simulator tool chains. This is required to invoke the simulators.

Supported Simulators

See the Intruction page for a list of supported simulators.

Quick Example

The following quick example uses the GHDL Simulator to analyze, elaborate and simulate a testbench for the module arith_prng (Pseudo Random Number Generator - PRNG). The VHDL file arith_prng.vhdl is located at PoCRoot\src\arith and virtually a member in the PoC.arith namespace. So the module can be identified by an unique name: PoC.arith.prng, which is passed to the frontend script.

Example 1:

cd PoCRoot
.\poc.ps1 ghdl PoC.arith.prng

The CLI command ghdl chooses GHDL Simulator as the simulator and passes the fully qualified PoC entity name PoC.arith.prng as a parameter to the tool. All required source file are gathered and compiled to an executable. Afterwards this executable is launched in CLI mode and it’s outputs are displayed in console:

Each testbench uses PoC’s simulation helper packages to count asserts and to track active stimuli and checker processes. After a completed simulation run, an report is written to STDOUT or the simulator’s console. Note the line SIMULATION RESULT = PASSED. For each simulated PoC entity, a line in the overall report is created. It lists the runtime per testbench and the simulation status (... ERROR, FAILED, NO ASSERTS or PASSED).

Example 2:

Passing an additional option --gui to the service tool, opens the testbench in GUI-mode. If a waveform configuration file is present (e.g. a *.gtkw file for GTKWave), then it is preloaded into the simulator’s waveform viewer.

cd PoCRoot
.\poc.ps1 ghdl PoC.arith.prng --gui

The opened waveform viewer and displayed waveform should look like this:

Vendor Specific Testbenches

PoC is shipped with a set of well known FPGA development boards. This set is extended by a list of generic boards, named after each supported FPGA vendor. These generic boards can be used in simulations to select a representative FPGA of a supported device vendor. If no board or device name is passed to a testbench run, the GENERIC board is chosen.

Board Name	Target Board	Target Device
GENERIC	GENERIC	GENERIC
Altera	DE4	Stratix-IV 230
Lattice	ECP5Versa	ECP5-45UM
Xilinx	KC705	Kintex-7 325T

A vendor specific testbench can be launched by passing either --board=xxx or --device=yyy as an additional parameter to the PoC scripts.

# Example 1 - A Lattice board
.\poc.ps1 ghdl PoC.arith.prng --board=Lattice
# Example 2 - A Altera Stratix IV board
.\poc.ps1 ghdl PoC.arith.prng --board=DE4
# Example 3 - A Xilinx Kintex-7 325T device
.\poc.ps1 ghdl PoC.arith.prng --device=XC7K325T-2FFG900

Note

Running vendor specific testbenches may require pre-compiled vendor libraries. Some simulators are shipped with diverse pre-compiled libraries, others include scripts or user guides to pre-compile them on the target system.

PoC is shipped with a set of pre-compile scripts to offer a unified interface and common storage for all supported vendor’s pre-compile procedures. See Pre-Compiling Vendor Libraries.

Running a Single Testbench

A testbench run is supervised by PoC’s PoCRoot\py\PoC.py service tool, which offers a consistent interface to all simulators. Unfortunately, every platform has it’s specialties, so a wrapper script is needed as abstraction from the host’s operating system. Depending on the choosen tool chain, the wrapper script will source or invoke the vendor tool’s environment scripts to pre-load the needed environment variables, paths or license file settings.

The order of options to the frontend script is as following: <common options> <simulator> <module> <simulator options>

The frontend offers several common options:

Common Option		Description
-q	–quiet	Quiet-mode (print nothing)
-v	–verbose	Print more messages
-d	–debug	Debug mode (print everything)
	–dryrun	Run in dry-run mode

One of the following supported simulators can be choosen, if installed and configured in PoC:

Simulator	Description
asim	Active-HDL Simulator
cocotb	Cocotb simulation using QuestaSim Simulator
ghdl	GHDL Simulator
isim	Xilinx ISE Simulator
vsim	QuestaSim Simulator or ModelSim
xsim	Xilinx Vivado Simulator

A testbench run can be interrupted by sending a keyboard interrupt to Python. On most operating systems this is done by pressing Ctrl + C. If PoC runs multiple testbenches at once, all finished testbenches are reported with there testbench result. The aborted testbench will be listed as errored.

Aldec Active-HDL

The command to invoke a simulation using Active-HDL is asim followed by a list of PoC entities. The following options are supported for Active-HDL:

Simulator Option		Description
	–board=<BOARD>	Specify a target board.
	–device=<DEVICE>	Specify a target device.
	–std=[87|93|02|08]	Select a VHDL standard. Default: 08

Note

GUI mode for Active-HDL is not yet supported.

Example:

cd PoCRoot
.\poc.ps1 asim PoC.arith.prng --std=93

Cocotb with QuestaSim backend

The command to invoke a Cocotb simulation using QuestaSim is cocotb followed by a list of PoC entities. The following options are supported for Cocotb:

Simulator Option		Description
	–board=<BOARD>	Specify a target board.
	–device=<DEVICE>	Specify a target device.
-g	–gui	Start the simulation in the QuestaSim GUI.

Note

Cocotb is currently only on Linux with QuestaSim supported. We are working to support the Windows platform and the GHDL backend.

Example:

cd PoCRoot
.\poc.ps1 cocotb PoC.cache.par

GHDL (plus GTKwave)

The command to invoke a simulation using GHDL is ghdl followed by a list of PoC entities. The following options are supported for GHDL:

Simulator Option		Description
	–board=<BOARD>	Specify a target board.
	–device=<DEVICE>	Specify a target device.
-g	–gui	Start GTKwave, if installed. Open *.gtkw, if available.
	–std=[87|93|02|08]	Select a VHDL standard. Default: 08

Example:

cd PoCRoot
.\poc.ps1 ghdl PoC.arith.prng --board=Atlys -g

Mentor Graphics QuestaSim

The command to invoke a simulation using QuestaSim or ModelSim is vsim followed by a list of PoC entities. The following options are supported for QuestaSim:

Simulator Option		Description
	–board=<BOARD>	Specify a target board.
	–device=<DEVICE>	Specify a target device.
-g	–gui	Start the simulation in the QuestaSim GUI.
	–std=[87|93|02|08]	Select a VHDL standard. Default: 08

Example:

cd PoCRoot
.\poc.ps1 vsim PoC.arith.prng --board=DE4 --gui

If QuestaSim is started in GUI mode (--gui), PoC will provide several Tcl files (*.do) in the simulator’s working directory to recompile, restart or rerun the current simulation. The rerun command is based on the saved IP core’s run script, which may default to run -all.

Tcl Script	Performed Tasks
recompile.do	recompile and restart
relaunch.do	recompile, restart and rerun
saveWaveform.do	save the current waveform viewer settings

Xilinx ISE Simulator

The command to invoke a simulation using ISE Simulator (isim) is isim followed by a list of PoC entities. The following options are supported for ISE Simulator:

Simulator Option		Description
	–board=<BOARD>	Specify a target board.
	–device=<DEVICE>	Specify a target device.
-g	–gui	Start the simulation in the ISE Simulator GUI (iSim).

Example:

cd PoCRoot
.\poc.ps1 isim PoC.arith.prng --board=Atlys -g

Xilinx Vivado Simulator

The command to invoke a simulation using Vivado Simulator (isim) is xsim followed by a list of PoC entities. The following options are supported for Vivado Simulator:

Simulator Option		Description
	–board=<BOARD>	Specify a target board.
	–device=<DEVICE>	Specify a target device.
-g	–gui	Start Vivado in simulation mode.
	–std=[93|08]	Select a VHDL standard. Default: 93

Example:

cd PoCRoot
.\poc.ps1 xsim PoC.arith.prng --board=Atlys -g

Running a Group of Testbenches

Each simulator can be invoked with a space seperated list of PoC entiries or a wildcard at the end of the fully qualified entity name.

Supported wildcard patterns are * and ?. Question mark refers to all entities in a PoC (sub-)namespace. Asterisk refers to all PoC entiries in the current namespace and all sub-namespaces.

Examples for testbenches groups:

PoC entity list	Description
PoC.arith.prng	A single PoC entity: arith_prng
PoC.*	All entities in the whole library
PoC.io.ddrio.?	All entities in PoC.io.ddrio: ddrio_in, ddrio_inout, ddrio_out
PoC.fifo.* PoC.cache.* PoC.dstruct.*	All FIFO, cache and data-structure testbenches.

cd PoCRoot
.\poc.ps1 -q asim PoC.arith.prng PoC.io.ddrio.* PoC.sort.lru_cache

Resulting output:

Continuous Integration (CI)

All PoC testbenches are executed on every GitHub upload (push) via Travis-CI. The testsuite runs all testbenches for the virtual board GENERIC with an FPGA device called GENERIC. We can’t run vendor dependent testbenches, because we can’t upload the vendor simulation libraries to Travis-CI.

To reproduce the Travis-CI results on a local machine, run the following command. The -q option, launches the frontend in quiet mode to reduce the command line messages:

cd PoCRoot
.\poc.ps1 -q ghdl PoC.*

If the vendor libraries are available and pre-compiled, then it’s also possible to run a CI flow for a specific vendor. This is an Altera example for the Terrasic DE4 board:

cd PoCRoot
.\poc.ps1 -q vsim PoC.* --board=DE4

See also

PoC Configuration

See the Configuration page on how to configure PoC and your installed simulator tool chains. This is required to invoke the simulators.

Latest Travis-CI Report

Browse the list of branches at Travis-CI.org.

Synthesis

Overview

The Python infrastructure shipped with the PoC-Library can launch manual, half-automated and fully automated synthesis runs. This can be done by invoking one of PoC’s frontend script:

• poc.sh: poc.sh <common options> <compiler> <module> <compiler options>
  Use this fronend script on Darwin, Linux and Unix platforms.

• poc.ps1: poc.ps1 <common options> <compiler> <module> <compiler options>
  Use this frontend script Windows platforms.
  

  Attention

  All Windows command line instructions are intended for Windows PowerShell, if not marked otherwise. So executing the following instructions in Windows Command Prompt (cmd.exe) won’t function or result in errors!

See also

PoC Configuration

See the Configuration page on how to configure PoC and your installed synthesis tool chains. This is required to invoke the compilers.

Supported Compiler

See the Intruction page for a list of supported compilers.

See also

List of Supported FPGA Devices

See this list to find a supported and well known target device.

List of Supported Development Boards

See this list to find a supported and well known development board.

Quick Example

The following quick example uses the Xilinx Systesis Tool (XST) to synthesize a netlist for IP core arith_prng (Pseudo Random Number Generator - PRNG). The VHDL file arith_prng.vhdl is located at PoCRoot\src\arith and virtually a member in the PoC.arith namespace. So the module can be identified by an unique name: PoC.arith.prng, which is passed to the frontend script.

Example 1:

cd PoCRoot
.\poc.ps1 xst PoC.arith.prng --board=KC705

The CLI command xst chooses Xilinx Synthesis Tool as the synthesizer and passes the fully qualified PoC entity name PoC.arith.prng as a parameter to the tool. Additionally, the development board name is required to load the correct my_config.vhdl file. All required source file are gathered and synthesized to a netlist.

Running a single Synthesis

A synthesis run is supervised by PoC’s PoCRoot\py\PoC.py service tool, which offers a consistent interface to all synthesizers. Unfortunately, every platform has it’s specialties, so a wrapper script is needed as abstraction from the host’s operating system. Depending on the choosen tool chain, the wrapper script will source or invoke the vendor tool’s environment scripts to pre-load the needed environment variables, paths or license file settings.

The order of options to the frontend script is as following: <common options> <synthesizer> <module> [<module>] <synthesizer options>

The frontend offers several common options:

Common Option		Description
-q	--quiet	Quiet-mode (print nothing)
-v	--verbose	Print more messages
-d	--debug	Debug mode (print everything)
	--dryrun	Run in dry-run mode

One of the following supported synthesizers can be choosen, if installed and configured in PoC:

Synthesizer	Command Reference
Altera Quartus II or Intel Quartus Prime	PoC.py quartus
Lattice (Diamond) Synthesis Engine (LSE)	PoC.py lse
Xilinx ISE Systhesis Tool (XST)	PoC.py xst
Xilinx ISE Core Generator (CoreGen)	PoC.py coregen
Xilinx Vivado Synthesis	PoC.py vivado

Altera / Intel Quartus

The command to invoke a synthesis using Altera Quartus II or Intel Quartus Prime is quartus followed by a list of PoC entities. The following options are supported for Quartus:

Simulator Option		Description
	--board=<Board>	Specify a target board.
	--device=<Device>	Specify a target device.

Example:

cd PoCRoot
.\poc.ps1 quartus PoC.arith.prng --board=DE4

Lattice Diamond

The command to invoke a synthesis using Lattice Diamond is lse followed by a list of PoC entities. The following options are supported for the Lattice Synthesis Engine (LSE):

Simulator Option		Description
	--board=<Board>	Specify a target board.
	--device=<Device>	Specify a target device.

Example:

cd PoCRoot
.\poc.ps1 lse PoC.arith.prng --board=ECP5Versa

Xilinx ISE Synthesis Tool (XST)

The command to invoke a synthesis using Xilinx ISE Synthesis is xst followed by a list of PoC entities. The following options are supported for the Xilinx Synthesis Tool (XST):

Simulator Option		Description
	--board=<Board>	Specify a target board.
	--device=<Device>	Specify a target device.

Example:

cd PoCRoot
.\poc.ps1 xst PoC.arith.prng --board=KC705

Xilinx ISE Core Generator

The command to invoke an IP core generation using Xilinx Core Generator is coregen followed by a list of PoC entities. The following options are supported for Core Generator (CG):

Simulator Option		Description
	--board=<Board>	Specify a target board.
	--device=<Device>	Specify a target device.

Example:

cd PoCRoot
.\poc.ps1 coregen PoC.xil.mig.Atlys_1x128 --board=Atlys

Xilinx Vivado Synthesis

The command to invoke a synthesis using Xilinx Vivado Synthesis is vivado followed by a list of PoC entities. The following options are supported for Vivado Synthesis (Synth):

Simulator Option		Description
	--board=<Board>	Specify a target board.
	--device=<Device>	Specify a target device.

Example:

cd PoCRoot
.\poc.ps1 vivado PoC.arith.prng --board=KC705

Project Management

Overview

Solutions

Projects

Pre-Compiling Vendor Libraries

Overview

Running vendor specific testbenches may require pre-compiled vendor libraries. Some vendors ship their simulators with diverse pre-compiled libraries, but these don’t include primitive libraries from hardware vendors. More over, many auxillary libraries are outdated. Hardware vendors ship their tool chains with pre-compile scripts or user guides to pre-compile the primitive libraries for a list of supported simulators on a target system.

PoC is shipped with a set of pre-compile scripts to offer a unified interface and common storage for all supported vendor’s pre-compile procedures. The scripts are located in \tools\precompile\ and the output is stored in \temp\precompiled\<Simulator>\<Library>.

Supported Simulators

The current set of pre-compile scripts support these simulators:

Vendor	Simulator and Edition	Altera	Lattice	Xilinx (ISE)	Xilinx (Vivado)
Gingold	GHDL with --std=93c GHDL with --std=08	yes yes	yes yes	yes yes	yes yes
Aldec	Active-HDL (or Stududent Ed.) Active-HDL Lattice Ed. Reviera-PRO	planned planned planned	planned shipped planned	planned planned planned	planned planned planned
Mentor	ModelSim PE (or Stududent Ed.) ModelSim SE ModelSim Altera Ed. QuestaSim	yes yes shipped yes	yes yes yes yes	yes yes yes yes	yes yes yes yes
Xilinx	ISE Simulator Vivado Simulator			shipped not supported	not supported shipped

FPGA Vendor’s Primitive Libraries

Altera

Note

The Altera Quartus tool chain needs to be configured in PoC.
See Configuring PoC’s Infrastruture for further details.

On Linux

# Example 1 - Compile for all Simulators
./tools/precompile/compile-altera.sh --all
# Example 2 - Compile only for GHDL and VHDL-2008
./tools/precompile/compile-altera.sh --ghdl --vhdl2008

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.
	--vhdl93	GHDL only: Compile only for VHDL-93.
	--vhdl2008	GHDL only: Compile only for VHDL-2008.

On Windows

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-altera.ps1 -All
# Example 2 - Compile only for GHDL and VHDL-2008
.\tools\precompile\compile-altera.ps1 -GHDL -VHDL2008

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.
	-VHDL93	GHDL only: Compile only for VHDL-93.
	-VHDL2008	GHDL only: Compile only for VHDL-2008.

Lattice

Note

The Lattice Diamond tool chain needs to be configured in PoC.
See Configuring PoC’s Infrastruture for further details.

On Linux

# Example 1 - Compile for all Simulators
./tools/precompile/compile-lattice.sh --all
# Example 2 - Compile only for GHDL and VHDL-2008
./tools/precompile/compile-lattice.sh --ghdl --vhdl2008

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.
	--vhdl93	GHDL only: Compile only for VHDL-93.
	--vhdl2008	GHDL only: Compile only for VHDL-2008.

On Windows

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-lattice.ps1 -All
# Example 2 - Compile only for GHDL and VHDL-2008
.\tools\precompile\compile-lattice.ps1 -GHDL -VHDL2008

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.
	-VHDL93	GHDL only: Compile only for VHDL-93.
	-VHDL2008	GHDL only: Compile only for VHDL-2008.

Xilinx ISE

Note

The Xilinx ISE tool chain needs to be configured in PoC.
See Configuring PoC’s Infrastruture for further details.

On Linux

# Example 1 - Compile for all Simulators
./tools/precompile/compile-xilinx-ise.sh --all
# Example 2 - Compile only for GHDL and VHDL-2008
./tools/precompile/compile-xilinx-ise.sh --ghdl --vhdl2008

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.
	--vhdl93	GHDL only: Compile only for VHDL-93.
	--vhdl2008	GHDL only: Compile only for VHDL-2008.

On Windows

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-xilinx-ise.ps1 -All
# Example 2 - Compile only for GHDL and VHDL-2008
.\tools\precompile\compile-xilinx-ise.ps1 -GHDL -VHDL2008

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.
	-VHDL93	GHDL only: Compile only for VHDL-93.
	-VHDL2008	GHDL only: Compile only for VHDL-2008.

Xilinx Vivado

Note

The Xilinx Vivado tool chain needs to be configured in PoC.
See Configuring PoC’s Infrastruture for further details.

On Linux

# Example 1 - Compile for all Simulators
./tools/precompile/compile-xilinx-vivado.sh --all
# Example 2 - Compile only for GHDL and VHDL-2008
./tools/precompile/compile-xilinx-vivado.sh --ghdl --vhdl2008

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.
	--vhdl93	GHDL only: Compile only for VHDL-93.
	--vhdl2008	GHDL only: Compile only for VHDL-2008.

On Windows

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-xilinx-vivado.ps1 -All
# Example 2 - Compile only for GHDL and VHDL-2008
.\tools\precompile\compile-xilinx-vivado.ps1 -GHDL -VHDL2008

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.
	-VHDL93	GHDL only: Compile only for VHDL-93.
	-VHDL2008	GHDL only: Compile only for VHDL-2008.

Third-Party Libraries

OSVVM

On Linux

# Example 1 - Compile for all Simulators
./tools/precompile/compile-osvvm.sh --all
# Example 2 - Compile only for GHDL
./tools/precompile/compile-osvvm.sh --ghdl

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.

On Windows

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-osvvm.ps1 -All
# Example 2 - Compile only for GHDL
.\tools\precompile\compile-osvvm.ps1 -GHDL

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.

UVVM

On Linux

# Example 1 - Compile for all Simulators
./tools/precompile/compile-uvvm.sh --all
# Example 2 - Compile only for GHDL
./tools/precompile/compile-uvvm.sh --ghdl

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.

On Windows

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-uvvm.ps1 -All
# Example 2 - Compile only for GHDL
.\tools\precompile\compile-uvvm.ps1 -GHDL

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.

Simulator Adapters

Cocotb

On Linux

Attention

This is an experimental compile script.

# Example 1 - Compile for all Simulators
./tools/precompile/compile-cocotb.sh --all
# Example 2 - Compile only for GHDL
./tools/precompile/compile-cocotb.sh --ghdl

List of command line arguments:

Common Option		Parameter Description
-h	--help	Print embedded help page(s).
-c	--clean	Clean-up directories.
-a	--all	Compile for all simulators.
	--ghdl	Compile for GHDL.
	--questa	Compile for QuestaSim.

On Windows

Attention

This is an experimental compile script.

# Example 1 - Compile for all Simulators
.\tools\precompile\compile-cocotb.ps1 -All
# Example 2 - Compile only for GHDL
.\tools\precompile\compile-cocotb.ps1 -GHDL

List of command line arguments:

Common Option		Parameter Description
-h	-Help	Print embedded help page(s).
-c	-Clean	Clean-up directories.
-a	-All	Compile for all simulators.
	-GHDL	Compile for GHDL.
	-Questa	Compile for QuestaSim.

Miscellaneous

The directory PoCRoot\tools\ contains several tools and addons to ease the work with the PoC-Library and VHDL.

GNU Emacs

Todo

No documentation available.

Git

• git-alias.setup.ps1/git-alias.setup.sh registers new global aliasses in Git

  • git tree - Prints the colored commit tree into the console
  • git treea - Prints the colored commit tree into the console

  git config --global alias.tree 'log --decorate --pretty=oneline --abbrev-commit --date-order --graph'
  git config --global alias.tree 'log --decorate --pretty=oneline --abbrev-commit --date-order --graph --all'
  

Browse the Git directory.

Notepad++

The PoC-Library is shipped with syntax highlighting rules for Notepad++. The following additional file types are supported:

• PoC Configuration Files (*.ini)
• PoC .Files Files (.files)
• PoC .Rules Files (.rules)
• Xilinx User Constraint Files (*.ucf): Syntax Highlighting - Xilinx UCF

Browse the Notepad++ directory.

Third Party Libraries

The pyIPCMI is shipped with different third party libraries, which are located in the <pyIPCMIRoot>/lib/ folder. This document lists all these libraries, their websites and licenses.

IP Core Management Infrastructure

pyIPCMI.py

Submodules

pyIPCMI.Base.py

Submodules

pyIPCMI.Base.Exceptions.py

Exceptions

• ExceptionBase: Base exception derived from Exception for all
• EnvironmentException: EnvironmentException is raised when an expected environment variable is
• PlatformNotSupportedException: PlatformNotSupportedException is raise if the platform is not supported
• NotConfiguredException: NotConfiguredException is raise if pyIPCMI or the requested tool chain
• SkipableException: Base class for all skipable exceptions.
• CommonException: Base exception derived from Exception for all
• SkipableCommonException: SkipableCommonException is a CommonException, which can be

exception pyIPCMI.Base.Exceptions.ExceptionBase(message='')

Base exception derived from Exception for all custom exceptions in pyIPCMI.

Inheritance

Members

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

args

exception pyIPCMI.Base.Exceptions.EnvironmentException(message='')

EnvironmentException is raised when an expected environment variable is missing for pyIPCMI.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Base.Exceptions.PlatformNotSupportedException(message='')

PlatformNotSupportedException is raise if the platform is not supported by pyIPCMI, or the selected tool flow is not supported on the host system by pyIPCMI.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Base.Exceptions.NotConfiguredException(message='')

NotConfiguredException is raise if pyIPCMI or the requested tool chain setting is not configured in pyIPCMI.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Base.Exceptions.SkipableException(message='')

Base class for all skipable exceptions.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Base.Exceptions.CommonException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Base.Exceptions.SkipableCommonException(message='')

SkipableCommonException is a CommonException, which can be skipped.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

pyIPCMI.Base.Executable.py

Exceptions

• ExecutableException: This exception is raised by all executable abstraction classes.

Classes

• CommandLineArgument: Base class (and meta class) for all Arguments classes.
• ExecutableArgument: Represents the executable.
• NamedCommandLineArgument: Base class for all command line arguments with a name.
• CommandArgument: Represents a command name.
• ShortCommandArgument: Represents a command name with a single dash.
• LongCommandArgument: Represents a command name with a double dash.
• WindowsCommandArgument: Represents a command name with a single slash.
• StringArgument: Represents a simple string argument.
• StringListArgument: Represents a list of string arguments.
• PathArgument: Represents a path argument.
• FlagArgument: Base class for all FlagArgument classes, which represents a simple flag argument.
• ShortFlagArgument: Represents a flag argument with a single dash.
• LongFlagArgument: Represents a flag argument with a double dash.
• WindowsFlagArgument: Represents a flag argument with a single slash.
• ValuedFlagArgument: Class and base class for all ValuedFlagArgument classes, which represents a flag argument with data.
• ShortValuedFlagArgument: Represents a ValuedFlagArgument with a single dash.
• LongValuedFlagArgument: Represents a ValuedFlagArgument with a double dash.
• WindowsValuedFlagArgument: Represents a ValuedFlagArgument with a single slash.
• ValuedFlagListArgument: Class and base class for all ValuedFlagListArgument classes, which represents a list of ValuedFlagArgument instances.
• ShortValuedFlagListArgument: Represents a ValuedFlagListArgument with a single dash.
• LongValuedFlagListArgument: Represents a ValuedFlagListArgument with a double dash.
• WindowsValuedFlagListArgument: Represents a ValuedFlagListArgument with a single slash.
• TupleArgument: Class and base class for all TupleArgument classes, which represents a switch with separate data.
• ShortTupleArgument: Represents a TupleArgument with a single dash in front of the switch name.
• LongTupleArgument: Represents a TupleArgument with a double dash in front of the switch name.
• WindowsTupleArgument: Represents a TupleArgument with a single slash in front of the switch name.
• CommandLineArgumentList: Represent a list of all available commands, flags and switch of an executable.
• Environment: Undocumented.
• Executable: Represent an executable.

exception pyIPCMI.Base.Executable.ExecutableException(message='')

This exception is raised by all executable abstraction classes.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.Base.Executable.CommandLineArgument

Base class (and meta class) for all Arguments classes.

Inheritance

Members

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ExecutableArgument

Represents the executable.

Inheritance

Members

Value

AsArgument()

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.NamedCommandLineArgument

Base class for all command line arguments with a name.

Inheritance

Members

_name = None

Name

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.CommandArgument

Represents a command name.

It is usually used to select a sub parser in a CLI argument parser or to hand over all following parameters to a separate tool. An example for a command is ‘checkout’ in git.exe checkout, which calls git-checkout.exe.

Inheritance

Members

_pattern = '{0}'

Value

AsArgument()

Name

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ShortCommandArgument

Represents a command name with a single dash.

Inheritance

Members

_pattern = '-{0}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.LongCommandArgument

Represents a command name with a double dash.

Inheritance

Members

_pattern = '--{0}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.WindowsCommandArgument

Represents a command name with a single slash.

Inheritance

Members

_pattern = '/{0}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.StringArgument

Represents a simple string argument.

Inheritance

Members

_pattern = '{0}'

Value

AsArgument()

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.StringListArgument

Represents a list of string arguments.

Inheritance

Members

_pattern = '{0}'

Value

AsArgument()

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.PathArgument

Represents a path argument.

The output format can be forced to the POSIX format with _PosixFormat.

Inheritance

Members

_PosixFormat = False

Value

AsArgument()

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.FlagArgument

Base class for all FlagArgument classes, which represents a simple flag argument.

A simple flag is a single boolean value (absent/present or off/on) with no data.

Inheritance

Members

_pattern = '{0}'

Value

AsArgument()

Name

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ShortFlagArgument

Represents a flag argument with a single dash.

Example: -optimize

Inheritance

Members

_pattern = '-{0}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.LongFlagArgument

Represents a flag argument with a double dash.

Example: --optimize

Inheritance

Members

_pattern = '--{0}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.WindowsFlagArgument

Represents a flag argument with a single slash.

Example: /optimize

Inheritance

Members

_pattern = '/{0}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ValuedFlagArgument

Class and base class for all ValuedFlagArgument classes, which represents a flag argument with data.

A valued flag is a flag name followed by a value. The default delimiter sign is equal (=). Name and value are passed as one arguments to the executable even if the delimiter sign is a whitespace character.

Example: width=100

Inheritance

Members

_pattern = '{0}={1}'

Value

AsArgument()

Name

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ShortValuedFlagArgument

Represents a ValuedFlagArgument with a single dash.

Example: -optimizer=on

Inheritance

Members

_pattern = '-{0}={1}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.LongValuedFlagArgument

Represents a ValuedFlagArgument with a double dash.

Example: --optimizer=on

Inheritance

Members

_pattern = '--{0}={1}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.WindowsValuedFlagArgument

Represents a ValuedFlagArgument with a single slash.

Example: /optimizer:on

Inheritance

Members

_pattern = '/{0}:{1}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ValuedFlagListArgument

Class and base class for all ValuedFlagListArgument classes, which represents a list of ValuedFlagArgument instances.

Each list item gets translated into a ValuedFlagArgument, with the same flag name, but differing values. Each ValuedFlagArgument is passed as a single argument to the executable, even if the delimiter sign is a whitespace character.

Example: file=file1.txt file=file2.txt

Inheritance

Members

_pattern = '{0}={1}'

Value

AsArgument()

Name

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ShortValuedFlagListArgument

Represents a ValuedFlagListArgument with a single dash.

Example: -file=file1.txt -file=file2.txt

Inheritance

Members

_pattern = '-{0}={1}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.LongValuedFlagListArgument

Represents a ValuedFlagListArgument with a double dash.

Example: --file=file1.txt --file=file2.txt

Inheritance

Members

_pattern = '--{0}={1}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.WindowsValuedFlagListArgument

Represents a ValuedFlagListArgument with a single slash.

Example: /file:file1.txt /file:file2.txt

Inheritance

Members

_pattern = '/{0}:{1}'

AsArgument()

Name

Value

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.TupleArgument

Class and base class for all TupleArgument classes, which represents a switch with separate data.

A tuple switch is a command line argument followed by a separate value. Name and value are passed as two arguments to the executable.

Example: width 100

Inheritance

Members

_switchPattern = '{0}'

_valuePattern = '{0}'

Value

AsArgument()

Name

_name = None

_value = None

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.ShortTupleArgument

Represents a TupleArgument with a single dash in front of the switch name.

Example: -file file1.txt

Inheritance

Members

_switchPattern = '-{0}'

AsArgument()

Name

Value

_name = None

_value = None

_valuePattern = '{0}'

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.LongTupleArgument

Represents a TupleArgument with a double dash in front of the switch name.

Example: --file file1.txt

Inheritance

Members

_switchPattern = '--{0}'

AsArgument()

Name

Value

_name = None

_value = None

_valuePattern = '{0}'

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.WindowsTupleArgument

Represents a TupleArgument with a single slash in front of the switch name.

Example: /file file1.txt

Inheritance

Members

_switchPattern = '/{0}'

AsArgument()

Name

Value

_name = None

_value = None

_valuePattern = '{0}'

mro() → list

return a type’s method resolution order

class pyIPCMI.Base.Executable.CommandLineArgumentList(*args)

Represent a list of all available commands, flags and switch of an executable.

Inheritance

Members

ToArgumentList()

append(object) → None -- append object to end

clear() → None -- remove all items from L

copy() → list -- a shallow copy of L

count(value) → integer -- return number of occurrences of value

extend(iterable) → None -- extend list by appending elements from the iterable

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

insert()

L.insert(index, object) – insert object before index

pop([index]) → item -- remove and return item at index (default last).

Raises IndexError if list is empty or index is out of range.

remove(value) → None -- remove first occurrence of value.

Raises ValueError if the value is not present.

reverse()

L.reverse() – reverse IN PLACE

sort(key=None, reverse=False) → None -- stable sort *IN PLACE*

class pyIPCMI.Base.Executable.Environment

Inheritance

Members

class pyIPCMI.Base.Executable.Executable(platform: str, dryrun: bool, executablePath: pathlib.Path, environment: pyIPCMI.Base.Executable.Environment = None, logger: pyIPCMI.Base.Logging.Logger = None)

Represent an executable.

Inheritance

Members

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

_TryLog(*args, condition=True, **kwargs)

Path

StartProcess(parameterList)

Send(line, end='\n')

SendBoundary()

Terminate()

GetReader()

ReadUntilBoundary(indent=0)

pyIPCMI.Base.Logging.py

Classes

• Severity: Logging message severity levels.
• LogEntry: Represents a single line log message with a severity and indentation level.
• Logger: Undocumented.
• ILogable: A mixin class to provide local logging methods.

class pyIPCMI.Base.Logging.Severity(*_)

Logging message severity levels.

Inheritance

Members

Fatal = 30

Error = 25

Quiet = 20

Warning = 15

Info = 10

DryRun = 5

Normal = 4

Verbose = 2

Debug = 1

All = 0

class pyIPCMI.Base.Logging.LogEntry(message, severity=<Severity.Normal: 4>, indent=0, appendLinebreak=True)

Represents a single line log message with a severity and indentation level.

Inheritance

Members

_Log_MESSAGE_FORMAT__ = {<Severity.Debug: 1>: 'DEBUG: {message}', <Severity.Verbose: 2>: 'VERBOSE: {message}', <Severity.Normal: 4>: '{message}', <Severity.DryRun: 5>: 'DRYRUN: {message}', <Severity.Info: 10>: 'INFO: {message}', <Severity.Warning: 15>: 'WARNING: {message}', <Severity.Quiet: 20>: '{message}', <Severity.Error: 25>: 'ERROR: {message}', <Severity.Fatal: 30>: 'FATAL: {message}'}

Severity

Return the log message’s severity level.

Indent

Return the log message’s indentation level.

Message

Return the indented log message.

IndentBy(indent)

Increase a log message’s indentation level.

class pyIPCMI.Base.Logging.Logger(logLevel, printToStdOut=True)

Inheritance

Members

LogLevel

Return the currently logged minimal severity level.

BaseIndent

_Log_MESSAGE_FORMAT__ = {<Severity.Debug: 1>: '{DARK_GRAY}{message}{NOCOLOR}', <Severity.Verbose: 2>: '{GRAY}{message}{NOCOLOR}', <Severity.Normal: 4>: '{WHITE}{message}{NOCOLOR}', <Severity.DryRun: 5>: '{DARK_CYAN}{message}{NOCOLOR}', <Severity.Info: 10>: '{WHITE}{message}{NOCOLOR}', <Severity.Warning: 15>: '{YELLOW}{message}{NOCOLOR}', <Severity.Quiet: 20>: '{WHITE}{message}{NOCOLOR}', <Severity.Error: 25>: '{RED}{message}{NOCOLOR}', <Severity.Fatal: 30>: '{DARK_RED}{message}{NOCOLOR}'}

Write(entry)

TryWrite(entry)

WriteFatal(message, indent=0, appendLinebreak=True)

WriteError(message, indent=0, appendLinebreak=True)

WriteWarning(message, indent=0, appendLinebreak=True)

WriteInfo(message, indent=0, appendLinebreak=True)

WriteQuiet(message, indent=0, appendLinebreak=True)

WriteNormal(message, indent=0, appendLinebreak=True)

WriteVerbose(message, indent=1, appendLinebreak=True)

WriteDebug(message, indent=2, appendLinebreak=True)

WriteDryRun(message, indent=2, appendLinebreak=True)

class pyIPCMI.Base.Logging.ILogable(logger=None)

A mixin class to provide local logging methods.

Inheritance

Members

Logger

Return the local logger instance.

Log(entry, condition=True)

Write an entry to the local logger.

_TryLog(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

pyIPCMI.Base.Project.py

Classes

• FileTypes: Undocumented.
• Environment: An enumeration.
• ToolChain: An enumeration.
• Tool: An enumeration.
• VHDLVersion: An enumeration.
• Project: Undocumented.
• FileSet: Undocumented.
• VHDLLibrary: Undocumented.
• File: Undocumented.
• ProjectFile: Undocumented.
• ConstraintFile: Undocumented.
• SettingsFile: Undocumented.
• SourceFile: Undocumented.
• VHDLSourceFile: Undocumented.
• VerilogSourceFile: Undocumented.
• PythonSourceFile: Undocumented.
• CocotbSourceFile: Undocumented.

class pyIPCMI.Base.Project.FileTypes

Inheritance

Members

Extension()

_FlagsArithmeticMixin__bits

_FlagsArithmeticMixin__create_flags_instance(bits)

_Flags__internal_str()

classmethod bits_from_simple_str(s)

classmethod bits_from_str(s)

Converts the output of __str__ into an integer.

data

classmethod from_simple_str(s)

Accepts only the output of to_simple_str(). The output of __str__() is invalid as input.

classmethod from_str(s)

Accepts both the output of to_simple_str() and __str__().

is_disjoint(*flags_instances)

is_member

flags.is_member is a shorthand for flags.properties is not None. If this property is False then this Flags instance has either zero bits or holds a combination of flag member bits. If this property is True then the bits of this Flags instance match exactly the bits associated with one of the members. This however doesn’t necessarily mean that this flag instance isn’t a combination of several flags because the bits of a member can be the subset of another member. For example if member0_bits=0x1 and member1_bits=0x3 then the bits of member0 are a subset of the bits of member1. If a flag instance holds the bits of member1 then Flags.is_member returns True and Flags.properties returns the properties of member1 but __len__() returns 2 and __iter__() yields both member0 and member1.

name

properties

Returns:Returns None if this flag isn’t an exact member of a flags class but a combination of flags,

returns an object holding the properties (e.g.: name, data, index, …) of the flag otherwise. We don’t store flag properties directly in Flags instances because this way Flags instances that are the (temporary) result of flags arithmetic don’t have to maintain these fields and it also has some benefits regarding memory usage.

to_simple_str()

class pyIPCMI.Base.Project.Environment

An enumeration.

Inheritance

Members

Any = 0

Simulation = 1

Synthesis = 2

class pyIPCMI.Base.Project.ToolChain

An enumeration.

Inheritance

Members

Any = 0

Aldec_ActiveHDL = 10

Aldec_RivieraPRO = 15

Altera_Quartus = 20

Altera_ModelSim = 21

Cocotb = 30

GHDL_GTKWave = 40

Intel_Quartus = 50

Intel_ModelSim = 51

Lattice_Diamond = 60

Lattice_Synplify = 65

Mentor_ModelSim = 70

Mentor_QuestaSim = 75

Xilinx_ISE = 80

Xilinx_PlanAhead = 81

Xilinx_Vivado = 82

class pyIPCMI.Base.Project.Tool(*_)

An enumeration.

Inheritance

Members

Any = 0

Aldec_aSim = ('ASIM', 'Aldec Active-HDL', 'Aldec Active-HDL')

Aldec_rPro = ('RPRO', 'Aldec Riviera-PRO', 'Aldec Riviera-PRO')

Altera_Quartus_Map = ('QMAP', 'Quartus Map', 'Altera Quartus Map (quartus_map)')

Cocotb_QuestaSim = ('COCO', 'Cocotb', 'Coroutine Cosimulation Testbench (Cocotb)')

GHDL = ('GHDL', 'GHDL', 'GHDL')

GTKwave = ('GTKW', 'GTKWave', 'GTKWave')

Lattice_LSE = ('LSE', 'Lattice LSE', 'Lattice Synthesis Engine (LSE)')

Mentor_vSim = ('VSIM', 'Mentor ModelSim', 'Mentor Graphics ModelSim (vSim)')

Xilinx_iSim = ('XSIM', 'Xilinx iSim', 'Xilinx ISE Simulator (iSim)')

Xilinx_XST = ('XST', 'Xilinx XST', 'Xilinx Synthesis Tool (XST)')

Xilinx_CoreGen = ('CG', 'Xilinx CoreGen', 'Xilinx Core Generator Tool (CoreGen)')

Xilinx_xSim = ('XSIM', 'Xilinx xSim', 'Xilinx Vivado Simulator (xSim)')

Xilinx_Synth = ('VIVADO', 'Xilinx Vivado Synthesis', 'Xilinx Vivado Synthesis (synth)')

Xilinx_IPCatalog = ('XCI', 'Xilinx Vivado IP Catalog', 'Xilinx Vivado IP Catalog')

class pyIPCMI.Base.Project.VHDLVersion(*_)

An enumeration.

Inheritance

Members

Any = 0

VHDL87 = 87

VHDL93 = 93

VHDL2002 = 2002

VHDL2008 = 2008

class pyIPCMI.Base.Project.Project(name)

Inheritance

Members

Name

RootDirectory

Board

Device

Environment

ToolChain

Tool

VHDLVersion

CreateFileSet(name, setDefault=True)

AddFileSet(fileSet)

FileSets

DefaultFileSet

AddFile(file, fileSet=None)

AddSourceFile(file, fileSet=None)

Files(fileType=<FileTypes(Text|ProjectFile|FileListFile|RulesFile|SourceFile|VHDLSourceFile|VerilogSourceFile|PythonSourceFile|CocotbSourceFile|ConstraintFile|UcfConstraintFile|XdcConstraintFile|SdcConstraintFile|LdcConstraintFile|SettingsFile|QuartusSettingsFile) bits=0xFFFF>, fileSet=None)

ExtractVHDLLibrariesFromVHDLSourceFiles()

VHDLLibraries

ExternalVHDLLibraries

AddExternalVHDLLibraries(library)

GetVariables()

pprint(indent=0)

class pyIPCMI.Base.Project.FileSet(name, project=None)

Inheritance

Members

Name

Project

Files

AddFile(file)

AddSourceFile(file)

class pyIPCMI.Base.Project.VHDLLibrary(name, project=None)

Inheritance

Members

Name

Project

Files

AddFile(file)

class pyIPCMI.Base.Project.File(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes() bits=0x0000>

Project

FileSet

FileType

FileName

Path

Open()

ReadFile()

_ReadContent()

class pyIPCMI.Base.Project.ProjectFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.ProjectFile bits=0x0002 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

class pyIPCMI.Base.Project.ConstraintFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.ConstraintFile bits=0x0200 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

class pyIPCMI.Base.Project.SettingsFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.SettingsFile bits=0x4000 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

class pyIPCMI.Base.Project.SourceFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.SourceFile bits=0x0010 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

class pyIPCMI.Base.Project.VHDLSourceFile(file, vhdlLibraryName, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.VHDLSourceFile bits=0x0020 data=UNDEFINED>

Parse()

File

FileName

FileSet

FileType

LibraryName

Open()

Path

Project

ReadFile()

_ReadContent()

class pyIPCMI.Base.Project.VerilogSourceFile(file, project=None, fileSet=None)

Inheritance

Members

File

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

_FileType = <FileTypes.VerilogSourceFile bits=0x0040 data=UNDEFINED>

class pyIPCMI.Base.Project.PythonSourceFile(file, project=None, fileSet=None)

Inheritance

Members

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

_FileType = <FileTypes.PythonSourceFile bits=0x0080 data=UNDEFINED>

class pyIPCMI.Base.Project.CocotbSourceFile(file, project=None, fileSet=None)

Inheritance

Members

File

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

_FileType = <FileTypes.CocotbSourceFile bits=0x0100 data=UNDEFINED>

pyIPCMI.Base.Shared.py

Classes

• Shared: Base class for Simulator and Compiler.

Functions

• to_time(): Convert n seconds to a str with this pattern: “{min}:{sec:02}”.

class pyIPCMI.Base.Shared.Shared(host: pyIPCMI.Base.IHost, dryRun)

Base class for Simulator and Compiler.

Parameters:

• host (object) – The hosting instance for this instance.
• dryRun (bool) – Enable dry-run mode
• noCleanUp (bool) – Don’t clean up after a run.

Inheritance

Members

ENVIRONMENT = 0

TOOL_CHAIN = 0

TOOL = 0

VHDL_VERSION = 2008

Host

DryRun

VHDLVersion

pyIPCMIProject

Directories

_GetTimeDeltaSinceLastEvent()

_PrepareEnvironment()

_PrepareEnvironment_PurgeDirectory()

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_Prepare()

_CreatepyIPCMIProject(projectName, board)

_AddFileListFile(fileListFilePath)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

_TryLog(*args, condition=True, **kwargs)

Functions

pyIPCMI.Base.Shared.to_time(seconds)

Convert n seconds to a str with this pattern: “{min}:{sec:02}”.

Parameters:seconds (int) – Number of seconds to be converted. Return type:str Returns:Returns a string formatted as #:##. E.g. “1:05”

Classes

• IHost: This is a type hint class (interface description) for a host instance.

class pyIPCMI.Base.IHost(logger=None)

This is a type hint class (interface description) for a host instance.

It’s needed until pyIPCMI requires Python 3.6.

Inheritance

Members

Platform = 'string'

Config = <lib.ExtendedConfigParser.ExtendedConfigParser object>

SaveAndReloadConfiguration()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

_TryLog(*args, condition=True, **kwargs)

pyIPCMI.Compiler

Submodules

pyIPCMI.Compiler.ISECompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.ISECompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 80

TOOL = 0

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run(entity, args, kwargs)

Run a testbench.

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

_WriteSpecialSectionIntoConfig(device)

pyIPCMIProject

pyIPCMI.Compiler.LSECompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.LSECompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 60

TOOL = ('LSE', 'Lattice LSE', 'Lattice Synthesis Engine (LSE)')

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run a list of netlist compilations. Expand wildcards to all selected netlists.

Run(netlist, board)

Run a testbench.

_WriteLSEProjectFile(netlist, board)

_RunCompile(netlist, lseArgumentFile)

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

_WriteSpecialSectionIntoConfig(device)

pyIPCMIProject

pyIPCMI.Compiler.QuartusCompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.QuartusCompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 20

TOOL = ('QMAP', 'Quartus Map', 'Altera Quartus Map (quartus_map)')

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run a list of netlist compilations. Expand wildcards to all selected netlists.

Run(netlist, board)

Run a testbench.

_WriteSpecialSectionIntoConfig(device)

_WriteQuartusProjectFile(netlist, device)

_RunCompile(netlist)

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Compiler.VivadoCompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.VivadoCompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 82

TOOL = ('VIVADO', 'Xilinx Vivado Synthesis', 'Xilinx Vivado Synthesis (synth)')

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run a list of netlist compilations. Expand wildcards to all selected netlists.

Run(netlist, board)

Run a testbench.

_WriteSpecialSectionIntoConfig(device)

_RunCompile(netlist)

_WriteTclFile(netlist, device)

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Compiler.XCICompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.XCICompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 82

TOOL = ('XCI', 'Xilinx Vivado IP Catalog', 'Xilinx Vivado IP Catalog')

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run a list of netlist compilations. Expand wildcards to all selected netlists.

Run(netlist, board)

Run a testbench.

_WriteSpecialSectionIntoConfig(device)

_RunCompile(netlist, device)

_WriteTclFile(netlist, device)

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Compiler.XCOCompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.XCOCompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 80

TOOL = ('CG', 'Xilinx CoreGen', 'Xilinx Core Generator Tool (CoreGen)')

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run a list of netlist compilations. Expand wildcards to all selected netlists.

Run(netlist, board)

Run a testbench.

_WriteSpecialSectionIntoConfig(device)

_RunCompile(netlist, device)

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Compiler.XSTCompiler

Classes

• Compiler: Base class for all Compiler classes.

class pyIPCMI.Compiler.XSTCompiler.Compiler(host, dryRun, noCleanUp)

Inheritance

Members

TOOL_CHAIN = 80

TOOL = ('XST', 'Xilinx XST', 'Xilinx Synthesis Tool (XST)')

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

RunAll(fqnList, *args, **kwargs)

Run a list of netlist compilations. Expand wildcards to all selected netlists.

Run(netlist, board)

Run a testbench.

_WriteSpecialSectionIntoConfig(device)

_RunCompile(netlist)

_WriteXstOptionsFile(netlist, device)

Directories

DryRun

ENVIRONMENT = 2

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

NoCleanUp

PrintCompileReportLine(testObject, indent, nameColumnWidth)

PrintOverallCompileReport()

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 93

_AddFileListFile(fileListFilePath)

_AddRulesFiles(rulesFilePath)

_CreatepyIPCMIProject(projectName, board)

_ExecuteCopyTasks(tasks, text)

_ExecuteDeleteTasks(tasks, text)

_ExecuteReplaceTasks(tasks, text)

_GenerateXilinxProjectFileContent(tool, vhdlVersion=93)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_ParseCopyRules(rawList, copyTasks, text)

_ParseDeleteRules(rawList, deleteTasks, text)

_ParseReplaceRules(rawList, replaceTasks, text)

_Prepare()

_PrepareCompilerEnvironment(device)

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_RunPostCopy(netlist)

_RunPostDelete(netlist)

_RunPostReplace(netlist)

_RunPreCopy(netlist)

_RunPreReplace(netlist)

_TryLog(*args, condition=True, **kwargs)

_WriteXilinxProjectFile(projectFilePath, tool, vhdlVersion=93)

pyIPCMIProject

Exceptions

• CompilerException: Base class for all CompilerException classes. It is raised while running
• SkipableCompilerException: SkipableCompilerException is a CompilerException, which

Classes

• CopyTask: This class represents a ‘copy task’ and inherits the partial class
• DeleteTask: This class represents a ‘delete task’ and inherits the partial class
• ReplaceTask: This class represents a ‘replace task’ and inherits the partial class
• AppendLineTask: This class represents a ‘append line task’ and inherits the partial class
• CompileState: Compile state enumeration.
• CompileResult: Compilation result enumeration.
• Compiler: Base class for all Compiler classes.

exception pyIPCMI.Compiler.CompilerException(message='')

Base class for all CompilerException classes. It is raised while running compiler (synthesis) tasks in pyIPCMI.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Compiler.SkipableCompilerException(message='')

SkipableCompilerException is a CompilerException, which can be skipped.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.Compiler.CopyTask(sourcePath, destinationPath)

This class represents a ‘copy task’ and inherits the partial class CopyRuleMixIn.

Inheritance

Members

DestinationPath

SourcePath

class pyIPCMI.Compiler.DeleteTask(filePath)

This class represents a ‘delete task’ and inherits the partial class DeleteRuleMixIn.

Inheritance

Members

FilePath

class pyIPCMI.Compiler.ReplaceTask(filePath, searchPattern, replacePattern, multiLine, dotAll, caseInSensitive)

This class represents a ‘replace task’ and inherits the partial class ReplaceRuleMixIn.

Inheritance

Members

FilePath

RegExpOption_CaseInsensitive

RegExpOption_DotAll

RegExpOption_MultiLine

ReplacePattern

SearchPattern

class pyIPCMI.Compiler.AppendLineTask(filePath, appendPattern)

This class represents a ‘append line task’ and inherits the partial class AppendLineRuleMixIn.

Inheritance

Members

AppendPattern

FilePath

class pyIPCMI.Compiler.CompileState

Compile state enumeration.

Inheritance

Members

Prepare = 0

PreCopy = 10

PrePatch = 11

Compile = 50

PostCopy = 90

PostPatch = 91

PostDelete = 92

CleanUp = 99

class pyIPCMI.Compiler.CompileResult

Compilation result enumeration.

Inheritance

Members

NotRun = 0

Error = 1

Failed = 2

Success = 3

class pyIPCMI.Compiler.Compiler(host: pyIPCMI.Base.IHost, dryRun, noCleanUp)

Base class for all Compiler classes.

Inheritance

Members

ENVIRONMENT = 2

VHDL_VERSION = 93

NoCleanUp

_PrepareCompiler()

Prepare for compilation. This method forwards to Base.Compiler.Compiler._Prepare(), which is inherited from Base.Shared.Shared.

TryRun(netlist, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

Run(netlist, board)

Run a testbench.

_PrepareCompilerEnvironment(device)

_WriteSpecialSectionIntoConfig(device)

_AddRulesFiles(rulesFilePath)

_RunPreCopy(netlist)

_RunPostCopy(netlist)

_ParseCopyRules(rawList, copyTasks, text)

_ExecuteCopyTasks(tasks, text)

_RunPostDelete(netlist)

_ParseDeleteRules(rawList, deleteTasks, text)

_ExecuteDeleteTasks(tasks, text)

_RunPreReplace(netlist)

_RunPostReplace(netlist)

_ParseReplaceRules(rawList, replaceTasks, text)

_ExecuteReplaceTasks(tasks, text)

PrintOverallCompileReport()

PrintCompileReportLine(testObject, indent, nameColumnWidth)

Directories

DryRun

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

TOOL = 0

TOOL_CHAIN = 0

VHDLVersion

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.DataBase

Submodules

pyIPCMI.DataBase.Config

Classes

• BaseEnum: An enumeration.
• Vendors: An enumeration.
• Families: Base enum for all Family enums.
• GenericFamilies: Enumeration of all generic families.
• AlteraFamilies: Enumeration of all Altera families.
• LatticeFamilies: Enumeration of all Lattice families.
• XilinxFamilies: Enumeration of all Xilinx families.
• Devices: Base enum for all Device enums.
• GenericDevices: Enumeration of all generic devices.
• AlteraDevices: Enumeration of all Altera devices.
• LatticeDevices: Enumeration of all Lattice devices.
• XilinxDevices: Enumeration of all Xilinx devices.
• SubTypes: Base enum for all SubType enums.
• GenericSubTypes: Enumeration of all generic device subtype.
• AlteraSubTypes: Enumeration of all Altera device subtype.
• LatticeSubTypes: Enumeration of all Lattice device subtype.
• XilinxSubTypes: Enumeration of all Xilinx device subtype.
• Packages: An enumeration.
• Device: Undocumented.
• Board: Undocumented.

class pyIPCMI.DataBase.Config.BaseEnum

An enumeration.

Inheritance

Members

class pyIPCMI.DataBase.Config.Vendors

An enumeration.

Inheritance

Members

Unknown = 0

Generic = 1

Altera = 2

Lattice = 3

MicroSemi = 4

Xilinx = 5

class pyIPCMI.DataBase.Config.Families

Base enum for all Family enums.

Inheritance

Members

class pyIPCMI.DataBase.Config.GenericFamilies

Enumeration of all generic families.

Inheritance

Members

Unknown = None

Generic = 'g'

class pyIPCMI.DataBase.Config.AlteraFamilies

Enumeration of all Altera families.

Inheritance

Members

Max = 'm'

Cyclone = 'c'

Arria = 'a'

Stratix = 's'

class pyIPCMI.DataBase.Config.LatticeFamilies

Enumeration of all Lattice families.

Inheritance

Members

ECP = 'lfe'

class pyIPCMI.DataBase.Config.XilinxFamilies

Enumeration of all Xilinx families.

Inheritance

Members

Spartan = 's'

Artix = 'a'

Kintex = 'k'

Virtex = 'v'

Zynq = 'z'

class pyIPCMI.DataBase.Config.Devices

Base enum for all Device enums.

Inheritance

Members

class pyIPCMI.DataBase.Config.GenericDevices

Enumeration of all generic devices.

Inheritance

Members

Unknown = 0

Generic = 1

class pyIPCMI.DataBase.Config.AlteraDevices

Enumeration of all Altera devices.

Inheritance

Members

Max2 = 100

Max4 = 101

Max5 = 102

Max10 = 103

Cyclone3 = 110

Cyclone4 = 111

Cyclone5 = 112

Arria2 = 120

Arria5 = 121

Stratix2 = 130

Stratix4 = 131

Stratix5 = 132

Stratix10 = 133

class pyIPCMI.DataBase.Config.LatticeDevices

Enumeration of all Lattice devices.

Inheritance

Members

iCE40 = 200

MachXO = 210

MachXO2 = 211

MachXO3 = 212

ECP2 = 220

ECP3 = 221

ECP5 = 222

class pyIPCMI.DataBase.Config.XilinxDevices

Enumeration of all Xilinx devices.

Inheritance

Members

Spartan3 = 310

Spartan6 = 311

Artix7 = 320

Kintex7 = 330

KintexUltraScale = 331

KintexUltraScalePlus = 332

Virtex2 = 340

Virtex4 = 341

Virtex5 = 342

Virtex6 = 343

Virtex7 = 344

VirtexUltraScale = 345

VirtexUltraScalePlus = 346

Zynq7000 = 350

class pyIPCMI.DataBase.Config.SubTypes

Base enum for all SubType enums.

Inheritance

Members

class pyIPCMI.DataBase.Config.GenericSubTypes

Enumeration of all generic device subtype.

Inheritance

Members

Unknown = None

Generic = 1

NoSubType = ('', '')

class pyIPCMI.DataBase.Config.AlteraSubTypes

Enumeration of all Altera device subtype.

Inheritance

Members

NoSubType = ('', '')

LS = ('ls', '')

E = ('e', '')

GS = ('gs', '')

GX = ('gx', '')

GT = ('gt', '')

GZ = ('gz', '')

SX = ('sx', '')

ST = ('st', '')

class pyIPCMI.DataBase.Config.LatticeSubTypes

Enumeration of all Lattice device subtype.

Inheritance

Members

NoSubType = ('', '')

U = ('u', '')

UM = ('um', '')

class pyIPCMI.DataBase.Config.XilinxSubTypes

Enumeration of all Xilinx device subtype.

Inheritance

Members

NoSubType = ('', '')

DA = ('d', 'a')

E = ('', 'e')

AN = ('', 'an')

X = ('x', '')

T = ('', 't')

XT = ('x', 't')

HT = ('h', 't')

LX = ('lx', '')

SXT = ('sx', 't')

LXT = ('lx', 't')

TXT = ('tx', 't')

FXT = ('fx', 't')

CXT = ('cx', 't')

HXT = ('hx', 't')

class pyIPCMI.DataBase.Config.Packages

An enumeration.

Inheritance

Members

Unknown = 0

Generic = 1

TQG = 10

CLG = 20

CPG = 21

CSG = 22

CABGA = 25

FBG = 30

FF = 31

FFG = 32

FG = 33

FGG = 34

FLG = 35

FT = 36

FTG = 37

RB = 40

RBG = 41

RF = 42

RS = 43

E = 50

Q = 51

F = 52

U = 53

M = 54

class pyIPCMI.DataBase.Config.Device(deviceString)

Inheritance

Members

_DecodeGeneric()

_DecodeAltera(deviceString)

_DecodeLatticeICE(deviceString)

_DecodeLatticeLCM(deviceString)

_DecodeLatticeLFE(deviceString)

_DecodeLatticeECP3(deviceString)

_DecodeLatticeECP5(deviceString)

_DecodeXilinx(deviceString)

Vendor

Family

Device

Generation

Number

SpeedGrade

PinCount

Package

Name

ShortName

FullName

FullName2

FamilyName

Series

GetVariables()

class pyIPCMI.DataBase.Config.Board(host, boardName=None, device=None)

Inheritance

Members

Name

Device

GetVariables()

pyIPCMI.DataBase.Entity

Classes

• EntityTypes: An enumeration.
• BaseFlags: Undocumented.
• TestbenchKind: Undocumented.
• NetlistKind: Undocumented.
• NamespaceRoot: Undocumented.
• Visibility: An enumeration.
• PathElement: Undocumented.
• Namespace: Undocumented.
• Library: Undocumented.
• WildCard: Undocumented.
• StarWildCard: Undocumented.
• AskWildCard: Undocumented.
• IPCore: Undocumented.
• LazyPathElement: Undocumented.
• Testbench: Undocumented.
• VHDLTestbench: Undocumented.
• CocoTestbench: Undocumented.
• Netlist: Undocumented.
• XstNetlist: Undocumented.
• QuartusNetlist: Undocumented.
• LatticeNetlist: Undocumented.
• CoreGeneratorNetlist: Undocumented.
• VivadoNetlist: Undocumented.
• FQN: Undocumented.

Functions

• _pyIPCMIEntityTypes_parser(): Undocumented.

class pyIPCMI.DataBase.Entity.EntityTypes

An enumeration.

Inheritance

Members

Unknown = 0

Source = 1

Testbench = 2

NetList = 3

class pyIPCMI.DataBase.Entity.BaseFlags

Inheritance

Members

_FlagsArithmeticMixin__bits

_FlagsArithmeticMixin__create_flags_instance(bits)

_Flags__internal_str()

classmethod bits_from_simple_str(s)

classmethod bits_from_str(s)

Converts the output of __str__ into an integer.

data

classmethod from_simple_str(s)

Accepts only the output of to_simple_str(). The output of __str__() is invalid as input.

classmethod from_str(s)

Accepts both the output of to_simple_str() and __str__().

is_disjoint(*flags_instances)

is_member

flags.is_member is a shorthand for flags.properties is not None. If this property is False then this Flags instance has either zero bits or holds a combination of flag member bits. If this property is True then the bits of this Flags instance match exactly the bits associated with one of the members. This however doesn’t necessarily mean that this flag instance isn’t a combination of several flags because the bits of a member can be the subset of another member. For example if member0_bits=0x1 and member1_bits=0x3 then the bits of member0 are a subset of the bits of member1. If a flag instance holds the bits of member1 then Flags.is_member returns True and Flags.properties returns the properties of member1 but __len__() returns 2 and __iter__() yields both member0 and member1.

name

properties

Returns:Returns None if this flag isn’t an exact member of a flags class but a combination of flags,

returns an object holding the properties (e.g.: name, data, index, …) of the flag otherwise. We don’t store flag properties directly in Flags instances because this way Flags instances that are the (temporary) result of flags arithmetic don’t have to maintain these fields and it also has some benefits regarding memory usage.

to_simple_str()

class pyIPCMI.DataBase.Entity.TestbenchKind

Inheritance

Members

_FlagsArithmeticMixin__bits

_FlagsArithmeticMixin__create_flags_instance(bits)

_Flags__internal_str()

classmethod bits_from_simple_str(s)

classmethod bits_from_str(s)

Converts the output of __str__ into an integer.

data

classmethod from_simple_str(s)

Accepts only the output of to_simple_str(). The output of __str__() is invalid as input.

classmethod from_str(s)

Accepts both the output of to_simple_str() and __str__().

is_disjoint(*flags_instances)

is_member

flags.is_member is a shorthand for flags.properties is not None. If this property is False then this Flags instance has either zero bits or holds a combination of flag member bits. If this property is True then the bits of this Flags instance match exactly the bits associated with one of the members. This however doesn’t necessarily mean that this flag instance isn’t a combination of several flags because the bits of a member can be the subset of another member. For example if member0_bits=0x1 and member1_bits=0x3 then the bits of member0 are a subset of the bits of member1. If a flag instance holds the bits of member1 then Flags.is_member returns True and Flags.properties returns the properties of member1 but __len__() returns 2 and __iter__() yields both member0 and member1.

name

properties

Returns:Returns None if this flag isn’t an exact member of a flags class but a combination of flags,

returns an object holding the properties (e.g.: name, data, index, …) of the flag otherwise. We don’t store flag properties directly in Flags instances because this way Flags instances that are the (temporary) result of flags arithmetic don’t have to maintain these fields and it also has some benefits regarding memory usage.

to_simple_str()

class pyIPCMI.DataBase.Entity.NetlistKind

Inheritance

Members

_FlagsArithmeticMixin__bits

_FlagsArithmeticMixin__create_flags_instance(bits)

_Flags__internal_str()

classmethod bits_from_simple_str(s)

classmethod bits_from_str(s)

Converts the output of __str__ into an integer.

data

classmethod from_simple_str(s)

Accepts only the output of to_simple_str(). The output of __str__() is invalid as input.

classmethod from_str(s)

Accepts both the output of to_simple_str() and __str__().

is_disjoint(*flags_instances)

is_member

flags.is_member is a shorthand for flags.properties is not None. If this property is False then this Flags instance has either zero bits or holds a combination of flag member bits. If this property is True then the bits of this Flags instance match exactly the bits associated with one of the members. This however doesn’t necessarily mean that this flag instance isn’t a combination of several flags because the bits of a member can be the subset of another member. For example if member0_bits=0x1 and member1_bits=0x3 then the bits of member0 are a subset of the bits of member1. If a flag instance holds the bits of member1 then Flags.is_member returns True and Flags.properties returns the properties of member1 but __len__() returns 2 and __iter__() yields both member0 and member1.

name

properties

Returns:Returns None if this flag isn’t an exact member of a flags class but a combination of flags,

returns an object holding the properties (e.g.: name, data, index, …) of the flag otherwise. We don’t store flag properties directly in Flags instances because this way Flags instances that are the (temporary) result of flags arithmetic don’t have to maintain these fields and it also has some benefits regarding memory usage.

to_simple_str()

class pyIPCMI.DataBase.Entity.NamespaceRoot(host)

Inheritance

Members

Libraries

LibraryNames

DefaultLibraryName

GetLibraries()

GetLibraryNames()

AddLibrary(libraryName, libraryPrefix)

_NamespaceRoot__LibraryRoot_Name = ''

_NamespaceRoot__LibraryRoot_SectionName = ''

class pyIPCMI.DataBase.Entity.Visibility

An enumeration.

Inheritance

Members

Unknown = 0

Private = 1

Public = 2

class pyIPCMI.DataBase.Entity.PathElement(host, name, configSectionName, parent)

Inheritance

Members

Name

Parent

ConfigSectionName

ConfigSection

Level

Visibility

IsVisible

Path

_Load()

class pyIPCMI.DataBase.Entity.Namespace(host, name, configSectionName, parent)

Inheritance

Members

_Load()

Namespaces

NamespaceNames

Entities

EntityNames

GetNamespaces()

GetNamespaceNames()

GetEntities()

GetEntityNames()

GetAllEntities()

pprint(indent=0)

ConfigSection

ConfigSectionName

IsVisible

Level

Name

Parent

Path

Visibility

class pyIPCMI.DataBase.Entity.Library(host, name, configSectionName, parent)

Inheritance

Members

Level

ConfigSection

ConfigSectionName

Entities

EntityNames

GetAllEntities()

GetEntities()

GetEntityNames()

GetNamespaceNames()

GetNamespaces()

IsVisible

Name

NamespaceNames

Namespaces

Parent

Path

Visibility

_Load()

pprint(indent=0)

class pyIPCMI.DataBase.Entity.WildCard(host, name, configSectionName, parent)

Inheritance

Members

GetEntities()

GetTestbenches(kind=<TestbenchKind(VHDLTestbench|CocoTestbench) bits=0x0003>)

GetVHDLTestbenches()

GetCocoTestbenches()

GetNetlists(kind=<NetlistKind(LatticeNetlist|QuartusNetlist|XstNetlist|CoreGeneratorNetlist|VivadoNetlist) bits=0x001F>)

GetLatticeNetlists()

GetQuartusNetlists()

GetXSTNetlists()

GetCoreGenNetlists()

GetVivadoNetlists()

Testbenches

VHDLTestbenches

CocoTestbenches

Netlists

LatticeNetlists

QuartusNetlists

XSTNetlists

CoreGenNetlists

VivadoNetlists

ConfigSection

ConfigSectionName

IsVisible

Level

Name

Parent

Path

Visibility

_Load()

class pyIPCMI.DataBase.Entity.StarWildCard(host, name, configSectionName, parent)

Inheritance

Members

_Load()

GetEntities()

CocoTestbenches

ConfigSection

ConfigSectionName

CoreGenNetlists

GetCocoTestbenches()

GetCoreGenNetlists()

GetLatticeNetlists()

GetNetlists(kind=<NetlistKind(LatticeNetlist|QuartusNetlist|XstNetlist|CoreGeneratorNetlist|VivadoNetlist) bits=0x001F>)

GetQuartusNetlists()

GetTestbenches(kind=<TestbenchKind(VHDLTestbench|CocoTestbench) bits=0x0003>)

GetVHDLTestbenches()

GetVivadoNetlists()

GetXSTNetlists()

IsVisible

LatticeNetlists

Level

Name

Netlists

Parent

Path

QuartusNetlists

Testbenches

VHDLTestbenches

Visibility

VivadoNetlists

XSTNetlists

class pyIPCMI.DataBase.Entity.AskWildCard(host, name, configSectionName, parent)

Inheritance

Members

_Load()

GetEntities()

CocoTestbenches

ConfigSection

ConfigSectionName

CoreGenNetlists

GetCocoTestbenches()

GetCoreGenNetlists()

GetLatticeNetlists()

GetNetlists(kind=<NetlistKind(LatticeNetlist|QuartusNetlist|XstNetlist|CoreGeneratorNetlist|VivadoNetlist) bits=0x001F>)

GetQuartusNetlists()

GetTestbenches(kind=<TestbenchKind(VHDLTestbench|CocoTestbench) bits=0x0003>)

GetVHDLTestbenches()

GetVivadoNetlists()

GetXSTNetlists()

IsVisible

LatticeNetlists

Level

Name

Netlists

Parent

Path

QuartusNetlists

Testbenches

VHDLTestbenches

Visibility

VivadoNetlists

XSTNetlists

class pyIPCMI.DataBase.Entity.IPCore(host, name, configSectionName, parent)

Inheritance

Members

Dependencies

VHDLTestbench

CocoTestbench

GetTestbenches(kind=<TestbenchKind(VHDLTestbench|CocoTestbench) bits=0x0003>)

LatticeNetlist

QuartusNetlist

XSTNetlist

CGNetlist

VivadoNetlist

GetNetlists(kind=<NetlistKind(LatticeNetlist|QuartusNetlist|XstNetlist|CoreGeneratorNetlist|VivadoNetlist) bits=0x001F>)

_Load()

pprint(indent=0)

ConfigSection

ConfigSectionName

IsVisible

Level

Name

Parent

Path

Visibility

class pyIPCMI.DataBase.Entity.LazyPathElement(host, name, configSectionName, parent)

Inheritance

Members

Kind

ConfigSection

ConfigSectionName

IsVisible

LazyLoadable_IsLoaded

Level

Name

Parent

Path

Visibility

_LazyLoadable_Load()

_Load()

class pyIPCMI.DataBase.Entity.Testbench(host, name, configSectionName, parent)

Inheritance

Members

ModuleName

FilesFile

Result

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

Name

Parent

Path

Visibility

_Load()

class pyIPCMI.DataBase.Entity.VHDLTestbench(host, name, configSectionName, parent)

Inheritance

Members

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

FilesFile

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

Result

Visibility

_Load()

class pyIPCMI.DataBase.Entity.CocoTestbench(host, name, configSectionName, parent)

Inheritance

Members

TopLevel

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

FilesFile

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

Result

Visibility

_Load()

class pyIPCMI.DataBase.Entity.Netlist(host, name, configSectionName, parent)

Inheritance

Members

ModuleName

RulesFile

_LazyLoadable_Load()

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

Name

Parent

Path

Visibility

_Load()

class pyIPCMI.DataBase.Entity.XstNetlist(host, name, configSectionName, parent)

Inheritance

Members

FilesFile

XcfFile

FilterFile

XstTemplateFile

PrjFile

XstFile

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

RulesFile

Visibility

_Load()

class pyIPCMI.DataBase.Entity.QuartusNetlist(host, name, configSectionName, parent)

Inheritance

Members

FilesFile

QsfFile

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

RulesFile

Visibility

_Load()

class pyIPCMI.DataBase.Entity.LatticeNetlist(host, name, configSectionName, parent)

Inheritance

Members

FilesFile

PrjFile

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

RulesFile

Visibility

_Load()

class pyIPCMI.DataBase.Entity.CoreGeneratorNetlist(host, name, configSectionName, parent)

Inheritance

Members

FilesFile

XcoFile

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

RulesFile

Visibility

_Load()

class pyIPCMI.DataBase.Entity.VivadoNetlist(host, name, configSectionName, parent)

Inheritance

Members

FilesFile

TclFile

_LazyLoadable_Load()

pprint(indent)

ConfigSection

ConfigSectionName

IsVisible

Kind

LazyLoadable_IsLoaded

Level

ModuleName

Name

Parent

Path

RulesFile

Visibility

_Load()

class pyIPCMI.DataBase.Entity.FQN(host, fqn, libraryName=None, defaultType=<EntityTypes.Source: 1>)

Inheritance

Members

Root()

Entity

Functions

pyIPCMI.DataBase.Entity._pyIPCMIEntityTypes_parser(cls, value)

pyIPCMI.DataBase.Solution

Classes

• Base: Base class for Repository, Solution and Project.
• Repository: Base class for Repository, Solution and Project.
• Solution: Base class for Repository, Solution and Project.
• Project: Base class for Repository, Solution and Project.
• ISEProject: Base class for Repository, Solution and Project.
• VivadoProject: Base class for Repository, Solution and Project.
• QuartusProject: Base class for Repository, Solution and Project.
• LatticeProject: Base class for Repository, Solution and Project.
• VirtualProject: Undocumented.
• FileListFile: Undocumented.
• RulesFile: Undocumented.

class pyIPCMI.DataBase.Solution.Base(host, sectionPrefix, sectionID, parent)

Base class for Repository, Solution and Project. It implements ILazyLoadable.

Inheritance

Members

ID

Parent

ConfigSectionName

_Load()

Implement this method for early loading.

LazyLoadable_IsLoaded

_LazyLoadable_Load()

class pyIPCMI.DataBase.Solution.Repository(host)

Inheritance

Members

Kind

_Load()

Implement this method for early loading.

_LazyLoadable_Load()

AddSolution(solutionID, solutionName, solutionRootPath)

RemoveSolution(solution)

Solutions

SolutionNames

ConfigSectionName

ID

LazyLoadable_IsLoaded

Parent

class pyIPCMI.DataBase.Solution.Solution(host, slnID, parent)

Inheritance

Members

Register()

Unregister()

CreateFiles()

_LazyLoadable_Load()

Name

Path

Projects

ProjectNames

ConfigSectionName

ID

LazyLoadable_IsLoaded

Parent

_Load()

Implement this method for early loading.

class pyIPCMI.DataBase.Solution.Project(host, prjID, parent)

Inheritance

Members

Name

ConfigSectionName

ID

LazyLoadable_IsLoaded

Parent

_LazyLoadable_Load()

_Load()

Implement this method for early loading.

class pyIPCMI.DataBase.Solution.ISEProject(host, prjID, parent)

Inheritance

Members

ConfigSectionName

ID

LazyLoadable_IsLoaded

Name

Parent

_LazyLoadable_Load()

_Load()

Implement this method for early loading.

class pyIPCMI.DataBase.Solution.VivadoProject(host, prjID, parent)

Inheritance

Members

ConfigSectionName

ID

LazyLoadable_IsLoaded

Name

Parent

_LazyLoadable_Load()

_Load()

Implement this method for early loading.

class pyIPCMI.DataBase.Solution.QuartusProject(host, prjID, parent)

Inheritance

Members

ConfigSectionName

ID

LazyLoadable_IsLoaded

Name

Parent

_LazyLoadable_Load()

_Load()

Implement this method for early loading.

class pyIPCMI.DataBase.Solution.LatticeProject(host, prjID, parent)

Inheritance

Members

ConfigSectionName

ID

LazyLoadable_IsLoaded

Name

Parent

_LazyLoadable_Load()

_Load()

Implement this method for early loading.

class pyIPCMI.DataBase.Solution.VirtualProject(name)

Inheritance

Members

AddExternalVHDLLibraries(library)

AddFile(file, fileSet=None)

AddFileSet(fileSet)

AddSourceFile(file, fileSet=None)

Board

CreateFileSet(name, setDefault=True)

DefaultFileSet

Device

Environment

ExternalVHDLLibraries

ExtractVHDLLibrariesFromVHDLSourceFiles()

FileSets

Files(fileType=<FileTypes(Text|ProjectFile|FileListFile|RulesFile|SourceFile|VHDLSourceFile|VerilogSourceFile|PythonSourceFile|CocotbSourceFile|ConstraintFile|UcfConstraintFile|XdcConstraintFile|SdcConstraintFile|LdcConstraintFile|SettingsFile|QuartusSettingsFile) bits=0xFFFF>, fileSet=None)

GetVariables()

Name

RootDirectory

Tool

ToolChain

VHDLLibraries

VHDLVersion

pprint(indent=0)

class pyIPCMI.DataBase.Solution.FileListFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.FileListFile bits=0x0004 data=UNDEFINED>

_classVHDLSourceFile

alias of pyIPCMI.Parser.FilesParser.VHDLSourceFileMixIn

_classVerilogSourceFile

alias of pyIPCMI.Parser.FilesParser.VerilogSourceFileMixIn

_classCocotbSourceFile

alias of pyIPCMI.Parser.FilesParser.CocotbSourceFileMixIn

Parse(host)

CopyFilesToFileSet()

CopyExternalLibraries()

FileName

FileSet

FileType

Files

Includes

Libraries

Open()

Path

Project

ReadFile()

Warnings

_Evaluate(host, expr)

_EvaluatePath(host, expr)

_Parse()

_ReadContent()

_Resolve(host, statements=None)

_classIncludeFile

alias of pyIPCMI.Parser.FilesParser.IncludeFileMixIn

_classLDCSourceFile

alias of pyIPCMI.Parser.FilesParser.LDCSourceFileMixIn

_classSDCSourceFile

alias of pyIPCMI.Parser.FilesParser.SDCSourceFileMixIn

_classUCFSourceFile

alias of pyIPCMI.Parser.FilesParser.UCFSourceFileMixIn

_classXDCSourceFile

alias of pyIPCMI.Parser.FilesParser.XDCSourceFileMixIn

class pyIPCMI.DataBase.Solution.RulesFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.RulesFile bits=0x0008 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

PostProcessRules

PreProcessRules

Project

ReadFile()

_Parse()

_ReadContent()

_Resolve()

_ResolveRule(ruleStatement, lst)

_classAppendLineRule

alias of pyIPCMI.Parser.RulesParser.AppendLineRuleMixIn

_classCopyRule

alias of pyIPCMI.Parser.RulesParser.CopyRuleMixIn

_classDeleteRule

alias of pyIPCMI.Parser.RulesParser.DeleteRuleMixIn

_classReplaceRule

alias of pyIPCMI.Parser.RulesParser.ReplaceRuleMixIn

Parse()

pyIPCMI.DataBase.TestCase

Classes

• SimulationStatus: An enumeration.
• CompileStatus: An enumeration.
• ElementBase: Undocumented.
• GroupBase: Undocumented.
• TestGroup: Undocumented.
• SynthesisGroup: Undocumented.
• SuiteMixIn: Undocumented.
• TestSuite: Undocumented.
• SynthesisSuite: Undocumented.
• TestBase: Undocumented.
• TestCase: Undocumented.
• Synthesis: Undocumented.

class pyIPCMI.DataBase.TestCase.SimulationStatus

An enumeration.

Inheritance

Members

Unknown = 0

DryRun = 1

SystemError = 5

InternalError = 6

AnalyzeError = 7

ElaborationError = 8

SimulationError = 9

SimulationFailed = 10

SimulationNoAsserts = 15

SimulationSuccess = 20

SimulationGUIRun = 30

class pyIPCMI.DataBase.TestCase.CompileStatus

An enumeration.

Inheritance

Members

Unknown = 0

DryRun = 1

SystemError = 5

InternalError = 6

CompileError = 7

CompileFailed = 10

CompileSuccess = 20

class pyIPCMI.DataBase.TestCase.ElementBase(name, parent)

Inheritance

Members

Name

Parent

class pyIPCMI.DataBase.TestCase.GroupBase(name, parent)

Inheritance

Members

Groups

Count

Name

Parent

class pyIPCMI.DataBase.TestCase.TestGroup(name, parent)

Inheritance

Members

TestCases

PassedCount

NoAssertsCount

DryRunCount

FailedCount

ErrorCount

Count

Groups

Name

Parent

class pyIPCMI.DataBase.TestCase.SynthesisGroup(name, parent)

Inheritance

Members

Synthesises

SuccessCount

DryRunCount

FailedCount

ErrorCount

Count

Groups

Name

Parent

class pyIPCMI.DataBase.TestCase.SuiteMixIn

Inheritance

Members

StartTimer()

StopTimer()

StartTime

EndTime

InitializationTime

OverallRunTime

class pyIPCMI.DataBase.TestCase.TestSuite

Inheritance

Members

IsAllPassed

AddTestCase(testCase)

Count

DryRunCount

EndTime

ErrorCount

FailedCount

Groups

InitializationTime

Name

NoAssertsCount

OverallRunTime

Parent

PassedCount

StartTime

StartTimer()

StopTimer()

TestCases

class pyIPCMI.DataBase.TestCase.SynthesisSuite

Inheritance

Members

IsAllSuccess

AddSynthesis(synthesis)

Count

DryRunCount

EndTime

ErrorCount

FailedCount

Groups

InitializationTime

Name

OverallRunTime

Parent

StartTime

StartTimer()

StopTimer()

SuccessCount

Synthesises

class pyIPCMI.DataBase.TestCase.TestBase(test)

Inheritance

Members

Parent

TestGroup

Status

StartTimer()

StopTimer()

OverallRunTime

Name

class pyIPCMI.DataBase.TestCase.TestCase(testbench)

Inheritance

Members

Testbench

UpdateStatus(testResult)

Name

OverallRunTime

Parent

StartTimer()

Status

StopTimer()

TestGroup

class pyIPCMI.DataBase.TestCase.Synthesis(synthesis)

Inheritance

Members

Name

OverallRunTime

Parent

StartTimer()

Status

StopTimer()

TestGroup

Netlist

UpdateStatus(synthResult)

Variables

• __pyIPCMI_SOLUTION_KEYWORD__
• __pyIPCMI_PROJECT_KEYWORD__

Classes

• Query: Undocumented.

pyIPCMI.DataBase.__pyIPCMI_SOLUTION_KEYWORD__

str(object=’‘) -> str str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.

'Solution'

pyIPCMI.DataBase.__pyIPCMI_PROJECT_KEYWORD__

str(object=’‘) -> str str(bytes_or_buffer[, encoding[, errors]]) -> str

Create a new string object from the given object. If encoding or errors is specified, then the object must expose a data buffer that will be decoded using the given encoding and error handler. Otherwise, returns the result of object.__str__() (if defined) or repr(object). encoding defaults to sys.getdefaultencoding(). errors defaults to ‘strict’.

'Project'

class pyIPCMI.DataBase.Query(host)

Inheritance

Members

Host

Platform

Config

QueryConfiguration(query)

_GetModelSimInstallationDirectory()

_GetModelSimBinaryDirectory()

_GetXilinxISESettingsFile()

_GetXilinxVivadoSettingsFile()

pyIPCMI.Parser.py

Submodules

pyIPCMI.Parser.FilesCodeDOM.py

Classes

• BlockedStatement: Undocumented.
• IfThenElseExpressions: Undocumented.
• ListElementExpressions: Undocumented.
• PathExpressions: Undocumented.
• ListConstructorExpression: Undocumented.
• SubDirectoryExpression: Undocumented.
• ConcatenateExpression: Undocumented.
• ExistsFunction: Undocumented.
• VHDLStatement: Undocumented.
• VerilogStatement: Undocumented.
• CocotbStatement: Undocumented.
• ConstraintStatement: Undocumented.
• LDCStatement: Undocumented.
• SDCStatement: Undocumented.
• UCFStatement: Undocumented.
• XDCStatement: Undocumented.
• InterpolateLiteral: Undocumented.
• PathStatement: Undocumented.
• ReportStatement: Undocumented.
• LibraryStatement: Undocumented.
• IncludeStatement: Undocumented.
• IfStatement: Undocumented.
• ElseIfStatement: Undocumented.
• ElseStatement: Undocumented.
• IfElseIfElseStatement: Undocumented.
• Document: Undocumented.

class pyIPCMI.Parser.FilesCodeDOM.BlockedStatement

Inheritance

Members

_allowedStatements = [<class 'pyIPCMI.Parser.FilesCodeDOM.IncludeStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.LibraryStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.VHDLStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.VerilogStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.CocotbStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.LDCStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.SDCStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.UCFStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.XDCStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.PathStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.ReportStatement'>, <class 'pyIPCMI.Parser.FilesCodeDOM.IfElseIfElseStatement'>, <class 'lib.CodeDOM.CommentLine'>, <class 'lib.CodeDOM.EmptyLine'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.IfThenElseExpressions

Inheritance

Members

_allowedExpressions = [<class 'lib.CodeDOM.Identifier'>, <class 'lib.CodeDOM.StringLiteral'>, <class 'lib.CodeDOM.IntegerLiteral'>, <class 'lib.CodeDOM.NotExpression'>, <class 'pyIPCMI.Parser.FilesCodeDOM.ExistsFunction'>, <class 'lib.CodeDOM.AndExpression'>, <class 'lib.CodeDOM.OrExpression'>, <class 'lib.CodeDOM.XorExpression'>, <class 'lib.CodeDOM.EqualExpression'>, <class 'lib.CodeDOM.UnequalExpression'>, <class 'lib.CodeDOM.LessThanExpression'>, <class 'lib.CodeDOM.LessThanEqualExpression'>, <class 'lib.CodeDOM.GreaterThanExpression'>, <class 'lib.CodeDOM.GreaterThanEqualExpression'>, <class 'lib.CodeDOM.InExpression'>, <class 'lib.CodeDOM.NotInExpression'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.ListElementExpressions

Inheritance

Members

_allowedExpressions = [<class 'lib.CodeDOM.Identifier'>, <class 'lib.CodeDOM.StringLiteral'>, <class 'lib.CodeDOM.IntegerLiteral'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.PathExpressions

Inheritance

Members

_allowedExpressions = [<class 'lib.CodeDOM.Identifier'>, <class 'lib.CodeDOM.StringLiteral'>, <class 'pyIPCMI.Parser.FilesCodeDOM.InterpolateLiteral'>, <class 'pyIPCMI.Parser.FilesCodeDOM.SubDirectoryExpression'>, <class 'pyIPCMI.Parser.FilesCodeDOM.ConcatenateExpression'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.ListConstructorExpression

Inheritance

Members

List

AddElement(element)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.SubDirectoryExpression(leftChild, rightChild)

Inheritance

Members

classmethod GetParser()

LeftChild

classmethod Parse(string, printChar)

RightChild

class pyIPCMI.Parser.FilesCodeDOM.ConcatenateExpression(leftChild, rightChild)

Inheritance

Members

classmethod GetParser()

LeftChild

classmethod Parse(string, printChar)

RightChild

class pyIPCMI.Parser.FilesCodeDOM.ExistsFunction(expression)

Inheritance

Members

Expression

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.VHDLStatement(libraryName, pathExpression, commentText)

Inheritance

Members

LibraryName

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.VerilogStatement(pathExpression, commentText)

Inheritance

Members

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.CocotbStatement(pathExpression, commentText)

Inheritance

Members

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.ConstraintStatement(pathExpression, commentText)

Inheritance

Members

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.LDCStatement(pathExpression, commentText)

Inheritance

Members

CommentText

classmethod GetParser()

classmethod Parse(string, printChar)

PathExpression

class pyIPCMI.Parser.FilesCodeDOM.SDCStatement(pathExpression, commentText)

Inheritance

Members

CommentText

classmethod GetParser()

classmethod Parse(string, printChar)

PathExpression

class pyIPCMI.Parser.FilesCodeDOM.UCFStatement(pathExpression, commentText)

Inheritance

Members

CommentText

classmethod GetParser()

classmethod Parse(string, printChar)

PathExpression

class pyIPCMI.Parser.FilesCodeDOM.XDCStatement(pathExpression, commentText)

Inheritance

Members

CommentText

classmethod GetParser()

classmethod Parse(string, printChar)

PathExpression

class pyIPCMI.Parser.FilesCodeDOM.InterpolateLiteral(sectionName, optionName)

Inheritance

Members

SectionName

OptionName

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.PathStatement(variable, pathExpression, commentText)

Inheritance

Members

Variable

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.ReportStatement(message, commentText)

Inheritance

Members

Message

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.LibraryStatement(library, pathExpression, commentText)

Inheritance

Members

Library

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.IncludeStatement(pathExpression, commentText)

Inheritance

Members

PathExpression

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.IfStatement(expression, commentText)

Inheritance

Members

classmethod GetParser()

AddStatement(stmt)

CommentText

Expression

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.FilesCodeDOM.ElseIfStatement(expression, commentText)

Inheritance

Members

classmethod GetParser()

AddStatement(stmt)

CommentText

Expression

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.FilesCodeDOM.ElseStatement(commentText)

Inheritance

Members

classmethod GetParser()

AddStatement(stmt)

CommentText

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.FilesCodeDOM.IfElseIfElseStatement

Inheritance

Members

IfClause

ElseIfClauses

ElseClause

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.FilesCodeDOM.Document(commentText='')

Inheritance

Members

AddStatement(stmt)

CommentText

classmethod Parse(string, printChar)

Statements

classmethod GetParser()

pyIPCMI.Parser.FilesParser.py

Classes

• FileReference: Undocumented.
• IncludeFileMixIn: Undocumented.
• VHDLSourceFileMixIn: Undocumented.
• VerilogSourceFileMixIn: Undocumented.
• CocotbSourceFileMixIn: Undocumented.
• LDCSourceFileMixIn: Undocumented.
• SDCSourceFileMixIn: Undocumented.
• UCFSourceFileMixIn: Undocumented.
• XDCSourceFileMixIn: Undocumented.
• VHDLLibraryReference: Undocumented.
• FilesParserMixIn: Undocumented.

class pyIPCMI.Parser.FilesParser.FileReference(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.IncludeFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.VHDLSourceFileMixIn(file, library)

Inheritance

Members

LibraryName

File

class pyIPCMI.Parser.FilesParser.VerilogSourceFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.CocotbSourceFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.LDCSourceFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.SDCSourceFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.UCFSourceFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.XDCSourceFileMixIn(file)

Inheritance

Members

File

class pyIPCMI.Parser.FilesParser.VHDLLibraryReference(name, path)

Inheritance

Members

Name

Path

class pyIPCMI.Parser.FilesParser.FilesParserMixIn

Inheritance

Members

_classIncludeFile

alias of IncludeFileMixIn

_classVHDLSourceFile

alias of VHDLSourceFileMixIn

_classVerilogSourceFile

alias of VerilogSourceFileMixIn

_classCocotbSourceFile

alias of CocotbSourceFileMixIn

_classLDCSourceFile

alias of LDCSourceFileMixIn

_classSDCSourceFile

alias of SDCSourceFileMixIn

_classUCFSourceFile

alias of UCFSourceFileMixIn

_classXDCSourceFile

alias of XDCSourceFileMixIn

_Parse()

_Resolve(host, statements=None)

_Evaluate(host, expr)

_EvaluatePath(host, expr)

Files

Includes

Libraries

Warnings

pyIPCMI.Parser.RulesCodeDOM.py

Classes

• InFileStatements: Undocumented.
• PreProcessStatements: Undocumented.
• PostProcessStatements: Undocumented.
• DocumentStatements: Undocumented.
• CopyStatement: Undocumented.
• DeleteStatement: Undocumented.
• ReplaceStatement: Undocumented.
• AppendLineStatement: Undocumented.
• FileStatement: Undocumented.
• ProcessRulesBlockStatement: Undocumented.
• PreProcessRulesStatement: Undocumented.
• PostProcessRulesStatement: Undocumented.
• Document: Undocumented.

class pyIPCMI.Parser.RulesCodeDOM.InFileStatements

Inheritance

Members

_allowedStatements = [<class 'pyIPCMI.Parser.RulesCodeDOM.ReplaceStatement'>, <class 'pyIPCMI.Parser.RulesCodeDOM.AppendLineStatement'>, <class 'lib.CodeDOM.CommentLine'>, <class 'lib.CodeDOM.EmptyLine'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.PreProcessStatements

Inheritance

Members

_allowedStatements = [<class 'pyIPCMI.Parser.RulesCodeDOM.CopyStatement'>, <class 'pyIPCMI.Parser.RulesCodeDOM.FileStatement'>, <class 'lib.CodeDOM.CommentLine'>, <class 'lib.CodeDOM.EmptyLine'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.PostProcessStatements

Inheritance

Members

_allowedStatements = [<class 'pyIPCMI.Parser.RulesCodeDOM.CopyStatement'>, <class 'pyIPCMI.Parser.RulesCodeDOM.DeleteStatement'>, <class 'pyIPCMI.Parser.RulesCodeDOM.FileStatement'>, <class 'lib.CodeDOM.CommentLine'>, <class 'lib.CodeDOM.EmptyLine'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.DocumentStatements

Inheritance

Members

_allowedStatements = [<class 'pyIPCMI.Parser.RulesCodeDOM.PreProcessRulesStatement'>, <class 'pyIPCMI.Parser.RulesCodeDOM.PostProcessRulesStatement'>, <class 'lib.CodeDOM.CommentLine'>, <class 'lib.CodeDOM.EmptyLine'>]

classmethod AddChoice(value)

classmethod GetParser()

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.CopyStatement(source, destination, commentText)

Inheritance

Members

SourcePath

DestinationPath

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.DeleteStatement(file, commentText)

Inheritance

Members

FilePath

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.ReplaceStatement(searchPattern, replacePattern, caseInsensitive, multiLine, dotAll, commentText)

Inheritance

Members

SearchPattern

ReplacePattern

CaseInsensitive

MultiLine

DotAll

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.AppendLineStatement(appendPattern, commentText)

Inheritance

Members

AppendPattern

classmethod GetParser()

CommentText

classmethod Parse(string, printChar)

class pyIPCMI.Parser.RulesCodeDOM.FileStatement(file, commentText)

Inheritance

Members

FilePath

classmethod GetParser()

AddStatement(stmt)

CommentText

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.RulesCodeDOM.ProcessRulesBlockStatement(commentText)

Inheritance

Members

classmethod GetParser()

AddStatement(stmt)

CommentText

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.RulesCodeDOM.PreProcessRulesStatement(commentText)

Inheritance

Members

AddStatement(stmt)

CommentText

classmethod GetParser()

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.RulesCodeDOM.PostProcessRulesStatement(commentText)

Inheritance

Members

AddStatement(stmt)

CommentText

classmethod GetParser()

classmethod Parse(string, printChar)

Statements

class pyIPCMI.Parser.RulesCodeDOM.Document(commentText='')

Inheritance

Members

classmethod GetParser()

AddStatement(stmt)

CommentText

classmethod Parse(string, printChar)

Statements

pyIPCMI.Parser.RulesParser.py

Classes

• Rule: Base class for all Rule and RuleMixIn classes.
• CopyRuleMixIn: A partial class (MixIn) to represent a ‘copy rule’.
• DeleteRuleMixIn: A partial class (MixIn) to represent a ‘delete rule’.
• ReplaceRuleMixIn: A partial class (MixIn) to represent a ‘replace rule’.
• AppendLineRuleMixIn: A partial class (MixIn) to represent a ‘append line rule’.
• RulesParserMixIn: Undocumented.

class pyIPCMI.Parser.RulesParser.Rule

Base class for all Rule and RuleMixIn classes.

Inheritance

Members

class pyIPCMI.Parser.RulesParser.CopyRuleMixIn(sourcePath, destinationPath)

A partial class (MixIn) to represent a ‘copy rule’.

Inheritance

Members

SourcePath

DestinationPath

class pyIPCMI.Parser.RulesParser.DeleteRuleMixIn(filePath)

A partial class (MixIn) to represent a ‘delete rule’.

Inheritance

Members

FilePath

class pyIPCMI.Parser.RulesParser.ReplaceRuleMixIn(filePath, searchPattern, replacePattern, multiLine, dotAll, caseInSensitive)

A partial class (MixIn) to represent a ‘replace rule’.

Inheritance

Members

FilePath

SearchPattern

ReplacePattern

RegExpOption_MultiLine

RegExpOption_DotAll

RegExpOption_CaseInsensitive

class pyIPCMI.Parser.RulesParser.AppendLineRuleMixIn(filePath, appendPattern)

A partial class (MixIn) to represent a ‘append line rule’.

Inheritance

Members

FilePath

AppendPattern

class pyIPCMI.Parser.RulesParser.RulesParserMixIn

Inheritance

Members

_classCopyRule

alias of CopyRuleMixIn

_classDeleteRule

alias of DeleteRuleMixIn

_classReplaceRule

alias of ReplaceRuleMixIn

_classAppendLineRule

alias of AppendLineRuleMixIn

_Parse()

_Resolve()

_ResolveRule(ruleStatement, lst)

PreProcessRules

PostProcessRules

pyIPCMI.Processor.py

pyIPCMI.Simulator

Submodules

pyIPCMI.Simulator.ActiveHDLSimulator

Classes

• Simulator: Base class for all Simulator classes.

class pyIPCMI.Simulator.ActiveHDLSimulator.Simulator(host, dryRun, simulationSteps)

Inheritance

Members

TOOL_CHAIN = 10

TOOL = ('ASIM', 'Aldec Active-HDL', 'Aldec Active-HDL')

_PrepareSimulator()

Create the Active-HDL executable factory.

_RunAnalysis(_)

_RunSimulation(testbench)

_RunSimulationWithGUI(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

Run(testbench, board, vhdlVersion, vhdlGenerics=None)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_RunCoverage(testbench)

_RunElaboration(testbench)

_RunView(testbench)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Simulator.CocotbSimulator

Classes

• Simulator: Base class for all Simulator classes.

class pyIPCMI.Simulator.CocotbSimulator.Simulator(host, dryRun, simulationSteps)

Inheritance

Members

TOOL_CHAIN = 30

TOOL = ('COCO', 'Cocotb', 'Coroutine Cosimulation Testbench (Cocotb)')

COCOTB_SIMBUILD_DIRECTORY = 'sim_build'

_PrepareSimulator()

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

_RunSimulation(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

Run(testbench, board, vhdlVersion, vhdlGenerics=None)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_RunAnalysis(testbench)

_RunCoverage(testbench)

_RunElaboration(testbench)

_RunView(testbench)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Simulator.GHDLSimulator

Classes

• Simulator: This class encapsulates the GHDL simulator.

class pyIPCMI.Simulator.GHDLSimulator.Simulator(host, dryRun, simulationSteps)

This class encapsulates the GHDL simulator.

Inheritance

Members

TOOL_CHAIN = 40

TOOL = ('GHDL', 'GHDL', 'GHDL')

_PrepareSimulator()

Create the GHDL executable factory instance.

Run(testbench, board, vhdlVersion, vhdlGenerics=None, withCoverage=False)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

_RunAnalysis(testbench)

_SetVHDLVersionAndIEEEFlavor(ghdl)

_SetExternalLibraryReferences(ghdl)

_RunElaboration(testbench)

_RunSimulation(testbench)

_RunView(testbench)

foo

_RunCoverage(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Simulator.ISESimulator

Classes

• Simulator: Base class for all Simulator classes.

class pyIPCMI.Simulator.ISESimulator.Simulator(host, dryRun, simulationSteps)

Inheritance

Members

TOOL_CHAIN = 80

TOOL = ('XSIM', 'Xilinx iSim', 'Xilinx ISE Simulator (iSim)')

_PrepareSimulator()

_RunElaboration(testbench)

_RunSimulation(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

Run(testbench, board, vhdlVersion, vhdlGenerics=None)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GenerateXilinxProjectFileContent(tool, vhdlVersion=93)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_RunAnalysis(testbench)

_RunCoverage(testbench)

_RunView(testbench)

_TryLog(*args, condition=True, **kwargs)

_WriteXilinxProjectFile(projectFilePath, tool, vhdlVersion=93)

pyIPCMIProject

pyIPCMI.Simulator.ModelSimSimulator

Classes

• Simulator: Base class for all Simulator classes.

class pyIPCMI.Simulator.ModelSimSimulator.Simulator(host, dryRun, simulationSteps)

Inheritance

Members

TOOL_CHAIN = 70

TOOL = ('VSIM', 'Mentor ModelSim', 'Mentor Graphics ModelSim (vSim)')

_PrepareSimulator()

Run(testbench, board, vhdlVersion, vhdlGenerics=None, withCoverage=False)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

_RunAnalysis(_)

_RunSimulation(testbench)

_RunSimulationWithGUI(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_RunCoverage(testbench)

_RunElaboration(testbench)

_RunView(testbench)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Simulator.QuestaSimulator

Classes

• Simulator: Base class for all Simulator classes.

class pyIPCMI.Simulator.QuestaSimulator.Simulator(host, dryRun, simulationSteps)

Inheritance

Members

TOOL_CHAIN = 75

TOOL = ('VSIM', 'Mentor ModelSim', 'Mentor Graphics ModelSim (vSim)')

_PrepareSimulator()

Run(testbench, board, vhdlVersion, vhdlGenerics=None)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

_RunAnalysis(_)

_RunSimulation(testbench)

_RunSimulationWithGUI(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_RunCoverage(testbench)

_RunElaboration(testbench)

_RunView(testbench)

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.Simulator.RivieraPROSimulator

pyIPCMI.Simulator.VivadoSimulator

Classes

• Simulator: Base class for all Simulator classes.

class pyIPCMI.Simulator.VivadoSimulator.Simulator(host, dryRun, simulationSteps)

Inheritance

Members

TOOL_CHAIN = 82

TOOL = ('XSIM', 'Xilinx xSim', 'Xilinx Vivado Simulator (xSim)')

_PrepareSimulator()

_RunElaboration(testbench)

_RunSimulation(testbench)

Directories

DryRun

ENVIRONMENT = 1

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

Run(testbench, board, vhdlVersion, vhdlGenerics=None)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TestSuite

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

VHDLVersion

VHDL_VERSION = 2008

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GenerateXilinxProjectFileContent(tool, vhdlVersion=93)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulationEnvironment()

_RunAnalysis(testbench)

_RunCoverage(testbench)

_RunView(testbench)

_TryLog(*args, condition=True, **kwargs)

_WriteXilinxProjectFile(projectFilePath, tool, vhdlVersion=93)

pyIPCMIProject

Exceptions

• SimulatorException: Base class for all SimulatorException classes. It is raised while running
• SkipableSimulatorException: SkipableSimulatorException is a SimulatorException, which
• pyIPCMISimulationResultNotFoundException: This exception is raised if the expected pyIPCMI simulation result string was

Classes

• SimulationSteps: Simulation step enumeration.
• SimulationState: Simulation state enumeration.
• SimulationResult: Simulation result enumeration.
• Simulator: Base class for all Simulator classes.

exception pyIPCMI.Simulator.SimulatorException(message='')

Base class for all SimulatorException classes. It is raised while running simulation tasks in pyIPCMI.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Simulator.SkipableSimulatorException(message='')

SkipableSimulatorException is a SimulatorException, which can be skipped.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.Simulator.pyIPCMISimulationResultNotFoundException(message='')

This exception is raised if the expected pyIPCMI simulation result string was not found in the simulator’s output.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.Simulator.SimulationSteps

Simulation step enumeration.

Inheritance

Members

_FlagsArithmeticMixin__bits

_FlagsArithmeticMixin__create_flags_instance(bits)

_Flags__internal_str()

classmethod bits_from_simple_str(s)

classmethod bits_from_str(s)

Converts the output of __str__ into an integer.

data

classmethod from_simple_str(s)

Accepts only the output of to_simple_str(). The output of __str__() is invalid as input.

classmethod from_str(s)

Accepts both the output of to_simple_str() and __str__().

is_disjoint(*flags_instances)

is_member

flags.is_member is a shorthand for flags.properties is not None. If this property is False then this Flags instance has either zero bits or holds a combination of flag member bits. If this property is True then the bits of this Flags instance match exactly the bits associated with one of the members. This however doesn’t necessarily mean that this flag instance isn’t a combination of several flags because the bits of a member can be the subset of another member. For example if member0_bits=0x1 and member1_bits=0x3 then the bits of member0 are a subset of the bits of member1. If a flag instance holds the bits of member1 then Flags.is_member returns True and Flags.properties returns the properties of member1 but __len__() returns 2 and __iter__() yields both member0 and member1.

name

properties

Returns:Returns None if this flag isn’t an exact member of a flags class but a combination of flags,

returns an object holding the properties (e.g.: name, data, index, …) of the flag otherwise. We don’t store flag properties directly in Flags instances because this way Flags instances that are the (temporary) result of flags arithmetic don’t have to maintain these fields and it also has some benefits regarding memory usage.

to_simple_str()

class pyIPCMI.Simulator.SimulationState

Simulation state enumeration.

Inheritance

Members

Prepare = 0

Analyze = 1

Elaborate = 2

Optimize = 3

Simulate = 4

View = 5

Coverage = 6

class pyIPCMI.Simulator.SimulationResult

Simulation result enumeration.

Inheritance

Members

NotRun = 0

DryRun = 1

Error = 2

Failed = 3

NoAsserts = 4

Passed = 5

GUIRun = 6

class pyIPCMI.Simulator.Simulator(host: pyIPCMI.Base.IHost, dryRun, simulationSteps: pyIPCMI.Simulator.SimulationSteps)

Base class for all Simulator classes.

Inheritance

Members

ENVIRONMENT = 1

VHDL_VERSION = 2008

TestSuite

_PrepareSimulationEnvironment()

_PrepareEnvironment_PurgeDirectory()

_PrepareSimulator()

RunAll(fqnList, *args, **kwargs)

Run a list of testbenches. Expand wildcards to all selected testbenches.

TryRun(testbench, *args, **kwargs)

Try to run a testbench. Skip skipable exceptions by printing the error and its cause.

Run(testbench, board, vhdlVersion, vhdlGenerics=None)

Write the Testbench message line, create a pyIPCMIProject and add the first *.files file to it.

_RunAnalysis(testbench)

_RunElaboration(testbench)

_RunSimulation(testbench)

_RunView(testbench)

_RunCoverage(testbench)

PrintOverallSimulationReport()

PrintSimulationReportLine(testObject, indent, nameColumnWidth)

Directories

DryRun

Host

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

TOOL = 0

TOOL_CHAIN = 0

VHDLVersion

_AddFileListFile(fileListFilePath)

_CreatepyIPCMIProject(projectName, board)

_GetHDLParameters(configSectionName)

Parse option ‘HDLParameters’ for Verilog Parameters / VHDL Generics.

_GetTimeDeltaSinceLastEvent()

_Prepare()

_PrepareEnvironment()

_PrepareEnvironment_ChangeDirectory()

Change working directory to temporary path ‘temp/<tool>’.

_PrepareEnvironment_CreatingDirectory()

_TryLog(*args, condition=True, **kwargs)

pyIPCMIProject

pyIPCMI.ToolChain

Submodules

pyIPCMI.ToolChain.Aldec

Submodules

pyIPCMI.ToolChain.Aldec.ActiveHDL

Exceptions

• ActiveHDLException: An ActiveHDLException is raised if Active-HDL catches a system exception.

Classes

• AldecActiveHDLEditions: Enumeration of all Active-HDL editions provided by Aldec itself.
• ActiveHDLEditions: Enumeration of all Active-HDL editions provided by Aldec inclusive editions
• Configuration: Base class for all tool Configuration classes.
• ActiveHDL: Factory for executable abstractions in Active-HDL.
• VHDLLibraryTool: Abstraction layer of Active-HDL’s VHDL library management tool ‘vlib’.
• VHDLCompiler: Abstraction layer of Active-HDL’s VHDL compiler ‘vcom’.
• VHDLStandaloneSimulator: Abstraction layer of Active-HDL’s VHDL standalone simulator ‘vsimsa’.

Functions

• VLibFilter(): A line based output stream filter for Active-HDL’s VHDL library management
• VComFilter(): A line based output stream filter for Active-HDL’s VHDL compiler.
• VSimFilter(): A line based output stream filter for Active-HDL’s VHDL simulator.

exception pyIPCMI.ToolChain.Aldec.ActiveHDL.ActiveHDLException(message='')

An ActiveHDLException is raised if Active-HDL catches a system exception.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Aldec.ActiveHDL.AldecActiveHDLEditions(name, section)

Enumeration of all Active-HDL editions provided by Aldec itself.

Inheritance

Members

StandardEdition = 1

StudentEdition = 2

class pyIPCMI.ToolChain.Aldec.ActiveHDL.ActiveHDLEditions(name, section)

Enumeration of all Active-HDL editions provided by Aldec inclusive editions shipped by other vendors.

Inheritance

Members

StandardEdition = 1

LatticeEdition = 2

class pyIPCMI.ToolChain.Aldec.ActiveHDL.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Aldec'

The name of the tools vendor.

_toolName = 'Aldec Active-HDL'

The name of the tool.

_section = 'INSTALL.Aldec.ActiveHDL'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Aldec Active-HDL supports multiple versions installed on the same system.

_template = {'Windows': {'INSTALL.Aldec.ActiveHDL': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '10.3', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/BIN'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Aldec:InstallationDirectory}/Active-HDL'), 'Edition': ('${${SectionName}:Edition}', 'Active-HDL')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if general Aldec support is configured in pyIPCMI.

ConfigureForAll()

Configuration routine for Aldec Active-HDL on all supported platforms.

1. Ask if Active-HDL is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for Active-HDL.
• No → clear the Active-HDL configuration section.

1. Ask for Active-HDL’s version.
2. Ask for Active-HDL’s edition (normal, student).
3. Ask for Active-HDL’s installation directory.

_ConfigureEdition()

Configure Active-HDL for Aldec.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckActiveHDLVersion(binPath, version)

Compare the given Active-HDL version with the tool’s version string.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Aldec.ActiveHDL.ActiveHDL(platform, dryrun, binaryDirectoryPath, version, logger=None)

Factory for executable abstractions in Active-HDL.

Inheritance

Members

GetVHDLLibraryTool()

Return an instance of Active-HDL’s VHDL library management tool ‘vlib’.

GetVHDLCompiler()

Return an instance of Active-HDL’s VHDL compiler ‘vcom’.

GetSimulator()

Return an instance of Active-HDL’s VHDL simulator ‘vsim’.

class pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLLibraryTool(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Abstraction layer of Active-HDL’s VHDL library management tool ‘vlib’.

Inheritance

Members

class Executable

_value = None

class SwitchLibraryName

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLLibraryTool.Executable'>, <class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLLibraryTool.SwitchLibraryName'>]

CreateLibrary()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLCompiler(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Abstraction layer of Active-HDL’s VHDL compiler ‘vcom’.

Inheritance

Members

class Executable

_value = None

class FlagNoRangeCheck

_name = 'norangecheck'

_value = None

class SwitchVHDLVersion

_pattern = '-{1}'

_name = ''

_value = None

class SwitchVHDLLibrary

_name = 'work'

_value = None

class ArgSourceFile

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLCompiler.Executable'>, <class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLCompiler.FlagNoRangeCheck'>, <class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLCompiler.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLCompiler.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLCompiler.ArgSourceFile'>]

Compile()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLStandaloneSimulator(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Abstraction layer of Active-HDL’s VHDL standalone simulator ‘vsimsa’.

Inheritance

Members

class Executable

_value = None

class SwitchBatchCommand

_name = 'do'

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLStandaloneSimulator.Executable'>, <class 'pyIPCMI.ToolChain.Aldec.ActiveHDL.VHDLStandaloneSimulator.SwitchBatchCommand'>]

Simulate()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Functions

pyIPCMI.ToolChain.Aldec.ActiveHDL.VLibFilter(gen)

A line based output stream filter for Active-HDL’s VHDL library management tool.

pyIPCMI.ToolChain.Aldec.ActiveHDL.VComFilter(gen)

A line based output stream filter for Active-HDL’s VHDL compiler.

pyIPCMI.ToolChain.Aldec.ActiveHDL.VSimFilter(gen)

A line based output stream filter for Active-HDL’s VHDL simulator.

pyIPCMI.ToolChain.Aldec.RivieraPRO

Exceptions

• RivieraPROException: An RivieraPROException is raised if Riviera-PRO catches a system exception.

Classes

• Configuration: Base class for all tool Configuration classes.
• RivieraPRO: Factory for executable abstractions in Riviera-PRO.
• VHDLLibraryTool: Abstraction layer of Riviera-PRO’s VHDL library management tool ‘vlib’.
• VHDLCompiler: Abstraction layer of Riviera-PRO’s VHDL compiler ‘vcom’.
• VHDLSimulator: Represent an executable.

Functions

• VLibFilter(): A line based output stream filter for Riviera-PRO’s VHDL library management tool.
• VComFilter(): A line based output stream filter for Riviera-PRO’s VHDL compiler.
• VSimFilter(): A line based output stream filter for Riviera-PRO’s VHDL simulator.

exception pyIPCMI.ToolChain.Aldec.RivieraPRO.RivieraPROException(message='')

An RivieraPROException is raised if Riviera-PRO catches a system exception.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Aldec.RivieraPRO.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Aldec'

The name of the tools vendor.

_toolName = 'Aldec Riviera-PRO'

The name of the tool.

_section = 'INSTALL.Aldec.RivieraPRO'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Aldec Riviera-PRO supports multiple versions installed on the same system.

_template = {'Linux': {'INSTALL.Aldec.RivieraPRO': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '2017.02', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/BIN'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Aldec:InstallationDirectory}/Riviera-PRO'), 'Edition': ('${${SectionName}:Edition}', 'Riviera-PRO')}}, 'Windows': {'INSTALL.Aldec.RivieraPRO': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '2017.02', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Aldec:InstallationDirectory}/Riviera-PRO-${Version}-x64'), 'Edition': ('${${SectionName}:Edition}', 'Riviera-PRO')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if general Aldec support is configured in pyIPCMI.

ConfigureForAll()

Configuration routine for Aldec Riviera-PRO on all supported platforms.

1. Ask if Riviera-PRO is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for Riviera-PRO.
• No → clear the Riviera-PRO configuration section.

1. Ask for Riviera-PRO’s version.
2. Ask for Riviera-PRO’s edition (normal, student).
3. Ask for Riviera-PRO’s installation directory.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckRivieraPROVersion(binPath, version)

Compare the given Riviera-PRO version with the tool’s version string.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Aldec.RivieraPRO.RivieraPRO(platform, dryrun, binaryDirectoryPath, version, logger=None)

Factory for executable abstractions in Riviera-PRO.

Inheritance

Members

GetVHDLLibraryTool()

Return an instance of Riviera-PRO’s VHDL library management tool ‘vlib’.

GetVHDLCompiler()

Return an instance of Riviera-PRO’s VHDL compiler ‘vcom’.

GetSimulator()

Return an instance of Riviera-PRO’s VHDL simulator ‘vsim’.

class pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLLibraryTool(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Abstraction layer of Riviera-PRO’s VHDL library management tool ‘vlib’.

Inheritance

Members

class Executable

_value = None

class SwitchLibraryName

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLLibraryTool.Executable'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLLibraryTool.SwitchLibraryName'>]

CreateLibrary()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLCompiler(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Abstraction layer of Riviera-PRO’s VHDL compiler ‘vcom’.

Inheritance

Members

class Executable

_value = None

class SwitchVHDLVersion

_pattern = '-{1}'

_name = ''

_value = None

class SwitchVHDLLibrary

_name = 'work'

_value = None

class ArgSourceFile

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLCompiler.Executable'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLCompiler.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLCompiler.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLCompiler.ArgSourceFile'>]

Compile()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLSimulator(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

The executable to launch.

_value = None

class SwitchBatchCommand

Specify a Tcl batch script for the batch mode.

_name = 'do'

_value = None

class FlagCommandLineMode

Run simulation in command line mode.

_name = 'c'

_value = None

class SwitchTimeResolution

Set simulation time resolution.

_name = 't'

_value = None

class SwitchTopLevel

The top-level for simulation.

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLSimulator.Executable'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLSimulator.SwitchBatchCommand'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLSimulator.FlagCommandLineMode'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLSimulator.SwitchTimeResolution'>, <class 'pyIPCMI.ToolChain.Aldec.RivieraPRO.VHDLSimulator.SwitchTopLevel'>]

Specify all accepted command line arguments

Simulate()

Start a simulation.

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Functions

pyIPCMI.ToolChain.Aldec.RivieraPRO.VLibFilter(gen)

A line based output stream filter for Riviera-PRO’s VHDL library management tool.

pyIPCMI.ToolChain.Aldec.RivieraPRO.VComFilter(gen)

A line based output stream filter for Riviera-PRO’s VHDL compiler.

pyIPCMI.ToolChain.Aldec.RivieraPRO.VSimFilter(gen)

A line based output stream filter for Riviera-PRO’s VHDL simulator.

Exceptions

• AldecException: Base class for all Aldec tool’s exceptions.

Classes

• Configuration: Configuration routines for Aldec as a vendor.

exception pyIPCMI.ToolChain.Aldec.AldecException(message='')

Base class for all Aldec tool’s exceptions.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Aldec.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Aldec as a vendor.

This configuration provides a common installation directory setup for all Aldec tools installed on a system.

Inheritance

Members

_vendor = 'Aldec'

The name of the tools vendor.

_section = 'INSTALL.Aldec'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'ALL': {'INSTALL.ActiveHDL': {'SectionName': '', 'Version': '${${SectionName}:Version}', 'BinaryDirectory': '${${SectionName}:BinaryDirectory}', 'InstallationDirectory': '${${SectionName}:InstallationDirectory}', 'Edition': '${${SectionName}:Edition}'}}, 'Linux': {'INSTALL.Aldec': {'InstallationDirectory': '/opt/Aldec'}}, 'Windows': {'INSTALL.Aldec': {'InstallationDirectory': 'C:/Aldec'}}}

The template for the configuration sections represented as nested dictionaries.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

pyIPCMI.ToolChain.Altera

Submodules

pyIPCMI.ToolChain.Altera.ModelSim

Exceptions

• ModelSimException: Base class for all tool specific exceptions

Classes

• AlteraModelSimEditions: Enumeration of all ModelSim editions provided by Altera.
• Configuration: Base class for all tool Configuration classes.
• AlteraEditionConfiguration: Base class for all tool Configuration classes.
• AlteraStarterEditionConfiguration: Base class for all tool Configuration classes.

exception pyIPCMI.ToolChain.Altera.ModelSim.ModelSimException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Altera.ModelSim.AlteraModelSimEditions(name, section)

Enumeration of all ModelSim editions provided by Altera.

Inheritance

Members

ModelSimAlteraEdition = 1

ModelSimAlteraStarterEdition = 2

class pyIPCMI.ToolChain.Altera.ModelSim.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Altera'

The name of the tools vendor.

_multiVersionSupport = False

ModelSim Altera (Starter) Edition doesn’t support multiple versions.

CheckDependency()

Check if general Altera support is configured in pyIPCMI.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

_ConfigureEdition()

Configure ModelSim for Altera.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_Configuration__GetModelSimVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_section = 'INSTALL.Vendor.Tool'

_template = {'ALL': {'INSTALL.Vendor.Tool': {'Version': '1.0'}}, 'Darwin': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Linux': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Windows': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool/'}}}

_toolName = 'Mentor ModelSim'

class pyIPCMI.ToolChain.Altera.ModelSim.AlteraEditionConfiguration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Altera ModelSim'

The name of the tool.

__editionName = None

The name of the tool.

_section = 'INSTALL.Altera.ModelSimAE'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Altera.ModelSimAE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/linuxaloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Altera:InstallationDirectory}/${INSTALL.Altera.Quartus:Version}/modelsim_ae', 'Edition': 'ModelSim Altera Edition'}}, 'Windows': {'INSTALL.Altera.ModelSimAE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/win32aloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Altera:InstallationDirectory}/${INSTALL.Altera.Quartus:Version}/modelsim_ae', 'Edition': 'ModelSim Altera Edition'}}}

CheckDependency()

Check if general Altera support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_AlteraEditionConfiguration__editionName = 'ModelSim Altera Edition'

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_Configuration__GetModelSimVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition()

Configure ModelSim for Altera.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_vendor = 'Altera'

class pyIPCMI.ToolChain.Altera.ModelSim.AlteraStarterEditionConfiguration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Altera ModelSim (Starter Edition)'

The name of the tool.

__editionName = None

The name of the tool.

_section = 'INSTALL.Altera.ModelSimASE'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Altera.ModelSimASE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/linuxaloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Altera:InstallationDirectory}/${INSTALL.Altera.Quartus:Version}/modelsim_ase', 'Edition': 'ModelSim Altera Starter Edition'}}, 'Windows': {'INSTALL.Altera.ModelSimASE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/win32aloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Altera:InstallationDirectory}/${INSTALL.Altera.Quartus:Version}/modelsim_ase', 'Edition': 'ModelSim Altera Starter Edition'}}}

CheckDependency()

Check if general Altera support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_AlteraStarterEditionConfiguration__editionName = 'ModelSim Altera Starter Edition'

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_Configuration__GetModelSimVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition()

Configure ModelSim for Altera.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_vendor = 'Altera'

pyIPCMI.ToolChain.Altera.Quartus

Exceptions

• QuartusException: Base class for all tool specific exceptions

Classes

• QuartusEditions: Enumeration of all Quartus editions provided by Altera itself.
• Configuration: Base class for all tool Configuration classes.
• Quartus: Undocumented.
• Map: Represent an executable.
• TclShell: Represent an executable.
• QuartusSession: Undocumented.
• QuartusProject: Undocumented.
• QuartusSettings: Undocumented.
• QuartusProjectFile: Undocumented.

Functions

• MapFilter(): Undocumented.

exception pyIPCMI.ToolChain.Altera.Quartus.QuartusException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Altera.Quartus.QuartusEditions(name, section)

Enumeration of all Quartus editions provided by Altera itself.

Inheritance

Members

AlteraQuartus = 1

IntelQuartus = 2

class pyIPCMI.ToolChain.Altera.Quartus.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Altera'

The name of the tools vendor.

_toolName = 'Altera Quartus'

The name of the tool.

_section = 'INSTALL.Altera.Quartus'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Altera Quartus supports multiple versions installed on the same system.

_template = {'Linux': {'INSTALL.Altera.Quartus': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '16.0', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Altera:InstallationDirectory}/${Version}/quartus')}}, 'Windows': {'INSTALL.Altera.Quartus': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '16.0', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin64'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Altera:InstallationDirectory}/${Version}/quartus')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if general Altera support is configured in pyIPCMI.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckQuartusVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Altera.Quartus.Quartus(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

GetMap()

GetTclShell()

class pyIPCMI.ToolChain.Altera.Quartus.Map(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class ArgProjectName

class SwitchArgumentFile

_name = 'f'

class SwitchDeviceFamily

_name = 'family'

class SwitchDevicePart

_name = 'part'

Parameters = [<class 'pyIPCMI.ToolChain.Altera.Quartus.Map.Executable'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.ArgProjectName'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.SwitchArgumentFile'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.SwitchDeviceFamily'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.SwitchDevicePart'>]

Compile()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Altera.Quartus.TclShell(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class SwitchShell

_name = 's'

Parameters = [<class 'pyIPCMI.ToolChain.Altera.Quartus.TclShell.Executable'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.TclShell.SwitchShell'>]

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Altera.Quartus.QuartusSession(host)

Inheritance

Members

exit()

class pyIPCMI.ToolChain.Altera.Quartus.QuartusProject(host, name, projectFile=None)

Inheritance

Members

Create(session=None)

Save(session)

Read()

Open(session)

Close(session)

AddExternalVHDLLibraries(library)

AddFile(file, fileSet=None)

AddFileSet(fileSet)

AddSourceFile(file, fileSet=None)

Board

CreateFileSet(name, setDefault=True)

DefaultFileSet

Device

Environment

ExternalVHDLLibraries

ExtractVHDLLibrariesFromVHDLSourceFiles()

FileSets

Files(fileType=<FileTypes(Text|ProjectFile|FileListFile|RulesFile|SourceFile|VHDLSourceFile|VerilogSourceFile|PythonSourceFile|CocotbSourceFile|ConstraintFile|UcfConstraintFile|XdcConstraintFile|SdcConstraintFile|LdcConstraintFile|SettingsFile|QuartusSettingsFile) bits=0xFFFF>, fileSet=None)

GetVariables()

Name

RootDirectory

Tool

ToolChain

VHDLLibraries

VHDLVersion

pprint(indent=0)

class pyIPCMI.ToolChain.Altera.Quartus.QuartusSettings(name, settingsFile=None)

Inheritance

Members

File

GlobalAssignments

Parameters

CopySourceFilesFromProject(project)

Write()

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_FileType = <FileTypes.SettingsFile bits=0x4000 data=UNDEFINED>

_ReadContent()

class pyIPCMI.ToolChain.Altera.Quartus.QuartusProjectFile(file)

Inheritance

Members

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_FileType = <FileTypes.ProjectFile bits=0x0002 data=UNDEFINED>

_ReadContent()

Functions

pyIPCMI.ToolChain.Altera.Quartus.MapFilter(gen)

Exceptions

• AlteraException: Base class for all tool specific exceptions

Classes

• Configuration: Configuration routines for Altera as a vendor.

exception pyIPCMI.ToolChain.Altera.AlteraException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Altera.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Altera as a vendor.

This configuration provides a common installation directory setup for all Altera tools installed on a system.

Inheritance

Members

_vendor = 'Altera'

The name of the tools vendor.

_section = 'INSTALL.Altera'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'ALL': {'INSTALL.Quartus': {'SectionName': '', 'Version': '${${SectionName}:Version}', 'BinaryDirectory': '${${SectionName}:BinaryDirectory}', 'InstallationDirectory': '${${SectionName}:InstallationDirectory}', 'Edition': '${${SectionName}:Edition}'}}, 'Linux': {'INSTALL.Altera': {'InstallationDirectory': '/opt/Altera'}}, 'Windows': {'INSTALL.Altera': {'InstallationDirectory': 'C:/Altera'}}}

The template for the configuration sections represented as nested dictionaries.

_GetDefaultInstallationDirectory()

Return default installation directory (str).

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

pyIPCMI.ToolChain.GHDL

Exceptions

• GHDLException: Base class for all tool specific exceptions
• GHDLReanalyzeException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• GHDL: Represent an executable.
• GHDLAnalyze: Represent an executable.
• GHDLElaborate: Represent an executable.
• GHDLRun: Represent an executable.

Functions

• GHDLAnalyzeFilter(): Undocumented.
• GHDLElaborateFilter(): Undocumented.
• GHDLRunFilter(): Undocumented.

exception pyIPCMI.ToolChain.GHDL.GHDLException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.ToolChain.GHDL.GHDLReanalyzeException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.GHDL.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'tgingold'

The name of the tools vendor.

_toolName = 'GHDL'

The name of the tool.

_section = 'INSTALL.GHDL'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Git supports multiple versions installed on the same system.

_template = {'Darwin': {'INSTALL.GHDL': {'Version': '0.36-dev', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'ScriptDirectory': ('${${SectionName}:ScriptDirectory}', '${InstallationDirectory}/lib/ghdl/vendors'), 'SectionName': ('%{PathWithRoot}#${Version}-${Backend}', None), 'Backend': 'llvm', 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '/usr/local')}}, 'Linux': {'INSTALL.GHDL': {'Version': '0.36-dev', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'ScriptDirectory': ('${${SectionName}:ScriptDirectory}', '${InstallationDirectory}/lib/ghdl/vendors'), 'SectionName': ('%{PathWithRoot}#${Version}-${Backend}', None), 'Backend': 'llvm', 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '/usr/local')}}, 'MinGW': {'INSTALL.GHDL': {'Version': '0.36-dev', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'ScriptDirectory': ('${${SectionName}:ScriptDirectory}', '${InstallationDirectory}/lib/ghdl/vendors'), 'SectionName': ('%{PathWithRoot}#${Version}-${Backend}', None), 'Backend': 'llvm', 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '/c/Tools/GHDL/${Version}-${Runtime}-${Backend}')}}, 'Windows': {'INSTALL.GHDL': {'Version': '0.36-dev', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'ScriptDirectory': ('${${SectionName}:ScriptDirectory}', '${InstallationDirectory}/lib/vendors'), 'SectionName': ('%{PathWithRoot}#${Version}-${Runtime}-${Backend}', None), 'Backend': 'mcode', 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', 'C:/Tools/GHDL/${Version}-${Runtime}-${Backend}'), 'Runtime': 'gnatgpl32'}}}

The template for the configuration sections represented as nested dictionaries.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureScriptDirectory()

Updates section with value from _template and returns directory as Path object.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__WriteGHDLSection(binPath)

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.GHDL.GHDL(platform, dryrun, binaryDirectoryPath, version, backend, logger=None)

Inheritance

Members

BinaryDirectoryPath

Backend

Version

deco()

Executable

class CmdAnalyze

_name = 'a'

class CmdElaborate

_name = 'e'

class CmdRun

_name = 'r'

class FlagVerbose

_name = 'v'

class FlagDebug

_name = 'g'

class FlagExplicit

_name = 'fexplicit'

class FlagRelaxedRules

_name = 'frelaxed-rules'

class FlagWarnBinding

_name = 'warn-binding'

class FlagNoVitalChecks

_name = 'no-vital-checks'

class FlagMultiByteComments

_name = 'mb-comments'

class FlagSynBinding

_name = 'syn-binding'

class FlagPSL

_name = 'fpsl'

class FlagProfileArcs

_name = 'fprofile-arcs'

class FlagTestCoverage

_name = 'ftest-coverage'

class SwitchCompilerOption

_pattern = '-{0},{1}'

_name = 'Wc'

class SwitchAssemblerOption

_pattern = '-{0},{1}'

_name = 'Wa'

class SwitchLinkerOption

_pattern = '-{0},{1}'

_name = 'Wl'

class SwitchIEEEFlavor

_name = 'ieee'

class SwitchVHDLVersion

_name = 'std'

class SwitchVHDLLibrary

_name = 'work'

class ArgListLibraryReferences

_pattern = '-{0}{1}'

_name = 'P'

class ArgSourceFile

class ArgTopLevel

Parameters = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdAnalyze'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdElaborate'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdRun'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagVerbose'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagDebug'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagExplicit'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagRelaxedRules'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagWarnBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagNoVitalChecks'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagMultiByteComments'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagSynBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagPSL'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagProfileArcs'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagTestCoverage'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchCompilerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchAssemblerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchLinkerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEFlavor'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgListLibraryReferences'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgSourceFile'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgTopLevel'>]

class SwitchIEEEAsserts

_name = 'ieee-asserts'

class SwitchStopDelta

_name = 'stop-delta'

class SwitchVCDWaveform

_name = 'vcd'

class SwitchVCDGZWaveform

_name = 'vcdgz'

class SwitchFastWaveform

_name = 'fst'

class SwitchGHDLWaveform

_name = 'wave'

class SwitchWaveformOptionFile

_name = 'read-wave-opt'

RunOptions = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEAsserts'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchStopDelta'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDGZWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchFastWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchGHDLWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchWaveformOptionFile'>]

GetGHDLAnalyze()

GetGHDLElaborate()

GetGHDLRun()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.GHDL.GHDLAnalyze(platform, dryrun, binaryDirectoryPath, version, backend, logger=None)

Inheritance

Members

Analyze()

class ArgListLibraryReferences

_name = 'P'

_pattern = '-{0}{1}'

class ArgSourceFile

class ArgTopLevel

Backend

BinaryDirectoryPath

class CmdAnalyze

_name = 'a'

class CmdElaborate

_name = 'e'

class CmdRun

_name = 'r'

Executable

class FlagDebug

_name = 'g'

class FlagExplicit

_name = 'fexplicit'

class FlagMultiByteComments

_name = 'mb-comments'

class FlagNoVitalChecks

_name = 'no-vital-checks'

class FlagPSL

_name = 'fpsl'

class FlagProfileArcs

_name = 'fprofile-arcs'

class FlagRelaxedRules

_name = 'frelaxed-rules'

class FlagSynBinding

_name = 'syn-binding'

class FlagTestCoverage

_name = 'ftest-coverage'

class FlagVerbose

_name = 'v'

class FlagWarnBinding

_name = 'warn-binding'

GetGHDLAnalyze()

GetGHDLElaborate()

GetGHDLRun()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdAnalyze'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdElaborate'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdRun'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagVerbose'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagDebug'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagExplicit'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagRelaxedRules'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagWarnBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagNoVitalChecks'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagMultiByteComments'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagSynBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagPSL'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagProfileArcs'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagTestCoverage'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchCompilerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchAssemblerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchLinkerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEFlavor'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgListLibraryReferences'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgSourceFile'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgTopLevel'>]

Path

ReadUntilBoundary(indent=0)

RunOptions = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEAsserts'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchStopDelta'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDGZWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchFastWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchGHDLWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchWaveformOptionFile'>]

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class SwitchAssemblerOption

_name = 'Wa'

_pattern = '-{0},{1}'

class SwitchCompilerOption

_name = 'Wc'

_pattern = '-{0},{1}'

class SwitchFastWaveform

_name = 'fst'

class SwitchGHDLWaveform

_name = 'wave'

class SwitchIEEEAsserts

_name = 'ieee-asserts'

class SwitchIEEEFlavor

_name = 'ieee'

class SwitchLinkerOption

_name = 'Wl'

_pattern = '-{0},{1}'

class SwitchStopDelta

_name = 'stop-delta'

class SwitchVCDGZWaveform

_name = 'vcdgz'

class SwitchVCDWaveform

_name = 'vcd'

class SwitchVHDLLibrary

_name = 'work'

class SwitchVHDLVersion

_name = 'std'

class SwitchWaveformOptionFile

_name = 'read-wave-opt'

Terminate()

Version

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

deco()

class pyIPCMI.ToolChain.GHDL.GHDLElaborate(platform, dryrun, binaryDirectoryPath, version, backend, logger=None)

Inheritance

Members

Elaborate()

class ArgListLibraryReferences

_name = 'P'

_pattern = '-{0}{1}'

class ArgSourceFile

class ArgTopLevel

Backend

BinaryDirectoryPath

class CmdAnalyze

_name = 'a'

class CmdElaborate

_name = 'e'

class CmdRun

_name = 'r'

Executable

class FlagDebug

_name = 'g'

class FlagExplicit

_name = 'fexplicit'

class FlagMultiByteComments

_name = 'mb-comments'

class FlagNoVitalChecks

_name = 'no-vital-checks'

class FlagPSL

_name = 'fpsl'

class FlagProfileArcs

_name = 'fprofile-arcs'

class FlagRelaxedRules

_name = 'frelaxed-rules'

class FlagSynBinding

_name = 'syn-binding'

class FlagTestCoverage

_name = 'ftest-coverage'

class FlagVerbose

_name = 'v'

class FlagWarnBinding

_name = 'warn-binding'

GetGHDLAnalyze()

GetGHDLElaborate()

GetGHDLRun()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdAnalyze'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdElaborate'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdRun'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagVerbose'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagDebug'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagExplicit'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagRelaxedRules'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagWarnBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagNoVitalChecks'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagMultiByteComments'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagSynBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagPSL'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagProfileArcs'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagTestCoverage'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchCompilerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchAssemblerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchLinkerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEFlavor'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgListLibraryReferences'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgSourceFile'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgTopLevel'>]

Path

ReadUntilBoundary(indent=0)

RunOptions = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEAsserts'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchStopDelta'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDGZWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchFastWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchGHDLWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchWaveformOptionFile'>]

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class SwitchAssemblerOption

_name = 'Wa'

_pattern = '-{0},{1}'

class SwitchCompilerOption

_name = 'Wc'

_pattern = '-{0},{1}'

class SwitchFastWaveform

_name = 'fst'

class SwitchGHDLWaveform

_name = 'wave'

class SwitchIEEEAsserts

_name = 'ieee-asserts'

class SwitchIEEEFlavor

_name = 'ieee'

class SwitchLinkerOption

_name = 'Wl'

_pattern = '-{0},{1}'

class SwitchStopDelta

_name = 'stop-delta'

class SwitchVCDGZWaveform

_name = 'vcdgz'

class SwitchVCDWaveform

_name = 'vcd'

class SwitchVHDLLibrary

_name = 'work'

class SwitchVHDLVersion

_name = 'std'

class SwitchWaveformOptionFile

_name = 'read-wave-opt'

Terminate()

Version

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

deco()

class pyIPCMI.ToolChain.GHDL.GHDLRun(platform, dryrun, binaryDirectoryPath, version, backend, logger=None)

Inheritance

Members

Run()

class ArgListLibraryReferences

_name = 'P'

_pattern = '-{0}{1}'

class ArgSourceFile

class ArgTopLevel

Backend

BinaryDirectoryPath

class CmdAnalyze

_name = 'a'

class CmdElaborate

_name = 'e'

class CmdRun

_name = 'r'

Executable

class FlagDebug

_name = 'g'

class FlagExplicit

_name = 'fexplicit'

class FlagMultiByteComments

_name = 'mb-comments'

class FlagNoVitalChecks

_name = 'no-vital-checks'

class FlagPSL

_name = 'fpsl'

class FlagProfileArcs

_name = 'fprofile-arcs'

class FlagRelaxedRules

_name = 'frelaxed-rules'

class FlagSynBinding

_name = 'syn-binding'

class FlagTestCoverage

_name = 'ftest-coverage'

class FlagVerbose

_name = 'v'

class FlagWarnBinding

_name = 'warn-binding'

GetGHDLAnalyze()

GetGHDLElaborate()

GetGHDLRun()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdAnalyze'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdElaborate'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.CmdRun'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagVerbose'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagDebug'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagExplicit'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagRelaxedRules'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagWarnBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagNoVitalChecks'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagMultiByteComments'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagSynBinding'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagPSL'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagProfileArcs'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.FlagTestCoverage'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchCompilerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchAssemblerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchLinkerOption'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEFlavor'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgListLibraryReferences'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgSourceFile'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.ArgTopLevel'>]

Path

ReadUntilBoundary(indent=0)

RunOptions = [<class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchIEEEAsserts'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchStopDelta'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchVCDGZWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchFastWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchGHDLWaveform'>, <class 'pyIPCMI.ToolChain.GHDL.GHDL.SwitchWaveformOptionFile'>]

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class SwitchAssemblerOption

_name = 'Wa'

_pattern = '-{0},{1}'

class SwitchCompilerOption

_name = 'Wc'

_pattern = '-{0},{1}'

class SwitchFastWaveform

_name = 'fst'

class SwitchGHDLWaveform

_name = 'wave'

class SwitchIEEEAsserts

_name = 'ieee-asserts'

class SwitchIEEEFlavor

_name = 'ieee'

class SwitchLinkerOption

_name = 'Wl'

_pattern = '-{0},{1}'

class SwitchStopDelta

_name = 'stop-delta'

class SwitchVCDGZWaveform

_name = 'vcdgz'

class SwitchVCDWaveform

_name = 'vcd'

class SwitchVHDLLibrary

_name = 'work'

class SwitchVHDLVersion

_name = 'std'

class SwitchWaveformOptionFile

_name = 'read-wave-opt'

Terminate()

Version

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

deco()

Functions

pyIPCMI.ToolChain.GHDL.GHDLAnalyzeFilter(gen)

pyIPCMI.ToolChain.GHDL.GHDLElaborateFilter(gen)

pyIPCMI.ToolChain.GHDL.GHDLRunFilter(gen)

pyIPCMI.ToolChain.GNU

Exceptions

• GNUException: Base class for all tool specific exceptions

Classes

• Make: Represent an executable.

Functions

• GNUMakeQuestaSimFilter(): Undocumented.
• CocotbSimulationResultFilter(): Undocumented.

exception pyIPCMI.ToolChain.GNU.GNUException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.GNU.Make(platform, dryrun, logger=None)

Inheritance

Members

class Executable

class SwitchGui

_name = 'GUI'

Parameters = [<class 'pyIPCMI.ToolChain.GNU.Make.Executable'>, <class 'pyIPCMI.ToolChain.GNU.Make.SwitchGui'>]

RunCocotb()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Functions

pyIPCMI.ToolChain.GNU.GNUMakeQuestaSimFilter(gen)

pyIPCMI.ToolChain.GNU.CocotbSimulationResultFilter(gen, simulationResult)

pyIPCMI.ToolChain.GTKWave

Exceptions

• GTKWaveException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• GTKWave: Represent an executable.

Functions

• GTKWaveFilter(): Undocumented.

exception pyIPCMI.ToolChain.GTKWave.GTKWaveException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.GTKWave.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'TonyBybell'

The name of the tools vendor.

_toolName = 'GTKWave'

The name of the tool.

_section = 'INSTALL.GTKWave'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

GTKWave supports multiple versions installed on the same system.

_template = {'Darwin': {'INSTALL.GTKWave': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '3.3.80', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '/usr/bin')}}, 'Linux': {'INSTALL.GTKWave': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '3.3.80', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '/usr/bin')}}, 'Windows': {'INSTALL.GTKWave': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '3.3.80', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', 'C:/Program Files (x86)/GTKWave')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__WriteGtkWaveSection(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.GTKWave.GTKWave(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

BinaryDirectoryPath

Version

class Executable

class SwitchDumpFile

_name = 'dump'

class SwitchSaveFile

_name = 'save'

Parameters = [<class 'pyIPCMI.ToolChain.GTKWave.GTKWave.Executable'>, <class 'pyIPCMI.ToolChain.GTKWave.GTKWave.SwitchDumpFile'>, <class 'pyIPCMI.ToolChain.GTKWave.GTKWave.SwitchSaveFile'>]

View()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Functions

pyIPCMI.ToolChain.GTKWave.GTKWaveFilter(gen)

pyIPCMI.ToolChain.Git

Exceptions

• GitException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• Git: Undocumented.
• GitSCM: Represent an executable.
• GitRevParse: Represent an executable.
• GitRevList: Represent an executable.
• GitDescribe: Represent an executable.
• GitConfig: Represent an executable.

exception pyIPCMI.ToolChain.Git.GitException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Git.Configuration(host)

Inheritance

Members

_vendor = 'Git SCM'

The name of the tools vendor.

_toolName = 'Git'

The name of the tool.

_section = 'INSTALL.Git'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Git': {'Version': '2.8.1', 'BinaryDirectory': '${InstallationDirectory}', 'HasInstalledGitFilters': 'False', 'InstallationDirectory': '/usr/bin', 'HasInstalledGitHooks': 'False'}}, 'Windows': {'INSTALL.Git': {'Version': '2.12.2', 'BinaryDirectory': '${InstallationDirectory}/cmd', 'HasInstalledGitFilters': 'False', 'InstallationDirectory': 'C:/Program Files/Git', 'HasInstalledGitHooks': 'False'}}}

The template for the configuration sections represented as nested dictionaries.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__GetGitDirectory()

_Configuration__InstallGitFilters()

_Configuration__InstallGitHooks()

_Configuration__IsUnderGitControl()

_Configuration__UninstallGitFilters()

_Configuration__UninstallGitHooks()

_Configuration__WriteGitSection(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

class pyIPCMI.ToolChain.Git.Git(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

GetGitRevParse()

GetGitRevList()

GetGitDescribe()

GetGitConfig()

class pyIPCMI.ToolChain.Git.GitSCM(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

Clear()

class Executable

class Switch_Version

_name = 'version'

Parameters = [<class 'pyIPCMI.ToolChain.Git.GitSCM.Executable'>, <class 'pyIPCMI.ToolChain.Git.GitSCM.Switch_Version'>]

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Git.GitRevParse(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

Clear()

class Command

_name = 'rev-parse'

class SwitchInsideWorkingTree

_name = 'is-inside-work-tree'

class SwitchShowTopLevel

_name = 'show-toplevel'

class SwitchGitDir

_name = 'git-dir'

RevParseParameters = [<class 'pyIPCMI.ToolChain.Git.GitRevParse.Command'>, <class 'pyIPCMI.ToolChain.Git.GitRevParse.SwitchInsideWorkingTree'>, <class 'pyIPCMI.ToolChain.Git.GitRevParse.SwitchShowTopLevel'>, <class 'pyIPCMI.ToolChain.Git.GitRevParse.SwitchGitDir'>]

Execute()

class Executable

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.Git.GitSCM.Executable'>, <class 'pyIPCMI.ToolChain.Git.GitSCM.Switch_Version'>]

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class Switch_Version

_name = 'version'

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Git.GitRevList(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

Clear()

class Command

_name = 'rev-list'

class SwitchTags

_name = 'tags'

class SwitchMaxCount

_name = 'max-count'

RevListParameters = [<class 'pyIPCMI.ToolChain.Git.GitRevList.Command'>, <class 'pyIPCMI.ToolChain.Git.GitRevList.SwitchTags'>, <class 'pyIPCMI.ToolChain.Git.GitRevList.SwitchMaxCount'>]

Execute()

class Executable

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.Git.GitSCM.Executable'>, <class 'pyIPCMI.ToolChain.Git.GitSCM.Switch_Version'>]

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class Switch_Version

_name = 'version'

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Git.GitDescribe(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

Clear()

class Command

_name = 'describe'

class SwitchAbbrev

_name = 'abbrev'

class SwitchTags

_name = 'tags'

DescribeParameters = [<class 'pyIPCMI.ToolChain.Git.GitDescribe.Command'>, <class 'pyIPCMI.ToolChain.Git.GitDescribe.SwitchAbbrev'>, <class 'pyIPCMI.ToolChain.Git.GitDescribe.SwitchTags'>]

Execute()

class Executable

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.Git.GitSCM.Executable'>, <class 'pyIPCMI.ToolChain.Git.GitSCM.Switch_Version'>]

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class Switch_Version

_name = 'version'

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Git.GitConfig(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

Clear()

class Command

_name = 'config'

class SwitchUnset

_name = 'unset'

class SwitchRemoveSection

_name = 'remove-section'

class ValueFilterClean

_name = 'clean'

_pattern = 'filter.{1}.{0}'

class ValueFilterSmudge

_name = 'smudge'

_pattern = 'filter.{1}.{0}'

class ValueFilterParameters

ConfigParameters = [<class 'pyIPCMI.ToolChain.Git.GitConfig.Command'>, <class 'pyIPCMI.ToolChain.Git.GitConfig.SwitchUnset'>, <class 'pyIPCMI.ToolChain.Git.GitConfig.SwitchRemoveSection'>, <class 'pyIPCMI.ToolChain.Git.GitConfig.ValueFilterClean'>, <class 'pyIPCMI.ToolChain.Git.GitConfig.ValueFilterSmudge'>, <class 'pyIPCMI.ToolChain.Git.GitConfig.ValueFilterParameters'>]

Execute()

class Executable

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.Git.GitSCM.Executable'>, <class 'pyIPCMI.ToolChain.Git.GitSCM.Switch_Version'>]

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class Switch_Version

_name = 'version'

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

pyIPCMI.ToolChain.Intel

Submodules

pyIPCMI.ToolChain.Intel.ModelSim

Exceptions

• ModelSimException: Base class for all tool specific exceptions

Classes

• IntelModelSimEditions: An enumeration.
• Configuration: Base class for all tool Configuration classes.
• IntelEditionConfiguration: Base class for all tool Configuration classes.
• IntelStarterEditionConfiguration: Base class for all tool Configuration classes.

exception pyIPCMI.ToolChain.Intel.ModelSim.ModelSimException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Intel.ModelSim.IntelModelSimEditions(name, section)

An enumeration.

Inheritance

Members

ModelSimIntelEdition = 1

ModelSimIntelStarterEdition = 2

class pyIPCMI.ToolChain.Intel.ModelSim.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Intel'

The name of the tools vendor.

_multiVersionSupport = False

Intel ModelSim Edition doesn’t support multiple versions.

CheckDependency()

Check if general Intel support is configured in pyIPCMI.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

_ConfigureEdition()

Configure ModelSim for Intel.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_Configuration__GetModelSimVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_section = 'INSTALL.Vendor.Tool'

_template = {'ALL': {'INSTALL.Vendor.Tool': {'Version': '1.0'}}, 'Darwin': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Linux': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Windows': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool/'}}}

_toolName = 'Mentor ModelSim'

class pyIPCMI.ToolChain.Intel.ModelSim.IntelEditionConfiguration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Intel ModelSim'

The name of the tool.

__editionName = None

The name of the tool.

_section = 'INSTALL.Intel.ModelSimAE'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Intel.ModelSimAE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/linuxaloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Intel:InstallationDirectory}/${INSTALL.Intel.Quartus:Version}/modelsim_ae', 'Edition': 'ModelSim Intel Edition'}}, 'Windows': {'INSTALL.Intel.ModelSimAE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/win32aloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Intel:InstallationDirectory}/${INSTALL.Intel.Quartus:Version}/modelsim_ae', 'Edition': 'ModelSim Intel Edition'}}}

CheckDependency()

Check if general Intel support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_Configuration__GetModelSimVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition()

Configure ModelSim for Intel.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_IntelEditionConfiguration__editionName = 'ModelSim Intel Edition'

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_vendor = 'Intel'

class pyIPCMI.ToolChain.Intel.ModelSim.IntelStarterEditionConfiguration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Intel ModelSim (Starter Edition)'

The name of the tool.

__editionName = None

_section = 'INSTALL.Intel.ModelSimASE'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Intel.ModelSimASE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/linuxaloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Intel:InstallationDirectory}/${INSTALL.Intel.Quartus:Version}/modelsim_ase', 'Edition': 'ModelSim Intel Starter Edition'}}, 'Windows': {'INSTALL.Intel.ModelSimASE': {'Version': '10.5b', 'BinaryDirectory': '${InstallationDirectory}/win32aloem', 'AdditionalVComOptions': '', 'AdditionalVSimOptions': '', 'InstallationDirectory': '${INSTALL.Intel:InstallationDirectory}/${INSTALL.Intel.Quartus:Version}/modelsim_ase', 'Edition': 'ModelSim Intel Starter Edition'}}}

CheckDependency()

Check if general Intel support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_Configuration__GetModelSimVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition()

Configure ModelSim for Intel.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_IntelStarterEditionConfiguration__editionName = 'ModelSim Intel Starter Edition'

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_vendor = 'Intel'

pyIPCMI.ToolChain.Intel.Quartus

Exceptions

• QuartusException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• Quartus: Undocumented.
• Map: Represent an executable.

exception pyIPCMI.ToolChain.Intel.Quartus.QuartusException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Intel.Quartus.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Intel'

The name of the tools vendor.

_toolName = 'Intel Quartus Prime'

The name of the tool.

_section = 'INSTALL.Intel.Quartus'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Intel Quartus supports multiple versions installed on the same system.

CheckDependency()

Check if general Intel support is configured in pyIPCMI.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckQuartusVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_template = {'Linux': {'INSTALL.Altera.Quartus': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '16.0', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Altera:InstallationDirectory}/${Version}/quartus')}}, 'Windows': {'INSTALL.Altera.Quartus': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '16.0', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin64'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Altera:InstallationDirectory}/${Version}/quartus')}}}

class pyIPCMI.ToolChain.Intel.Quartus.Quartus(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

GetMap()

GetTclShell()

class pyIPCMI.ToolChain.Intel.Quartus.Map(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class ArgProjectName

Compile()

class Executable

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Parameters = [<class 'pyIPCMI.ToolChain.Altera.Quartus.Map.Executable'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.ArgProjectName'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.SwitchArgumentFile'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.SwitchDeviceFamily'>, <class 'pyIPCMI.ToolChain.Altera.Quartus.Map.SwitchDevicePart'>]

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

class SwitchArgumentFile

_name = 'f'

class SwitchDeviceFamily

_name = 'family'

class SwitchDevicePart

_name = 'part'

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Exceptions

• IntelException: Base class for all tool specific exceptions

Classes

• Configuration: Configuration routines for Intel as a vendor.

exception pyIPCMI.ToolChain.Intel.IntelException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Intel.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Intel as a vendor.

This configuration provides a common installation directory setup for all Intel tools installed on a system.

Inheritance

Members

_vendor = 'Intel'

The name of the tools vendor.

_section = 'INSTALL.Intel'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Intel': {'InstallationDirectory': '/opt/IntelFPGA'}}, 'Windows': {'INSTALL.Intel': {'InstallationDirectory': 'C:/IntelFPGA'}}}

The template for the configuration sections represented as nested dictionaries.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

pyIPCMI.ToolChain.Lattice

Submodules

pyIPCMI.ToolChain.Lattice.ActiveHDL

pyIPCMI.ToolChain.Lattice.Diamond

Exceptions

• DiamondException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• Diamond: Undocumented.
• Synth: Represent an executable.
• SynthesisArgumentFile: Undocumented.

Functions

• MapFilter(): Undocumented.
• CompilerFilter(): Undocumented.

exception pyIPCMI.ToolChain.Lattice.Diamond.DiamondException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Lattice.Diamond.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Lattice'

The name of the tools vendor.

_toolName = 'Lattice Diamond'

The name of the tool.

_section = 'INSTALL.Lattice.Diamond'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Lattice Diamond supports multiple versions installed on the same system.

_template = {'Linux': {'INSTALL.Lattice.Diamond': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '3.8', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin/lin64'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Lattice:InstallationDirectory}/diamond/${Version}_x64'), 'BinaryDirectory2': ('${${SectionName}:BinaryDirectory2}', '${InstallationDirectory}/ispfpga/bin/lin64')}}, 'Windows': {'INSTALL.Lattice.Diamond': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '3.8', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin/nt64'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Lattice:InstallationDirectory}/Diamond/${Version}_x64'), 'BinaryDirectory2': ('${${SectionName}:BinaryDirectory2}', '${InstallationDirectory}/ispfpga/bin/nt64')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if general Lattice support is configured in pyIPCMI.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckDiamondVersion(binPath, version)

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Lattice.Diamond.Diamond(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

PreparseEnvironment(installationDirectory)

GetSynthesizer()

class pyIPCMI.ToolChain.Lattice.Diamond.Synth(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class SwitchProjectFile

_name = 'f'

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Lattice.Diamond.Synth.Executable'>, <class 'pyIPCMI.ToolChain.Lattice.Diamond.Synth.SwitchProjectFile'>]

static GetLogFileReader(logFile)

Compile(logFile)

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Lattice.Diamond.SynthesisArgumentFile(file)

Inheritance

Members

Architecture

Device

SpeedGrade

Package

TopLevel

FileName

FileSet

FileType

LogFile

Open()

Path

Project

ReadFile()

_FileType = <FileTypes() bits=0x0000>

_ReadContent()

VHDLVersion

HDLParams

Write(project)

Functions

pyIPCMI.ToolChain.Lattice.Diamond.MapFilter(gen)

pyIPCMI.ToolChain.Lattice.Diamond.CompilerFilter(gen)

pyIPCMI.ToolChain.Lattice.Synplify

Exceptions

• SynplifyException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.

exception pyIPCMI.ToolChain.Lattice.Synplify.SynplifyException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Lattice.Synplify.Configuration(host)

Inheritance

Members

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_section = 'INSTALL.Vendor.Tool'

_template = {'ALL': {'INSTALL.Vendor.Tool': {'Version': '1.0'}}, 'Darwin': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Linux': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Windows': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool/'}}}

_toolName = 'Tool'

_vendor = 'Unknown'

Exceptions

• LatticeException: Base class for all tool specific exceptions

Classes

• Configuration: Configuration routines for Lattice as a vendor.
• LatticeDesignConstraintFile: Undocumented.

exception pyIPCMI.ToolChain.Lattice.LatticeException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Lattice.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Lattice as a vendor.

This configuration provides a common installation directory setup for all Lattice tools installed on a system.

Inheritance

Members

_vendor = 'Lattice'

The name of the tools vendor.

_section = 'INSTALL.Lattice'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Lattice': {'InstallationDirectory': '/usr/local'}}, 'Windows': {'INSTALL.Lattice': {'InstallationDirectory': 'C:/Lattice'}}}

The template for the configuration sections represented as nested dictionaries.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

class pyIPCMI.ToolChain.Lattice.LatticeDesignConstraintFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.LdcConstraintFile bits=0x2000 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

pyIPCMI.ToolChain.Mentor

Submodules

pyIPCMI.ToolChain.Mentor.ModelSim

Exceptions

• ModelSimException: Base class for all tool specific exceptions

Classes

• MentorModelSimPEEditions: Enumeration of all ModelSim editions provided by Mentor Graphics itself.
• ModelSimEditions: Enumeration of all ModelSim editions provided by Mentor Graphics inclusive
• Configuration: Base class for all tool Configuration classes.
• ModelSimPEConfiguration: Base class for all tool Configuration classes.
• ModelSimSE32Configuration: Base class for all tool Configuration classes.
• ModelSimSE64Configuration: Base class for all tool Configuration classes.
• Selector: Base class for all Selector classes.
• ModelSim: Undocumented.
• VHDLLibraryTool: Represent an executable.
• VHDLCompiler: Represent an executable.
• VHDLSimulator: Represent an executable.

Functions

• VLibFilter(): Undocumented.
• VComFilter(): Undocumented.
• VSimFilter(): Undocumented.

exception pyIPCMI.ToolChain.Mentor.ModelSim.ModelSimException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Mentor.ModelSim.MentorModelSimPEEditions(name, section)

Enumeration of all ModelSim editions provided by Mentor Graphics itself.

Inheritance

Members

ModelSimPE = 1

ModelSimPEEducation = 2

class pyIPCMI.ToolChain.Mentor.ModelSim.ModelSimEditions(name, section)

Enumeration of all ModelSim editions provided by Mentor Graphics inclusive editions shipped by other vendors.

Inheritance

Members

ModelSimPE = 1

ModelSimDE = 2

ModelSimSE32 = 3

ModelSimSE64 = 4

ModelSimAlteraEdition = 5

ModelSimAlteraStarterEdition = 6

ModelSimIntelEdition = 7

ModelSimIntelStarterEdition = 8

QuestaSim = 9

class pyIPCMI.ToolChain.Mentor.ModelSim.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Mentor'

The name of the tools vendor.

_toolName = 'Mentor ModelSim'

The name of the tool.

_multiVersionSupport = True

Mentor ModelSim supports multiple versions installed on the same system.

CheckDependency()

Check if general Mentor Graphics support is configured in pyIPCMI.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

_GetModelSimVersion(binPath)

_CheckModelSimVersion(binPath, version)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_section = 'INSTALL.Vendor.Tool'

_template = {'ALL': {'INSTALL.Vendor.Tool': {'Version': '1.0'}}, 'Darwin': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Linux': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Windows': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool/'}}}

class pyIPCMI.ToolChain.Mentor.ModelSim.ModelSimPEConfiguration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Mentor ModelSim PE'

The name of the tool.

_section = 'INSTALL.Mentor.ModelSimPE'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Windows': {'INSTALL.Mentor.ModelSimPE': {'AdditionalVComOptions': ('${${SectionName}:AdditionalVComOptions}', ''), 'Version': '10.5c', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/win32pe'), 'ToolInstallationName': 'ModelSim PE', 'SectionName': ('%{PathWithRoot}#${Version}', None), 'AdditionalVSimOptions': ('${${SectionName}:AdditionalVSimOptions}', ''), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Mentor:InstallationDirectory}/${ToolInstallationName}/${Version}'), 'Edition': 'ModelSim PE'}}}

The template for the configuration sections represented as nested dictionaries.

_ConfigureEdition()

Configure ModelSim PE for Mentor Graphics.

CheckDependency()

Check if general Mentor Graphics support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = True

_vendor = 'Mentor'

class pyIPCMI.ToolChain.Mentor.ModelSim.ModelSimSE32Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Mentor ModelSim SE 32-bit'

The name of the tool.

_section = 'INSTALL.Mentor.ModelSimSE32'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Windows': {'INSTALL.Mentor.ModelSimSE32': {'AdditionalVComOptions': ('${${SectionName}:AdditionalVComOptions}', ''), 'Version': '10.5c', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/win32'), 'ToolInstallationName': 'ModelSim SE', 'SectionName': ('%{PathWithRoot}#${Version}', None), 'AdditionalVSimOptions': ('${${SectionName}:AdditionalVSimOptions}', ''), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Mentor:InstallationDirectory}/${ToolInstallationName}/${Version}'), 'Edition': 'ModelSim SE 32-bit'}}}

The template for the configuration sections represented as nested dictionaries.

_ConfigureEdition()

CheckDependency()

Check if general Mentor Graphics support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = True

_vendor = 'Mentor'

class pyIPCMI.ToolChain.Mentor.ModelSim.ModelSimSE64Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'Mentor ModelSim SE 64-bit'

The name of the tool.

_section = 'INSTALL.Mentor.ModelSimSE64'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Mentor.ModelSimSE64': {'AdditionalVComOptions': ('${${SectionName}:AdditionalVComOptions}', ''), 'Version': '10.5c', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/linux_x86_64'), 'ToolInstallationName': 'ModelSim_SE', 'SectionName': ('%{PathWithRoot}#${Version}', None), 'AdditionalVSimOptions': ('${${SectionName}:AdditionalVSimOptions}', ''), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Mentor:InstallationDirectory}/${ToolInstallationName}/${Version}'), 'Edition': 'ModelSim SE 64-bit'}}, 'Windows': {'INSTALL.Mentor.ModelSimSE64': {'AdditionalVComOptions': ('${${SectionName}:AdditionalVComOptions}', ''), 'Version': '10.5c', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/win64'), 'ToolInstallationName': 'ModelSim SE', 'SectionName': ('%{PathWithRoot}#${Version}', None), 'AdditionalVSimOptions': ('${${SectionName}:AdditionalVSimOptions}', ''), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Mentor:InstallationDirectory}/${ToolInstallationName}/${Version}'), 'Edition': 'ModelSim SE 64-bit'}}}

The template for the configuration sections represented as nested dictionaries.

_ConfigureEdition()

CheckDependency()

Check if general Mentor Graphics support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = True

_vendor = 'Mentor'

class pyIPCMI.ToolChain.Mentor.ModelSim.Selector(host: pyIPCMI.Base.IHost)

Inheritance

Members

_toolName = 'ModelSim'

Select()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

ToolName

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskSelection(editions, defaultEdition)

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_GetConfiguredEditions(editions)

Return all configured editions.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Mentor.ModelSim.ModelSim(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

GetVHDLLibraryTool()

GetVHDLCompiler()

GetSimulator()

class pyIPCMI.ToolChain.Mentor.ModelSim.VHDLLibraryTool(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class SwitchLibraryName

Parameters = [<class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLLibraryTool.Executable'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLLibraryTool.SwitchLibraryName'>]

CreateLibrary()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

_value = None

class FlagTime

_name = 'time'

_value = None

class FlagExplicit

_name = 'explicit'

_value = None

class FlagQuietMode

_name = 'quiet'

_value = None

class SwitchModelSimIniFile

_name = 'modelsimini'

_value = None

class FlagRangeCheck

_name = 'rangecheck'

_value = None

class SwitchCoverage

_name = 'cover'

class FlagEnableFocusedExpressionCoverage

_name = 'coverfec'

class FlagDisableFocusedExpressionCoverage

_name = 'nocoverfec'

class FlagEnableRapidExpressionCoverage

_name = 'coverrec'

class FlagDisableRapidExpressionCoverage

_name = 'nocoverrec'

class FlagEnableRecognitionOfImplicitFSMResetTransitions

_name = 'fsmresettrans'

class FlagDisableRecognitionOfImplicitFSMResetTransitions

_name = 'nofsmresettrans'

class FlagEnableRecognitionOfSingleBitFSMState

_name = 'fsmsingle'

class FlagDisableRecognitionOfSingleBitFSMState

_name = 'nofsmsingle'

class FlagEnableRecognitionOfImplicitFSMTransitions

_name = 'fsmimplicittrans'

class FlagDisableRecognitionOfImplicitFSMTransitions

_name = 'nofsmimplicittrans'

class SwitchFSMVerbosityLevel

_name = 'fsmverbose'

class FlagReportAsNote

_name = 'note'

_value = None

class FlagReportAsError

_name = 'error'

_value = None

class FlagReportAsWarning

_name = 'warning'

_value = None

class FlagReportAsFatal

_name = 'fatal'

_value = None

class FlagRelaxLanguageChecks

_name = 'permissive'

class FlagForceLanguageChecks

_name = 'pedanticerrors'

class SwitchVHDLVersion

_pattern = '-{0}'

_value = None

class ArgLogFile

_name = 'l'

_value = None

class SwitchVHDLLibrary

_name = 'work'

_value = None

class ArgSourceFile

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.Executable'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagTime'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagExplicit'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagQuietMode'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.SwitchModelSimIniFile'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagRangeCheck'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.SwitchCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagEnableFocusedExpressionCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagDisableFocusedExpressionCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagEnableRapidExpressionCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagDisableRapidExpressionCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagEnableRecognitionOfImplicitFSMResetTransitions'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagDisableRecognitionOfImplicitFSMResetTransitions'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagEnableRecognitionOfSingleBitFSMState'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagDisableRecognitionOfSingleBitFSMState'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagEnableRecognitionOfImplicitFSMTransitions'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagDisableRecognitionOfImplicitFSMTransitions'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.SwitchFSMVerbosityLevel'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagReportAsNote'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagReportAsError'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagReportAsWarning'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagReportAsFatal'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagRelaxLanguageChecks'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.FlagForceLanguageChecks'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.SwitchVHDLVersion'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.ArgLogFile'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.SwitchVHDLLibrary'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLCompiler.ArgSourceFile'>]

Compile()

GetTclCommand()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

The executable to launch.

_value = None

class FlagQuietMode

Run simulation in quiet mode. (Don’t show ‘Loading…’ messages.

_name = 'quiet'

_value = None

class FlagBatchMode

Run simulation in batch mode.

_name = 'batch'

_value = None

class FlagGuiMode

Run simulation in GUI mode.

_name = 'gui'

_value = None

class SwitchBatchCommand

Specify a Tcl batch script for the batch mode.

_name = 'do'

_value = None

class FlagCommandLineMode

Run simulation in command line mode.

_name = 'c'

_value = None

class SwitchModelSimIniFile

Specify the used ‘modelsim.ini’ file.

_name = 'modelsimini'

_value = None

class FlagEnableOptimization

Enabled optimization while elaborating the design.

_name = 'vopt'

class FlagDisableOptimization

Disabled optimization while elaborating the design.

_name = 'novopt'

class FlagEnableOptimizationVerbosity

Enabled optimization while elaborating the design.

_name = 'vopt_verbose'

class FlagEnableKeepAssertionCountsForCoverage

_name = 'assertcover'

class FlagDisableKeepAssertionCountsForCoverage

_name = 'noassertcover'

class FlagEnableCoverage

_name = 'coverage'

class FlagDisableCoverage

_name = 'nocoverage'

class FlagEnablePSL

_name = 'psl'

class FlagDisablePSL

_name = 'nopsl'

class FlagEnableFSMDebugging

_name = 'fsmdebug'

class FlagReportAsNote

_name = 'note'

_value = None

class FlagReportAsError

_name = 'error'

_value = None

class FlagReportAsWarning

_name = 'warning'

_value = None

class FlagReportAsFatal

_name = 'fatal'

_value = None

class FlagRelaxLanguageChecks

_name = 'permissive'

class FlagForceLanguageChecks

_name = 'pedanticerrors'

class SwitchTimeResolution

Set simulation time resolution.

_name = 't'

_value = None

class ArgLogFile

_name = 'l'

_value = None

class ArgKeepStdOut

_name = 'keepstdout'

class ArgVHDLLibraryName

_name = 'lib'

_value = None

class ArgOnFinishMode

_name = 'onfinish'

_value = None

class SwitchTopLevel

The top-level for simulation.

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.Executable'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagQuietMode'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagBatchMode'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagGuiMode'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.SwitchBatchCommand'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagCommandLineMode'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.SwitchModelSimIniFile'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagEnableOptimization'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagDisableOptimization'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagEnableOptimizationVerbosity'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagEnableKeepAssertionCountsForCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagDisableKeepAssertionCountsForCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagEnableCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagDisableCoverage'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagEnablePSL'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagDisablePSL'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagEnableFSMDebugging'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagReportAsNote'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagReportAsError'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagReportAsWarning'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagReportAsFatal'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagRelaxLanguageChecks'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.FlagForceLanguageChecks'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.ArgLogFile'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.ArgKeepStdOut'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.ArgVHDLLibraryName'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.SwitchTimeResolution'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.ArgOnFinishMode'>, <class 'pyIPCMI.ToolChain.Mentor.ModelSim.VHDLSimulator.SwitchTopLevel'>]

Specify all accepted command line arguments

Simulate()

Start a simulation.

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

Functions

pyIPCMI.ToolChain.Mentor.ModelSim.VLibFilter(gen)

pyIPCMI.ToolChain.Mentor.ModelSim.VComFilter(gen)

pyIPCMI.ToolChain.Mentor.ModelSim.VSimFilter(gen)

pyIPCMI.ToolChain.Mentor.QuestaSim

Exceptions

• QuestaSimException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.

exception pyIPCMI.ToolChain.Mentor.QuestaSim.QuestaSimException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Mentor.QuestaSim.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Mentor'

The name of the tools vendor.

_toolName = 'Mentor QuestaSim'

The name of the tool.

_section = 'INSTALL.Mentor.QuestaSim'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Mentor QuestaSim supports multiple versions installed on the same system.

_template = {'Linux': {'INSTALL.Mentor.QuestaSim': {'Version': '10.5c', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'AdditionalVComOptions': ('${${SectionName}:AdditionalVComOptions}', ''), 'SectionName': ('%{PathWithRoot}#${Version}', None), 'AdditionalVSimOptions': ('${${SectionName}:AdditionalVSimOptions}', ''), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Mentor:InstallationDirectory}/${Version}/questasim')}}, 'Windows': {'INSTALL.Mentor.QuestaSim': {'Version': '10.5c', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/win64'), 'AdditionalVComOptions': ('${${SectionName}:AdditionalVComOptions}', ''), 'SectionName': ('%{PathWithRoot}#${Version}', None), 'AdditionalVSimOptions': ('${${SectionName}:AdditionalVSimOptions}', ''), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Mentor:InstallationDirectory}/QuestaSim/${Version}')}}}

The template for the configuration sections represented as nested dictionaries.

ConfigureForAll()

Configuration routine for Mentor Graphics ModelSim on all supported platforms.

1. Ask if ModelSim is installed.

• Pass → skip this configuration. Don’t change existing settings.
• Yes → collect installation information for ModelSim.
• No → clear the ModelSim configuration section.

1. Ask for ModelSim’s version.
2. Ask for ModelSim’s edition (PE, PE student, SE 32-bit, SE 64-bit).
3. Ask for ModelSim’s installation directory.

_CheckQuestaSimVersion(binPath, version)

CheckDependency()

Check if general Mentor Graphics support is configured in pyIPCMI.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_CheckModelSimVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_GetModelSimVersion(binPath)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

Exceptions

• MentorException: Base class for all tool specific exceptions

Classes

• Configuration: Configuration routines for Mentor Graphics as a vendor.

exception pyIPCMI.ToolChain.Mentor.MentorException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Mentor.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Mentor Graphics as a vendor.

This configuration provides a common installation directory setup for all Mentor Graphics tools installed on a system.

Inheritance

Members

_vendor = 'Mentor'

The name of the tools vendor.

_section = 'INSTALL.Mentor'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'ALL': {'INSTALL.ModelSim': {'Version': '${${SectionName}:Version}', 'BinaryDirectory': '${${SectionName}:BinaryDirectory}', 'AdditionalVComOptions': '${${SectionName}:AdditionalVComOptions}', 'SectionName': '', 'AdditionalVSimOptions': '${${SectionName}:AdditionalVSimOptions}', 'InstallationDirectory': '${${SectionName}:InstallationDirectory}', 'Edition': '${${SectionName}:Edition}'}}, 'Linux': {'INSTALL.Mentor': {'InstallationDirectory': '/opt/mentor'}}, 'Windows': {'INSTALL.Mentor': {'InstallationDirectory': 'C:/Mentor'}}}

The template for the configuration sections represented as nested dictionaries.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

pyIPCMI.ToolChain.PoC

Classes

• Configuration: Base class for all tool Configuration classes.

class pyIPCMI.ToolChain.PoC.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'VLSI-EDA'

The name of the tools vendor.

_toolName = 'PoC'

The name of the tool.

_section = 'INSTALL.PoC'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'ALL': {'INSTALL.PoC': {'GitRemoteBranch': 'master', 'Version': '1.1.2', 'MultiVersionSupport': 'True', 'IsGitRepository': 'True', 'HasInstalledGitHooks': 'False', 'HasInstalledGitFilters': 'False', 'RepositoryKind': 'Public', 'InstallationDirectory': ''}, 'SOLUTION.Solutions': {}}}

The template for the configuration sections represented as nested dictionaries.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

pyIPCMI.ToolChain.Synopsys

Exceptions

• SynopsysException: Base class for all tool specific exceptions

Classes

• Configuration: Configuration routines for Synopsys as a vendor.
• SynopsysDesignConstraintFile: Undocumented.

exception pyIPCMI.ToolChain.Synopsys.SynopsysException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Synopsys.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Synopsys as a vendor.

This configuration provides a common installation directory setup for all Synopsys tools installed on a system.

Inheritance

Members

_vendor = 'Synopsys'

The name of the tools vendor.

_section = 'INSTALL.Synopsys'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Synopsys': {'InstallationDirectory': '/opt/Synopsys'}}, 'Windows': {'INSTALL.Synopsys': {'InstallationDirectory': 'C:/Synopsys'}}}

The template for the configuration sections represented as nested dictionaries.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

class pyIPCMI.ToolChain.Synopsys.SynopsysDesignConstraintFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.SdcConstraintFile bits=0x1000 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

pyIPCMI.ToolChain.Windows

Exceptions

• WindowsException: Base class for all tool specific exceptions

Classes

• Cmd: Represent an executable.

exception pyIPCMI.ToolChain.Windows.WindowsException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Windows.Cmd(platform, dryrun, logger=None)

Inheritance

Members

class Executable

class SwitchCommand

_name = 'C'

Parameters = [<class 'pyIPCMI.ToolChain.Windows.Cmd.Executable'>, <class 'pyIPCMI.ToolChain.Windows.Cmd.SwitchCommand'>]

GetEnvironment(settingsFile=None)

GetReader()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

pyIPCMI.ToolChain.Xilinx

Submodules

pyIPCMI.ToolChain.Xilinx.ISE

Exceptions

• ISEException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• ISE: Undocumented.
• Fuse: Represent an executable.
• ISESimulator: Represent an executable.
• Xst: Represent an executable.
• CoreGenerator: Represent an executable.
• ISEProject: Undocumented.
• ISEProjectFile: Undocumented.
• UserConstraintFile: Undocumented.

Functions

• VhCompFilter(): Undocumented.
• FuseFilter(): Undocumented.
• SimulatorFilter(): Undocumented.
• XstFilter(): Undocumented.
• CoreGeneratorFilter(): Undocumented.

exception pyIPCMI.ToolChain.Xilinx.ISE.ISEException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Xilinx.ISE.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Xilinx'

The name of the tools vendor.

_toolName = 'Xilinx ISE'

The name of the tool.

_section = 'INSTALL.Xilinx.ISE'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Xilinx ISE supports multiple versions installed on the same system.

_template = {'Linux': {'INSTALL.Xilinx.ISE': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '14.7', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/ISE/bin/lin64'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Xilinx:InstallationDirectory}/${Version}/ISE_DS')}}, 'Windows': {'INSTALL.Xilinx.ISE': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '14.7', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/ISE/bin/nt64'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Xilinx:InstallationDirectory}/${Version}/ISE_DS')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if general Xilinx support is configured in pyIPCMI.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckISEVersion(binPath)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Xilinx.ISE.ISE(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

PreparseEnvironment(installationDirectory)

GetVHDLCompiler()

GetFuse()

GetXst()

GetCoreGenerator()

class pyIPCMI.ToolChain.Xilinx.ISE.Fuse(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class FlagIncremental

_name = 'incremental'

class FlagRangeCheck

_name = 'rangecheck'

class SwitchMultiThreading

_name = 'mt'

class SwitchTimeResolution

_name = 'timeprecision_vhdl'

class SwitchProjectFile

_name = 'prj'

class SwitchOutputFile

_name = 'o'

class ArgTopLevel

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.FlagIncremental'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.FlagRangeCheck'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.SwitchMultiThreading'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.SwitchTimeResolution'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.SwitchProjectFile'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.SwitchOutputFile'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Fuse.ArgTopLevel'>]

Link()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.ISE.ISESimulator(platform, dryrun, executablePath, environment, logger=None)

Inheritance

Members

class Executable

class SwitchLogFile

_name = 'log'

class FlagGuiMode

_name = 'gui'

class SwitchTclBatchFile

_name = 'tclbatch'

class SwitchWaveformFile

_name = 'view'

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.ISE.ISESimulator.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.ISESimulator.SwitchLogFile'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.ISESimulator.FlagGuiMode'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.ISESimulator.SwitchTclBatchFile'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.ISESimulator.SwitchWaveformFile'>]

Simulate()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.ISE.Xst(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class SwitchIntStyle

_name = 'intstyle'

class SwitchXstFile

_name = 'ifn'

class SwitchReportFile

_name = 'ofn'

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.ISE.Xst.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Xst.SwitchIntStyle'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Xst.SwitchXstFile'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.Xst.SwitchReportFile'>]

Compile()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.ISE.CoreGenerator(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

class FlagRegenerate

_name = 'r'

class SwitchProjectFile

_name = 'p'

class SwitchBatchFile

_name = 'b'

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.ISE.CoreGenerator.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.CoreGenerator.FlagRegenerate'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.CoreGenerator.SwitchProjectFile'>, <class 'pyIPCMI.ToolChain.Xilinx.ISE.CoreGenerator.SwitchBatchFile'>]

Generate()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.ISE.ISEProject(name)

Inheritance

Members

AddExternalVHDLLibraries(library)

AddFile(file, fileSet=None)

AddFileSet(fileSet)

AddSourceFile(file, fileSet=None)

Board

CreateFileSet(name, setDefault=True)

DefaultFileSet

Device

Environment

ExternalVHDLLibraries

ExtractVHDLLibrariesFromVHDLSourceFiles()

FileSets

Files(fileType=<FileTypes(Text|ProjectFile|FileListFile|RulesFile|SourceFile|VHDLSourceFile|VerilogSourceFile|PythonSourceFile|CocotbSourceFile|ConstraintFile|UcfConstraintFile|XdcConstraintFile|SdcConstraintFile|LdcConstraintFile|SettingsFile|QuartusSettingsFile) bits=0xFFFF>, fileSet=None)

GetVariables()

Name

RootDirectory

Tool

ToolChain

VHDLLibraries

VHDLVersion

pprint(indent=0)

class pyIPCMI.ToolChain.Xilinx.ISE.ISEProjectFile(file)

Inheritance

Members

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_FileType = <FileTypes.ProjectFile bits=0x0002 data=UNDEFINED>

_ReadContent()

class pyIPCMI.ToolChain.Xilinx.ISE.UserConstraintFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.UcfConstraintFile bits=0x0400 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

Functions

pyIPCMI.ToolChain.Xilinx.ISE.VhCompFilter(gen)

pyIPCMI.ToolChain.Xilinx.ISE.FuseFilter(gen)

pyIPCMI.ToolChain.Xilinx.ISE.SimulatorFilter(gen)

pyIPCMI.ToolChain.Xilinx.ISE.XstFilter(gen)

pyIPCMI.ToolChain.Xilinx.ISE.CoreGeneratorFilter(gen)

pyIPCMI.ToolChain.Xilinx.Vivado

Exceptions

• VivadoException: Base class for all tool specific exceptions

Classes

• Configuration: Base class for all tool Configuration classes.
• ToolMixIn: Undocumented.
• Vivado: Undocumented.
• XElab: Represent an executable.
• XSim: Represent an executable.
• Synth: Represent an executable.
• VivadoProject: Undocumented.
• VivadoProjectFile: Undocumented.
• XilinxDesignConstraintFile: Undocumented.

Functions

• ElaborationFilter(): Undocumented.
• SimulatorFilter(): Undocumented.
• CompilerFilter(): Undocumented.

exception pyIPCMI.ToolChain.Xilinx.Vivado.VivadoException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Xilinx.Vivado.Configuration(host: pyIPCMI.Base.IHost)

Inheritance

Members

_vendor = 'Xilinx'

The name of the tools vendor.

_toolName = 'Xilinx Vivado'

The name of the tool.

_section = 'INSTALL.Xilinx.Vivado'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_multiVersionSupport = True

Xilinx Vivado supports multiple versions installed on the same system.

_template = {'Linux': {'INSTALL.Xilinx.Vivado': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '2016.3', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Xilinx:InstallationDirectory}/Vivado/${Version}')}}, 'Windows': {'INSTALL.Xilinx.Vivado': {'SectionName': ('%{PathWithRoot}#${Version}', None), 'Version': '2016.3', 'BinaryDirectory': ('${${SectionName}:BinaryDirectory}', '${InstallationDirectory}/bin'), 'InstallationDirectory': ('${${SectionName}:InstallationDirectory}', '${INSTALL.Xilinx:InstallationDirectory}/Vivado/${Version}')}}}

The template for the configuration sections represented as nested dictionaries.

CheckDependency()

Check if general Xilinx support is configured in pyIPCMI.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

PrepareVersionedSections(writeWarnings=False)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_Configuration__CheckVivadoVersion(binPath, version)

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

_ConfigureEdition(editions, defaultEdition)

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Xilinx.Vivado.ToolMixIn(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

class pyIPCMI.ToolChain.Xilinx.Vivado.Vivado(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

PreparseEnvironment(installationDirectory)

GetElaborator()

GetSimulator()

GetSynthesizer()

class pyIPCMI.ToolChain.Xilinx.Vivado.XElab(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

_value = None

class FlagRangeCheck

_name = 'rangecheck'

_value = None

class SwitchMultiThreading

_name = 'mt'

_value = None

class SwitchVerbose

_name = 'verbose'

_value = None

class SwitchDebug

_name = 'debug'

_value = None

class SwitchOptimization

_pattern = '--{0}{1}'

_name = 'O'

_value = None

class SwitchTimeResolution

_name = 'timeprecision_vhdl'

_value = None

class SwitchProjectFile

_name = 'prj'

_value = None

class SwitchLogFile

_name = 'log'

_value = None

class SwitchSnapshot

_name = 's'

_value = None

class ArgTopLevel

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.FlagRangeCheck'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchMultiThreading'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchTimeResolution'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchVerbose'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchDebug'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchOptimization'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchProjectFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchLogFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.SwitchSnapshot'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XElab.ArgTopLevel'>]

Link()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.Vivado.XSim(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

_value = None

class SwitchLogFile

_name = '-log'

_value = None

class FlagGuiMode

_name = '-gui'

_value = None

class SwitchTclBatchFile

_name = '-tclbatch'

_value = None

class SwitchWaveformFile

_name = '-view'

_value = None

class SwitchSnapshot

_value = None

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.Vivado.XSim.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XSim.SwitchLogFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XSim.FlagGuiMode'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XSim.SwitchTclBatchFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XSim.SwitchWaveformFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.XSim.SwitchSnapshot'>]

Simulate()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.Vivado.Synth(toolchain: pyIPCMI.ToolChain.ToolMixIn)

Inheritance

Members

class Executable

_value = None

class SwitchLogFile

_name = 'log'

_value = None

class SwitchSourceFile

_name = 'source'

_value = None

class SwitchMode

_name = 'mode'

_value = 'batch'

Parameters = [<class 'pyIPCMI.ToolChain.Xilinx.Vivado.Synth.Executable'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.Synth.SwitchLogFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.Synth.SwitchSourceFile'>, <class 'pyIPCMI.ToolChain.Xilinx.Vivado.Synth.SwitchMode'>]

Compile()

GetReader()

HasErrors

True if errors or fatals errors were found while processing the output stream.

HasWarnings

True if errors or fatals errors were found while processing the output stream.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

Path

ReadUntilBoundary(indent=0)

Send(line, end='\n')

SendBoundary()

StartProcess(parameterList)

Terminate()

_TryLog(*args, condition=True, **kwargs)

_pyIPCMI_BOUNDARY = '====== pyIPCMI BOUNDARY ======'

class pyIPCMI.ToolChain.Xilinx.Vivado.VivadoProject(name)

Inheritance

Members

AddExternalVHDLLibraries(library)

AddFile(file, fileSet=None)

AddFileSet(fileSet)

AddSourceFile(file, fileSet=None)

Board

CreateFileSet(name, setDefault=True)

DefaultFileSet

Device

Environment

ExternalVHDLLibraries

ExtractVHDLLibrariesFromVHDLSourceFiles()

FileSets

Files(fileType=<FileTypes(Text|ProjectFile|FileListFile|RulesFile|SourceFile|VHDLSourceFile|VerilogSourceFile|PythonSourceFile|CocotbSourceFile|ConstraintFile|UcfConstraintFile|XdcConstraintFile|SdcConstraintFile|LdcConstraintFile|SettingsFile|QuartusSettingsFile) bits=0xFFFF>, fileSet=None)

GetVariables()

Name

RootDirectory

Tool

ToolChain

VHDLLibraries

VHDLVersion

pprint(indent=0)

class pyIPCMI.ToolChain.Xilinx.Vivado.VivadoProjectFile(file)

Inheritance

Members

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_FileType = <FileTypes.ProjectFile bits=0x0002 data=UNDEFINED>

_ReadContent()

class pyIPCMI.ToolChain.Xilinx.Vivado.XilinxDesignConstraintFile(file, project=None, fileSet=None)

Inheritance

Members

_FileType = <FileTypes.XdcConstraintFile bits=0x0800 data=UNDEFINED>

FileName

FileSet

FileType

Open()

Path

Project

ReadFile()

_ReadContent()

Functions

pyIPCMI.ToolChain.Xilinx.Vivado.ElaborationFilter(gen)

pyIPCMI.ToolChain.Xilinx.Vivado.SimulatorFilter(gen)

pyIPCMI.ToolChain.Xilinx.Vivado.CompilerFilter(gen)

Exceptions

• XilinxException: Base class for all tool specific exceptions

Classes

• Configuration: Configuration routines for Xilinx as a vendor.
• XilinxProjectExportMixIn: Undocumented.

exception pyIPCMI.ToolChain.Xilinx.XilinxException(message='')

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.Xilinx.Configuration(host: pyIPCMI.Base.IHost)

Configuration routines for Xilinx as a vendor.

This configuration provides a common installation directory setup for all Xilinx tools installed on a system.

Inheritance

Members

_vendor = 'Xilinx'

The name of the tools vendor.

_section = 'INSTALL.Xilinx'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_template = {'Linux': {'INSTALL.Xilinx': {'InstallationDirectory': '/opt/Xilinx'}}, 'Windows': {'INSTALL.Xilinx': {'InstallationDirectory': 'C:/Xilinx'}}}

The template for the configuration sections represented as nested dictionaries.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsConfigured()

Return true if the configurations section is configured

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

class pyIPCMI.ToolChain.Xilinx.XilinxProjectExportMixIn

Inheritance

Members

_GenerateXilinxProjectFileContent(tool, vhdlVersion=93)

_WriteXilinxProjectFile(projectFilePath, tool, vhdlVersion=93)

Exceptions

• ToolChainException: Base class for all tool specific exceptions
• ConfigurationException: ConfigurationException is raise while running configuration or database
• SkipConfigurationException: SkipConfigurationException is a ConfigurationException,

Classes

• ConfigurationState: Describes the configuration state of a tool or vendor.
• ChangeState: Describes if a configuration was changed.
• ToolMixIn: Undocumented.
• AskMixIn: Undocumented.
• Configuration: Base class for all Configuration classes.
• VendorConfiguration: Base class for all vendor Configuration classes.
• ToolConfiguration: Base class for all tool Configuration classes.
• EditionDescription: EditionDescription(Name, Section)
• Edition: An enumeration.
• ToolSelector: Base class for all Selector classes.
• Configurator: A instance of this class controls the interactive configuration process.

exception pyIPCMI.ToolChain.ToolChainException(message='')

Base class for all tool specific exceptions

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.ToolChain.ConfigurationException(message='')

ConfigurationException is raise while running configuration or database tasks in pyIPCMI

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

exception pyIPCMI.ToolChain.SkipConfigurationException(message='')

SkipConfigurationException is a ConfigurationException, which can be skipped.

Inheritance

Members

args

with_traceback(tb)

Exception.with_traceback(tb) – set self.__traceback__ to tb and return self.

class pyIPCMI.ToolChain.ConfigurationState

Describes the configuration state of a tool or vendor.

Inheritance

Members

Unconfigured = 0

Configured = 1

class pyIPCMI.ToolChain.ChangeState

Describes if a configuration was changed.

Inheritance

Members

Unchanged = 0

Changed = 1

class pyIPCMI.ToolChain.ToolMixIn(platform, dryrun, binaryDirectoryPath, version, logger=None)

Inheritance

Members

class pyIPCMI.ToolChain.AskMixIn

Inheritance

Members

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

class pyIPCMI.ToolChain.Configuration(host: pyIPCMI.Base.IHost)

Base class for all Configuration classes.

Inheritance

Members

_vendor = 'Unknown'

The name of the tools vendor.

_section = 'INSTALL.Name'

The name of the configuration section. Pattern: INSTALL.Tool.

_multiVersionSupport = False

True if a tool supports multiple versions installed on the same system.

_template = {'ALL': {'INSTALL.Name': {}}, 'Darwin': {'INSTALL.Name': {}}, 'Linux': {'INSTALL.Name': {}}, 'MinGW': {'INSTALL.Name': {}}, 'Windows': {'INSTALL.Name': {}}}

The template for the configuration sections represented as nested dictionaries.

Host

Return the hosting object.

State

Return the configuration state.

SectionName

Return the configuration’s section name.

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

IsConfigured()

Return true if the configurations section is configured

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

classmethod GetSections(platform)

Return all section names for this configuration.

PrepareSections(warningWasWritten, writeWarnings=True)

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

PrepareOptions(writeWarnings=True)

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

_AskInstalled(question)

Ask a Yes/No/Pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.VendorConfiguration(host: pyIPCMI.Base.IHost)

Base class for all vendor Configuration classes.

Inheritance

Members

_section = 'INSTALL.Vendor.Tool'

The name of the configuration section. Pattern: INSTALL.Vendor.

_template = {'Darwin': {'INSTALL.Vendor.Tool': {'InstallationDirectory': '/opt/Vendor'}}, 'Linux': {'INSTALL.Vendor.Tool': {'InstallationDirectory': '/opt/Vendor'}}, 'Windows': {'INSTALL.Vendor.Tool': {'InstallationDirectory': 'C:/Vendor'}}}

The template for the configuration section represented as nested dictionaries.

IsConfigured()

Return true if the vendor represented by this Configuration class is configured in pyIPCMI.

Inherited method IsConfigured() from class Configuration.

ConfigureForAll()

Start a generic (platform independent) vendor configuration procedure.

This method configures a vendor path. Overwrite this method to implement a vendor specific configuration routine for a vendor Configuration class.

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_vendor = 'Unknown'

class pyIPCMI.ToolChain.ToolConfiguration(host: pyIPCMI.Base.IHost)

Base class for all tool Configuration classes.

Inheritance

Members

_section = 'INSTALL.Vendor.Tool'

The name of the configuration section. Pattern: INSTALL.Vendor.ToolName.

_toolName = 'Tool'

The name of the tool.

_template = {'ALL': {'INSTALL.Vendor.Tool': {'Version': '1.0'}}, 'Darwin': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Linux': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool'}}, 'Windows': {'INSTALL.Vendor.Tool': {'BinaryDirectory': '${InstallationDirectory}/bin', 'InstallationDirectory': '${INSTALL.Vendor:InstallationDirectory}/${Version}/Tool/'}}}

The template for the configuration section represented as nested dictionaries.

IsConfigured()

Return true if the tool represented by this Configuration class is configured in pyIPCMI.

Inherited method IsConfigured() from class Configuration.

_ConfigureVersion()

If no version was configured before, then _GetDefaultVersion is called. Asks for version and updates section. Returns version as string.

_GetDefaultVersion()

Returns unresolved default version (str) from template.

Overwrite this method in a sub-class for automatic search of version.

_ConfigureEdition(editions, defaultEdition)

_GetDefaultEdition()

Returns unresolved default edition (str) from template.

Overwrite this method in a sub-class for automatic search of editions.

_ConfigureBinaryDirectory()

Updates section with value from _template and returns directory as Path object.

PrepareVersionedSections(writeWarnings=False)

CheckDependency()

Check if all vendor or tool dependencies are fulfilled to configure this tool.

ClearSection(writeWarnings=False)

Clear the configuration section associated to this Configuration class.

ConfigureForAll()

Start a generic (platform independent) configuration procedure.

Overwrite this method to implement a generic configuration routine for a (tool) Configuration class.

ConfigureForDarwin()

Start the configuration procedure for Darwin.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Darwin specific configuration routine.

ConfigureForLinux()

Start the configuration procedure for Linux.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Linux specific configuration routine.

ConfigureForWindows()

Start the configuration procedure for Windows.

This method is a wrapper for ConfigureForAll(). Overwrite this method to implement a Windows specific configuration routine.

classmethod GetSections(platform)

Return all section names for this configuration.

Host

Return the hosting object.

IsSupportedPlatform()

Return true if the given platform is supported by this configuration routine.

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

PrepareOptions(writeWarnings=True)

PrepareSections(warningWasWritten, writeWarnings=True)

RunPostConfigurationTasks()

Virtual method. Overwrite to execute post-configuration tasks.

SectionName

Return the configuration’s section name.

State

Return the configuration state.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskInstalled(question)

Ask a Yes/No/Pass question.

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_ConfigureInstallationDirectory()

Asks for installation directory and updates section. Checks if entered directory exists and returns Path object. If no installation directory was configured before, then _GetDefaultInstallationDir is called.

_GetDefaultInstallationDirectory()

Return unresolved default installation directory (str) from template.

Overwrite function in sub-class for automatic search of installation directory.

_GetDefaultOptionValue(optionName)

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TestDefaultInstallPath(defaults)

Helper function for automatic search of installation directory.

_TryLog(*args, condition=True, **kwargs)

_multiVersionSupport = False

_vendor = 'Unknown'

class pyIPCMI.ToolChain.EditionDescription(Name, Section)

Inheritance

Members

Name

Alias for field number 0

Section

Alias for field number 1

_asdict()

Return a new OrderedDict which maps field names to their values.

_fields = ('Name', 'Section')

classmethod _make(iterable, new=<built-in method __new__ of type object at 0xa385c0>, len=<built-in function len>)

Make a new EditionDescription object from a sequence or iterable

_replace(**kwds)

Return a new EditionDescription object replacing specified fields with new values

_source = "from builtins import property as _property, tuple as _tuple\nfrom operator import itemgetter as _itemgetter\nfrom collections import OrderedDict\n\nclass EditionDescription(tuple):\n 'EditionDescription(Name, Section)'\n\n __slots__ = ()\n\n _fields = ('Name', 'Section')\n\n def __new__(_cls, Name, Section):\n 'Create new instance of EditionDescription(Name, Section)'\n return _tuple.__new__(_cls, (Name, Section))\n\n @classmethod\n def _make(cls, iterable, new=tuple.__new__, len=len):\n 'Make a new EditionDescription object from a sequence or iterable'\n result = new(cls, iterable)\n if len(result) != 2:\n raise TypeError('Expected 2 arguments, got %d' % len(result))\n return result\n\n def _replace(_self, **kwds):\n 'Return a new EditionDescription object replacing specified fields with new values'\n result = _self._make(map(kwds.pop, ('Name', 'Section'), _self))\n if kwds:\n raise ValueError('Got unexpected field names: %r' % list(kwds))\n return result\n\n def __repr__(self):\n 'Return a nicely formatted representation string'\n return self.__class__.__name__ + '(Name=%r, Section=%r)' % self\n\n def _asdict(self):\n 'Return a new OrderedDict which maps field names to their values.'\n return OrderedDict(zip(self._fields, self))\n\n def __getnewargs__(self):\n 'Return self as a plain tuple. Used by copy and pickle.'\n return tuple(self)\n\n Name = _property(_itemgetter(0), doc='Alias for field number 0')\n\n Section = _property(_itemgetter(1), doc='Alias for field number 1')\n\n"

count(value) → integer -- return number of occurrences of value

index(value[, start[, stop]]) → integer -- return first index of value.

Raises ValueError if the value is not present.

class pyIPCMI.ToolChain.Edition(name, section)

An enumeration.

Inheritance

Members

class pyIPCMI.ToolChain.ToolSelector(host: pyIPCMI.Base.IHost)

Base class for all Selector classes.

Inheritance

Members

_toolName = ''

ToolName

_GetConfiguredEditions(editions)

Return all configured editions.

_AskSelection(editions, defaultEdition)

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.ToolChain.Configurator(host: pyIPCMI.Base.IHost)

A instance of this class controls the interactive configuration process.

Inheritance

Members

ConfigureAll()

Select all tool chains for configuration

ConfigureTool(toolChain)

Select tool chains for configuration.

InitializeConfiguration()

Initialize pyIPCMI’s configuration with empty sections.

The list of sections is gathered from all enabled configurators’ _template fields.

UpdateConfiguration()

Update an existing configuration e.g. after a pyIPCMI update.

_ConfigureTools(configurators)

Run the configuration routines for a list of configurators

_ConfigurationLoop(configurator)

Retry to configure a vendor or tool until it succeeds or the user presses P to pass a configuration step.

A :py:exec:`KeyboardInterrupt` should be handled in a calling method.

ConfigureDefaultTools()

_ConfigureDefaultTools()

_WriteConfigurationHeader()

Write a header containing general information about the configuration and list allowed input values for yes/no/pass questions.

_AskConfigureDefaultTools()

Ask if default tools should be configured now.

Relocated()

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

_Ask(question, default, beforeDefault='', afterDefault='', indent=1)

_AskYes_NoPass(question, indent=1)

Ask a yes/NO/pass question.

_Ask_YesNoPass(question, indent=1)

Ask a YES/no/pass question.

_PrintAvailableEditions(editions, selectedEdition)

Print all available editions and return the selected index.

_TryLog(*args, condition=True, **kwargs)

Classes

• pyIPCMIEntityAttribute: Undocumented.
• BoardDeviceAttributeGroup: Undocumented.
• VHDLVersionAttribute: Undocumented.
• SimulationStepsAttributeGroup: Undocumented.
• CompileStepsAttributeGroup: Undocumented.
• IPCoreManagementInfrastructure: A mixin class to provide local logging methods.

class pyIPCMI.pyIPCMIEntityAttribute

Inheritance

Members

classmethod GetAttributes(method)

classmethod GetMethods(cl)

static _AppendAttribute(func, attribute)

_debug = False

class pyIPCMI.BoardDeviceAttributeGroup

Inheritance

Members

classmethod GetAttributes(method)

classmethod GetMethods(cl)

static _AppendAttribute(func, attribute)

_debug = False

class pyIPCMI.VHDLVersionAttribute

Inheritance

Members

classmethod GetAttributes(method)

classmethod GetMethods(cl)

static _AppendAttribute(func, attribute)

_debug = False

class pyIPCMI.SimulationStepsAttributeGroup

Inheritance

Members

classmethod GetAttributes(method)

classmethod GetMethods(cl)

static _AppendAttribute(func, attribute)

_debug = False

class pyIPCMI.CompileStepsAttributeGroup

Inheritance

Members

classmethod GetAttributes(method)

classmethod GetMethods(cl)

static _AppendAttribute(func, attribute)

_debug = False

class pyIPCMI.IPCoreManagementInfrastructure(debug, verbose, quiet, dryRun, sphinx=False)

Inheritance

Members

HeadLine = 'pyIPCMI - Service Tool'

Platform

DryRun

Directories

ConfigFiles

Config

Root

Repository

SaveAndReloadConfiguration()

Run()

PrintHeadline()

HandleDefault(_)

HandleHelp(args)

HandleInfo(args)

HandleConfiguration(args)

Handle ‘configure’ command.

HandleSelection(args)

Handle ‘select’ command.

HandleAddSolution(_)

HandleListSolution(_)

HandleRemoveSolution(args)

HandleListProject(args)

HandleQueryConfiguration(args)

_ExtractBoard(BoardName, DeviceName, force=False)

_ExtractFQNs(fqns, defaultLibrary=None, defaultType=<EntityTypes.Testbench: 2>)

_ExtractVHDLVersion(vhdlVersion, defaultVersion=None)

_CheckActiveHDL()

_CheckRivieraPRO()

_CheckQuartus()

_CheckDiamond()

_CheckModelSim()

_CheckISE()

_CheckVivado()

_CheckGHDL()

static _ExtractSimulationSteps(guiMode, analyze, elaborate, optimize, recompile, simulate, showWaveform, showCoverage, resimulate, showReport, cleanUp)

static _ExtractCompileSteps(guiMode, synthesize, showReport, cleanUp)

HandleListTestbenches(args)

HandleActiveHDLSimulation(args)

HandleGHDLSimulation(args)

HandleISESimulation(args)

HandleModelSimSimulation(args)

HandleAnyMentorSimulation(args)

HandleRivieraPROSimulation(args)

HandleQuestaSimSimulation(args)

HandleVivadoSimulation(args)

HandleCocotbSimulation(args)

HandleListNetlist(args)

HandleISECompilation(args)

HandleCoreGeneratorCompilation(args)

HandleXstCompilation(args)

HandleIpCatalogCompilation(args)

HandleVivadoCompilation(args)

HandleQuartusCompilation(args)

static GetAttributes(method)

GetMethods()

HandleLSECompilation(args)

static HasAttribute(method)

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

MainParser

SubParsers

_ArgParseMixin__mainParser = None

_ArgParseMixin__subParser = None

_ArgParseMixin__subParsers = {}

_IPCoreManagementInfrastructure__BackupConfiguration()

_IPCoreManagementInfrastructure__CONFIGFILE_BOARDS = 'config.boards.ini'

_IPCoreManagementInfrastructure__CONFIGFILE_DEFAULTS = 'config.defaults.ini'

_IPCoreManagementInfrastructure__CONFIGFILE_IPCORES = 'config.entity.ini'

_IPCoreManagementInfrastructure__CONFIGFILE_PRIVATE = 'config.private.ini'

_IPCoreManagementInfrastructure__CONFIGFILE_STRUCTURE = 'config.structure.ini'

_IPCoreManagementInfrastructure__CheckEnvironment()

_IPCoreManagementInfrastructure__CheckSection(sectionName, toolName)

_IPCoreManagementInfrastructure__PLATFORM = 'Linux'

_IPCoreManagementInfrastructure__PrepareForConfiguration()

_IPCoreManagementInfrastructure__PrepareForSimulation()

_IPCoreManagementInfrastructure__PrepareForSynthesis()

_IPCoreManagementInfrastructure__ReadConfiguration()

_IPCoreManagementInfrastructure__WriteConfiguration()

_TryLog(*args, condition=True, **kwargs)

class pyIPCMI.pyIPCMIEntityAttribute

Bases: lib.pyAttribute.Attribute

classmethod GetAttributes(method)

classmethod GetMethods(cl)

class pyIPCMI.BoardDeviceAttributeGroup

Bases: lib.pyAttribute.Attribute

classmethod GetAttributes(method)

classmethod GetMethods(cl)

class pyIPCMI.VHDLVersionAttribute

Bases: lib.pyAttribute.Attribute

classmethod GetAttributes(method)

classmethod GetMethods(cl)

class pyIPCMI.SimulationStepsAttributeGroup

Bases: lib.pyAttribute.Attribute

classmethod GetAttributes(method)

classmethod GetMethods(cl)

class pyIPCMI.CompileStepsAttributeGroup

Bases: lib.pyAttribute.Attribute

classmethod GetAttributes(method)

classmethod GetMethods(cl)

class pyIPCMI.IPCoreManagementInfrastructure(debug, verbose, quiet, dryRun, sphinx=False)

Bases: pyIPCMI.Base.Logging.ILogable, lib.pyAttribute.ArgParseAttributes.ArgParseMixin

HeadLine = 'pyIPCMI - Service Tool'

Platform

DryRun

Directories

ConfigFiles

Config

Root

Repository

SaveAndReloadConfiguration()

Run()

PrintHeadline()

HandleDefault(_)

HandleHelp(args)

HandleInfo(args)

HandleConfiguration(args)

Handle ‘configure’ command.

HandleSelection(args)

Handle ‘select’ command.

HandleAddSolution(_)

HandleListSolution(_)

HandleRemoveSolution(args)

HandleListProject(args)

HandleQueryConfiguration(args)

HandleListTestbenches(args)

HandleActiveHDLSimulation(args)

HandleGHDLSimulation(args)

HandleISESimulation(args)

HandleModelSimSimulation(args)

HandleAnyMentorSimulation(args)

HandleRivieraPROSimulation(args)

HandleQuestaSimSimulation(args)

HandleVivadoSimulation(args)

HandleCocotbSimulation(args)

HandleListNetlist(args)

HandleISECompilation(args)

HandleCoreGeneratorCompilation(args)

HandleXstCompilation(args)

HandleIpCatalogCompilation(args)

HandleVivadoCompilation(args)

HandleQuartusCompilation(args)

static GetAttributes(method)

GetMethods()

HandleLSECompilation(args)

static HasAttribute(method)

Log(entry, condition=True)

Write an entry to the local logger.

LogDebug(*args, condition=True, **kwargs)

LogDryRun(*args, condition=True, **kwargs)

LogError(*args, condition=True, **kwargs)

LogFatal(*args, condition=True, **kwargs)

LogInfo(*args, condition=True, **kwargs)

LogNormal(*args, condition=True, **kwargs)

LogQuiet(*args, condition=True, **kwargs)

LogVerbose(*args, condition=True, **kwargs)

LogWarning(*args, condition=True, **kwargs)

Logger

Return the local logger instance.

MainParser

SubParsers

Change Log

2016

New in 1.x (upcoming)

Already documented changes are available on the release branch at GitHub.

• VHDL common packages
• VHDL Simulation helpers
• New Entities
  • IP:ocram_sdp_wf
  • IP:ocram_tdp_wf
  • IP:cache_par2
  • IP:cache_cpu
  • IP:cache_mem
  • Simulation helper IP:ocram_tdp_sim
• Updated Entities
  • Interface of IP:cache_tagunit_par changed slightly.
  • New port “write-mask” in IP:ddr3_mem2mig_adapter_Series7.
  • New port “write-mask” in IP:ddr2_mem2mig_adapter_Spartan6.
  • Fixed IP:dstruct_deque
• New Testbenches
  • Testbench for IP:ocram_sdp_wf
  • Testbench for IP:ocram_tdp_wf
  • Testbench for IP:cache_par2
  • Testbench for IP:cache_cpu
  • Testbench for IP:cache_mem
• Updated Testbenches
  • Testbench for IP:ocram_sdp
  • Testbench for IP:ocram_esdp
  • Testbench for IP:ocram_tdp
  • Testbench for IP:sortnet_BitonicSort
  • Testbench for IP:sortnet_OddEvenSort
  • Testbench for IP:sortnet_OddEvenMergeSort
• New Constraints
• Updated Constraints
• Shipped Tool and Helper Scripts
• Python Infrastructure
  • Common changes
  • All Simulators
  • Aldec Active-HDL
  • GHDL
  • Mentor QuestaSim
  • Xilinx ISE Simulator
  • Xilinx Vivado Simulator
  • All Compilers
  • Altera Quartus Synthesis
  • Lattice Diamond (LSE)
  • Xilinx ISE (XST)
  • Xilinx ISE Core Generator
  • Xilinx Vivado Synthesis
• Continuous Integration
  • Implemented a simple Python infrastructe test on AppVeyor
• Documentation
  • Improved PDF rendering

New in 1.x (upcomming)

Already documented changes are available on the release branch at GitHub.

• Python Infrastructure
  • Common changes
    • The classes Simulator and Compiler now share common methods in base class called Shared.
  • *.files Parser
    • Implemented path expressions: sub-directory expression, concatenate expression
    • Implemented InterpolateLiteral: access database keys in *.files files
    • New Path statement, which defines a path constant calculated from a path expression
    • Replaced string arguments in statements with path expressions if the desired string was a path
    • Replaced simple StringToken matches with Identifier expressions
  • All Simulators
  • All Compilers
  • GHDL
    • Reduced -P<path> parameters: Removed doublings
• Documentation
• VHDL Simulation helpers
  • Mark a testbench as failed if (registered) processes are active while finalize is called
• Shipped Tool and Helper Scripts
  • Updated and new Notepad++ syntax files

New in 1.x (upcomming)

Already documented changes are available on the release branch at GitHub.

• Python Infrastructure
  • Common changes
    • The classes Simulator and Compiler now share common methods in base class called Shared.
  • *.files Parser
    • Implemented path expressions: sub-directory expression, concatenate expression
    • Implemented InterpolateLiteral: access database keys in *.files files
    • New Path statement, which defines a path constant calculated from a path expression
    • Replaced string arguments in statements with path expressions if the desired string was a path
    • Replaced simple StringToken matches with Identifier expressions
  • All Simulators
  • All Compilers
  • GHDL
    • Reduced -P<path> parameters: Removed doublings
• Documentation
• VHDL Simulation helpers
  • Mark a testbench as failed if (registered) processes are active while finalize is called
• Shipped Tool and Helper Scripts
  • Updated and new Notepad++ syntax files

New in 1.0 (13.05.2016)

• Python Infrastructure (Completely Reworked)

  • New Requirements
    • Python 3.5
    • py-flags
  • New command line interface
    • Synopsis: poc.sh|ps1 [common options] <command> <entity> [options]
    • Removed task specific wrapper scripts: testbench.sh|ps1, netlist.sh|ps1, …
    • Updated wrapper.ps1 and wrapper.sh files
  • New ini-file database
    • Added a new config.boards.ini file to list known boards (real and virtual ones)
  • New parser for *.files files
    • conditional compiling (if-then-elseif-else)
    • include statement - include other *.files files
    • library statement - reference external VHDL libraries
    • prepared for Cocotb testbenches
  • New parser for *.rules files
  • All Tool Flows
    • Unbuffered outputs from vendor tools (realtime output to stdout from subprocess)
    • Output filtering from vendor tools
      • verbose message suppression
      • error and warning message highlighting
      • abort flow on vendor tool errors
  • All Simulators
    • Run testbenches for different board or device configurations (see --board and --device command line options)
  • New Simulators
    • Aldec Active-HDL support (no GUI support)
      • Tested with Active-HDL from Lattice Diamond
      • Tested with Active-HDL Student Edition
    • Cocotb (with QuestaSim backend on Linux)
  • New Synthesizers
    • Altera Quartus II and Quartus Prime
      • Command: quartus
    • Lattice Synthesis Engine (LSE) from Diamond
      • Command: lse
    • Xilinx Vivado
      • Command: vivado
  • GHDL
    • GHDLSimulator can distinguish different backends (mcode, gcc, llvm)
    • Pre-compiled library support for GHDL
  • QuestaSim / ModelSim Altera Edition
    • Pre-compiled library support for GHDL
  • Vivado Simulator
    • Tested Vivado Simulator 2016.1 (xSim) with PoC -> still produces errors or false results

• Shipped Tool and Helper Scripts

  • Updated and new Notepad++ syntax files

  • Pre-compiled vendor library support

    • Added a new <PoCRoot>/temp/precompiled folder for precompiled vendor libraries
    • QuestaSim supports Altera QuartusII, Xilinx ISE and Xilinx Vivado libraries
    • GHDL supports Altera QuartusII, Xilinx ISE and Xilinx Vivado libraries

2015

New in v0.4 (29.04.2015)

• New Python infrastructure
  • Added simulators for:
    • GHDL + GTKWave
    • Mentor Graphic QuestaSim
    • Xilinx ISE Simulator
    • Xilinx Vivado Simulator

New in v0.3.0 (31.03.20015)

• Added Python infrastructure
  • Added platform wrapper scripts (*.sh, *.ps1)
  • Added IP-core compiler scripts Netlist.py
• Added Tools
  • Notepad++ syntax file for Xilinx UCF/XCF files
  • Git configuration script to register global aliases

2014

New in v0.0.0 (16.12.2014)

• Initial commit

Index