#! /usr/bin/env python2.3 ############################################################################## # # Copyright (c) 2001, 2002 Zope Corporation and Contributors. # All Rights Reserved. # # This software is subject to the provisions of the Zope Public License, # Version 2.0 (ZPL). A copy of the ZPL should accompany this distribution. # THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED # WARRANTIES ARE DISCLAIMED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED # WARRANTIES OF TITLE, MERCHANTABILITY, AGAINST INFRINGEMENT, AND FITNESS # FOR A PARTICULAR PURPOSE. # ############################################################################## """ test.py [-abBcdDfFgGhklLmMPprstTuUv] [modfilter [testfilter]] Find and run tests written using the unittest module. The test runner searches for Python modules that contain test suites. It collects those suites, and runs the tests. There are many options for controlling how the tests are run. There are options for using the debugger, reporting code coverage, and checking for refcount problems. The test runner uses the following rules for finding tests to run. It searches for packages and modules that contain "tests" as a component of the name, e.g. "frob.tests.nitz" matches this rule because tests is a sub-package of frob. Within each "tests" package, it looks for modules that begin with the name "test." For each test module, it imports the module and calls the module's test_suite() function, which must return a unittest TestSuite object. Options can be specified as command line arguments (see below). However, options may also be specified in a file named 'test.config', a Python script which, if found, will be executed before the command line arguments are processed. The test.config script should specify options by setting zero or more of the global variables: LEVEL, BUILD, and other capitalized variable names found in the test runner script (see the list of global variables in process_args().). -a level --at-level level --all Run the tests at the given level. Any test at a level at or below this is run, any test at a level above this is not run. Level 0 runs all tests. The default is to run tests at level 1. --all is a shortcut for -a 0. -b --build Run "python setup.py build" before running tests, where "python" is the version of python used to run test.py. Highly recommended. Tests will be run from the build directory. -B --build-inplace Run "python setup.py build_ext -i" before running tests. Tests will be run from the source directory. -c --pychecker use pychecker -d --debug Instead of the normal test harness, run a debug version which doesn't catch any exceptions. This is occasionally handy when the unittest code catching the exception doesn't work right. Unfortunately, the debug harness doesn't print the name of the test, so Use With Care. -D --debug-inplace Works like -d, except that it loads pdb when an exception occurs. --dir directory -s directory Option to limit where tests are searched for. This is important when you *really* want to limit the code that gets run. This can be specified more than once to run tests in two different parts of the source tree. For example, if refactoring interfaces, you don't want to see the way you have broken setups for tests in other packages. You *just* want to run the interface tests. -f --skip-unit Run functional tests but not unit tests. Note that functional tests will be skipped if the module zope.app.tests.functional cannot be imported. Functional tests also expect to find the file ftesting.zcml, which is used to configure the functional-test run. -F DEPRECATED. Run both unit and functional tests. This option is deprecated, because this is the new default mode. Note that functional tests will be skipped if the module zope.app.tests.functional cannot be imported. -g threshold --gc-threshold threshold Set the garbage collector generation0 threshold. This can be used to stress memory and gc correctness. Some crashes are only reproducible when the threshold is set to 1 (agressive garbage collection). Do "-g 0" to disable garbage collection altogether. -G gc_option --gc-option gc_option Set the garbage collection debugging flags. The argument must be one of the DEBUG_ flags defined bythe Python gc module. Multiple options can be specified by using "-G OPTION1 -G OPTION2." -k --keepbytecode Do not delete all stale bytecode before running tests -l test_root --libdir test_root Search for tests starting in the specified start directory (useful for testing components being developed outside the main "src" or "build" trees). -L --loop Keep running the selected tests in a loop. You may experience memory leakage. -m -M minimal GUI. See -U. -P --profile Run the tests under hotshot and display the top 50 stats, sorted by cumulative time and number of calls. -p --progress Show running progress. It can be combined with -v or -vv. -r --refcount Look for refcount problems. This requires that Python was built --with-pydebug. -t --top-fifty Time the individual tests and print a list of the top 50, sorted from longest to shortest. --times n --times outfile With an integer argument, time the tests and print a list of the top tests, sorted from longest to shortest. With a non-integer argument, specifies a file to which timing information is to be printed. -T --trace Use the trace module from Python for code coverage. The current utility writes coverage files to a directory named `coverage' that is parallel to `build'. It also prints a summary to stdout. -u --skip-functional CHANGED. Run unit tests but not functional tests. Note that the meaning of -u is changed from its former meaning, which is now specified by -U or --gui. -U --gui Use the PyUnit GUI instead of output to the command line. The GUI imports tests on its own, taking care to reload all dependencies on each run. The debug (-d), verbose (-v), progress (-p), and Loop (-L) options will be ignored. The testfilter filter is also not applied. -m -M --minimal-gui Note: -m is DEPRECATED in favour of -M or --minimal-gui. -m starts the gui minimized. Double-clicking the progress bar will start the import and run all tests. -v --verbose Verbose output. With one -v, unittest prints a dot (".") for each test run. With -vv, unittest prints the name of each test (for some definition of "name" ...). With no -v, unittest is silent until the end of the run, except when errors occur. When -p is also specified, the meaning of -v is slightly different. With -p and no -v only the percent indicator is displayed. With -p and -v the test name of the current test is shown to the right of the percent indicator. With -p and -vv the test name is not truncated to fit into 80 columns and it is not cleared after the test finishes. modfilter testfilter Case-sensitive regexps to limit which tests are run, used in search (not match) mode. In an extension of Python regexp notation, a leading "!" is stripped and causes the sense of the remaining regexp to be negated (so "!bc" matches any string that does not match "bc", and vice versa). By default these act like ".", i.e. nothing is excluded. modfilter is applied to a test file's path, starting at "build" and including (OS-dependent) path separators. testfilter is applied to the (method) name of the unittest methods contained in the test files whose paths modfilter matched. Extreme (yet useful) examples: test.py -vvb . "^testWriteClient$" Builds the project silently, then runs unittest in verbose mode on all tests whose names are precisely "testWriteClient". Useful when debugging a specific test. test.py -vvb . "!^testWriteClient$" As before, but runs all tests whose names aren't precisely "testWriteClient". Useful to avoid a specific failing test you don't want to deal with just yet. test.py -M . "!^testWriteClient$" As before, but now opens up a minimized PyUnit GUI window (only showing the progress bar). Useful for refactoring runs where you continually want to make sure all tests still pass. """ import gc import hotshot, hotshot.stats import os import re import pdb import sys import threading # just to get at Thread objects created by tests import time import traceback import unittest import warnings def set_trace_doctest(stdin=sys.stdin, stdout=sys.stdout, trace=pdb.set_trace): sys.stdin = stdin sys.stdout = stdout trace() pdb.set_trace_doctest = set_trace_doctest from distutils.util import get_platform PLAT_SPEC = "%s-%s" % (get_platform(), sys.version[0:3]) class ImmediateTestResult(unittest._TextTestResult): __super_init = unittest._TextTestResult.__init__ __super_startTest = unittest._TextTestResult.startTest __super_printErrors = unittest._TextTestResult.printErrors def __init__(self, stream, descriptions, verbosity, debug=False, count=None, progress=False): self.__super_init(stream, descriptions, verbosity) self._debug = debug self._progress = progress self._progressWithNames = False self.count = count self._testtimes = {} if progress and verbosity == 1: self.dots = False self._progressWithNames = True self._lastWidth = 0 self._maxWidth = 80 try: import curses except ImportError: pass else: curses.setupterm() self._maxWidth = curses.tigetnum('cols') self._maxWidth -= len("xxxx/xxxx (xxx.x%): ") + 1 def stopTest(self, test): self._testtimes[test] = time.time() - self._testtimes[test] if gc.garbage: print "The following test left garbage:" print test print gc.garbage # XXX Perhaps eat the garbage here, so that the garbage isn't # printed for every subsequent test. # Did the test leave any new threads behind? new_threads = [t for t in threading.enumerate() if (t.isAlive() and t not in self._threads)] if new_threads: print "The following test left new threads behind:" print test print "New thread(s):", new_threads def print_times(self, stream, count=None): results = self._testtimes.items() results.sort(lambda x, y: cmp(y[1], x[1])) if count: n = min(count, len(results)) if n: print >>stream, "Top %d longest tests:" % n else: n = len(results) if not n: return for i in range(n): print >>stream, "%6dms" % int(results[i][1] * 1000), results[i][0] def _print_traceback(self, msg, err, test, errlist): if self.showAll or self.dots or self._progress: self.stream.writeln("\n") self._lastWidth = 0 tb = "".join(traceback.format_exception(*err)) self.stream.writeln(msg) self.stream.writeln(tb) errlist.append((test, tb)) def startTest(self, test): if self._progress: self.stream.write("\r%4d" % (self.testsRun + 1)) if self.count: self.stream.write("/%d (%5.1f%%)" % (self.count, (self.testsRun + 1) * 100.0 / self.count)) if self.showAll: self.stream.write(": ") elif self._progressWithNames: # XXX will break with multibyte strings name = self.getShortDescription(test) width = len(name) if width < self._lastWidth: name += " " * (self._lastWidth - width) self.stream.write(": %s" % name) self._lastWidth = width self.stream.flush() self._threads = threading.enumerate() self.__super_startTest(test) self._testtimes[test] = time.time() def getShortDescription(self, test): s = self.getDescription(test) if len(s) > self._maxWidth: pos = s.find(" (") if pos >= 0: w = self._maxWidth - (pos + 5) if w < 1: # first portion (test method name) is too long s = s[:self._maxWidth-3] + "..." else: pre = s[:pos+2] post = s[-w:] s = "%s...%s" % (pre, post) return s[:self._maxWidth] def addError(self, test, err): if self._progress: self.stream.write("\r") if self._debug: raise err[0], err[1], err[2] self._print_traceback("Error in test %s" % test, err, test, self.errors) def addFailure(self, test, err): if self._progress: self.stream.write("\r") if self._debug: raise err[0], err[1], err[2] self._print_traceback("Failure in test %s" % test, err, test, self.failures) def printErrors(self): if self._progress and not (self.dots or self.showAll): self.stream.writeln() self.__super_printErrors() def printErrorList(self, flavor, errors): for test, err in errors: self.stream.writeln(self.separator1) self.stream.writeln("%s: %s" % (flavor, self.getDescription(test))) self.stream.writeln(self.separator2) self.stream.writeln(err) class ImmediateTestRunner(unittest.TextTestRunner): __super_init = unittest.TextTestRunner.__init__ def __init__(self, **kwarg): debug = kwarg.get("debug") if debug is not None: del kwarg["debug"] progress = kwarg.get("progress") if progress is not None: del kwarg["progress"] profile = kwarg.get("profile") if profile is not None: del kwarg["profile"] self.__super_init(**kwarg) self._debug = debug self._progress = progress self._profile = profile # Create the test result here, so that we can add errors if # the test suite search process has problems. The count # attribute must be set in run(), because we won't know the # count until all test suites have been found. self.result = ImmediateTestResult( self.stream, self.descriptions, self.verbosity, debug=self._debug, progress=self._progress) def _makeResult(self): # Needed base class run method. return self.result def run(self, test): self.result.count = test.countTestCases() if self._debug: club_debug(test) if self._profile: prof = hotshot.Profile("tests_profile.prof") args = (self, test) r = prof.runcall(unittest.TextTestRunner.run, *args) prof.close() stats = hotshot.stats.load("tests_profile.prof") stats.sort_stats('cumulative', 'calls') stats.print_stats(50) return r return unittest.TextTestRunner.run(self, test) def club_debug(test): # Beat a debug flag into debug-aware test cases setDebugModeOn = getattr(test, 'setDebugModeOn', None) if setDebugModeOn is not None: setDebugModeOn() for subtest in getattr(test, '_tests', ()): club_debug(subtest) # setup list of directories to put on the path class PathInit: def __init__(self, build, build_inplace, libdir=None): self.inplace = None # Figure out if we should test in-place or test in-build. If the -b # or -B option was given, test in the place we were told to build in. # Otherwise, we'll look for a build directory and if we find one, # we'll test there, otherwise we'll test in-place. if build: self.inplace = build_inplace if self.inplace is None: # Need to figure it out if os.path.isdir(os.path.join("build", "lib.%s" % PLAT_SPEC)): self.inplace = False else: self.inplace = True # Calculate which directories we're going to add to sys.path, and cd # to the appropriate working directory self.org_cwd = os.getcwd() if self.inplace: self.libdir = "src" else: self.libdir = "lib.%s" % PLAT_SPEC os.chdir("build") # Hack sys.path self.cwd = os.getcwd() sys.path.insert(0, os.path.join(self.cwd, self.libdir)) # Hack again for external products. global functional kind = functional and "FUNCTIONAL" or "UNIT" if libdir: extra = os.path.join(self.org_cwd, libdir) print "Running %s tests from %s" % (kind, extra) self.libdir = extra sys.path.insert(0, extra) else: print "Running %s tests from %s" % (kind, self.cwd) # Make sure functional tests find ftesting.zcml if functional: config_file = 'ftesting.zcml' if not self.inplace: # We chdired into build, so ftesting.zcml is in the # parent directory config_file = os.path.join('..', 'ftesting.zcml') print "Parsing %s" % config_file from zope.app.tests.functional import FunctionalTestSetup FunctionalTestSetup(config_file) def match(rx, s): if not rx: return True if rx[0] == "!": return re.search(rx[1:], s) is None else: return re.search(rx, s) is not None class TestFileFinder: def __init__(self, prefix): self.files = [] self._plen = len(prefix) if not prefix.endswith(os.sep): self._plen += 1 global functional if functional: self.dirname = "ftests" else: self.dirname = "tests" def visit(self, rx, dir, files): if os.path.split(dir)[1] != self.dirname: # Allow tests/ftests module rather than package. modfname = self.dirname + '.py' if modfname in files: path = os.path.join(dir, modfname) if match(rx, path): self.files.append(path) return return # ignore tests that aren't in packages if not "__init__.py" in files: if not files or files == ["CVS"]: return print "not a package", dir return # Put matching files in matches. If matches is non-empty, # then make sure that the package is importable. matches = [] for file in files: if file.startswith('test') and os.path.splitext(file)[-1] == '.py': path = os.path.join(dir, file) if match(rx, path): matches.append(path) # ignore tests when the package can't be imported, possibly due to # dependency failures. pkg = dir[self._plen:].replace(os.sep, '.') try: __import__(pkg) # We specifically do not want to catch ImportError since that's useful # information to know when running the tests. except RuntimeError, e: if VERBOSE: print "skipping %s because: %s" % (pkg, e) return else: self.files.extend(matches) def module_from_path(self, path): """Return the Python package name indicated by the filesystem path.""" assert path.endswith(".py") path = path[self._plen:-3] mod = path.replace(os.sep, ".") return mod def walk_with_symlinks(top, func, arg): """Like os.path.walk, but follows symlinks on POSIX systems. This could theoreticaly result in an infinite loop, if you create symlink cycles in your Zope sandbox, so don't do that. """ try: names = os.listdir(top) except os.error: return func(arg, top, names) exceptions = ('.', '..') for name in names: if name not in exceptions: name = os.path.join(top, name) if os.path.isdir(name): walk_with_symlinks(name, func, arg) def find_test_dir(dir): if os.path.exists(dir): return dir d = os.path.join(pathinit.libdir, dir) if os.path.exists(d): if os.path.isdir(d): return d raise ValueError("%s does not exist and %s is not a directory" % (dir, d)) raise ValueError("%s does not exist!" % dir) def find_tests(rx): global finder finder = TestFileFinder(pathinit.libdir) if TEST_DIRS: for d in TEST_DIRS: d = find_test_dir(d) walk_with_symlinks(d, finder.visit, rx) else: walk_with_symlinks(pathinit.libdir, finder.visit, rx) return finder.files def package_import(modname): mod = __import__(modname) for part in modname.split(".")[1:]: mod = getattr(mod, part) return mod class PseudoTestCase: """Minimal test case objects to create error reports. If test.py finds something that looks like it should be a test but can't load it or find its test suite, it will report an error using a PseudoTestCase. """ def __init__(self, name, descr=None): self.name = name self.descr = descr def shortDescription(self): return self.descr def __str__(self): return "Invalid Test (%s)" % self.name def get_suite(file, result): modname = finder.module_from_path(file) try: mod = package_import(modname) return mod.test_suite() except: result.addError(PseudoTestCase(modname), sys.exc_info()) return None def filter_testcases(s, rx): new = unittest.TestSuite() for test in s._tests: # See if the levels match dolevel = (LEVEL == 0) or LEVEL >= getattr(test, "level", 0) if not dolevel: continue if isinstance(test, unittest.TestCase): name = test.id() # Full test name: package.module.class.method name = name[1 + name.rfind("."):] # extract method name if not rx or match(rx, name): new.addTest(test) else: filtered = filter_testcases(test, rx) if filtered: new.addTest(filtered) return new def gui_runner(files, test_filter): if BUILD_INPLACE: utildir = os.path.join(os.getcwd(), "utilities") else: utildir = os.path.join(os.getcwd(), "..", "utilities") sys.path.append(utildir) import unittestgui suites = [] for file in files: suites.append(finder.module_from_path(file) + ".test_suite") suites = ", ".join(suites) minimal = (GUI == "minimal") unittestgui.main(suites, minimal) class TrackRefs: """Object to track reference counts across test runs.""" def __init__(self): self.type2count = {} self.type2all = {} def update(self): obs = sys.getobjects(0) type2count = {} type2all = {} for o in obs: all = sys.getrefcount(o) if type(o) is str and o == '': # avoid dictionary madness continue t = type(o) if t in type2count: type2count[t] += 1 type2all[t] += all else: type2count[t] = 1 type2all[t] = all ct = [(type2count[t] - self.type2count.get(t, 0), type2all[t] - self.type2all.get(t, 0), t) for t in type2count.iterkeys()] 
/*
 *  yosys -- Yosys Open SYnthesis Suite
 *
 *  Copyright (C) 2012  Clifford Wolf <clifford@clifford.at>
 *
 *  Permission to use, copy, modify, and/or distribute this software for any
 *  purpose with or without fee is hereby granted, provided that the above
 *  copyright notice and this permission notice appear in all copies.
 *
 *  THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 *  WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 *  MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 *  ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 *  WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 *  ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 *  OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 */

#include "blifparse.h"

YOSYS_NAMESPACE_BEGIN

static bool read_next_line(char *&buffer, size_t &buffer_size, int &line_count, std::istream &f)
{
	string strbuf;
	int buffer_len = 0;
	buffer[0] = 0;

	while (1)
	{
		buffer_len += strlen(buffer + buffer_len);
		while (buffer_len > 0 && (buffer[buffer_len-1] == ' ' || buffer[buffer_len-1] == '\t' ||
				buffer[buffer_len-1] == '\r' || buffer[buffer_len-1] == '\n'))
			buffer[--buffer_len] = 0;

		if (buffer_size-buffer_len < 4096) {
			buffer_size *= 2;
			buffer = (char*)realloc(buffer, buffer_size);
		}

		if (buffer_len == 0 || buffer[buffer_len-1] == '\\') {
			if (buffer_len > 0 && buffer[buffer_len-1] == '\\')
				buffer[--buffer_len] = 0;
			line_count++;
			if (!std::getline(f, strbuf))
				return false;
			while (buffer_size-buffer_len < strbuf.size()+1) {
				buffer_size *= 2;
				buffer = (char*)realloc(buffer, buffer_size);
			}
			strcpy(buffer+buffer_len, strbuf.c_str());
		} else
			return true;
	}
}

static std::pair<RTLIL::IdString, int> wideports_split(std::string name)
{
	int pos = -1;

	if (name.empty() || name.back() != ']')
		goto failed;

	for (int i = 0; i+1 < GetSize(name); i++) {
		if (name[i] == '[')
			pos = i;
		else if (name[i] < '0' || name[i] > '9')
			pos = -1;
		else if (i == pos+1 && name[i] == '0' && name[i+1] != ']')
			pos = -1;
	}

	if (pos >= 0)
		return std::pair<RTLIL::IdString, int>("\\" + name.substr(0, pos), atoi(name.c_str() + pos+1)+1);

failed:
	return std::pair<RTLIL::IdString, int>("\\" + name, 0);
}

void parse_blif(RTLIL::Design *design, std::istream &f, IdString dff_name, bool run_clean, bool sop_mode, bool wideports)
{
	RTLIL::Module *module = nullptr;
	RTLIL::Const *lutptr = NULL;
	RTLIL::Cell *sopcell = NULL;
	RTLIL::Cell *lastcell = nullptr;
	RTLIL::State lut_default_state = RTLIL::State::Sx;
	std::string err_reason;
	int blif_maxnum = 0, sopmode = -1;

	auto blif_wire = [&](const std::string &wire_name) -> Wire*
	{
		if (wire_name[0] == '$')
		{
			for (int i = 0; i+1 < GetSize(wire_name); i++)
			{
				if (wire_name[i] != '$')
					continue;

				int len = 0;
				while (i+len+1 < GetSize(wire_name) && '0' <= wire_name[i+len+1] && wire_name[i+len+1] <= '9')
					len++;

				if (len > 0) {
					string num_str = wire_name.substr(i+1, len);
					int num = atoi(num_str.c_str()) & 0x0fffffff;
					blif_maxnum = std::max(blif_maxnum, num);
				}
			}
		}

		IdString wire_id = RTLIL::escape_id(wire_name);
		Wire *wire = module->wire(wire_id);

		if (wire == nullptr)
			wire = module->addWire(wire_id);

		return wire;
	};

	dict<RTLIL::IdString, RTLIL::Const> *obj_attributes = nullptr;
	dict<RTLIL::IdString, RTLIL::Const> *obj_parameters = nullptr;

	dict<RTLIL::IdString, std::pair<int, bool>> wideports_cache;

	size_t buffer_size = 4096;
	char *buffer = (char*)malloc(buffer_size);
	int line_count = 0;

	while (1)
	{
		if (!read_next_line(buffer, buffer_size, line_count, f)) {
			if (module != nullptr)
				goto error;
			free(buffer);
			return;
		}

	continue_without_read:
		if (buffer[0] == '#')
			continue;

		if (buffer[0] == '.')
		{
			if (lutptr) {
				for (auto &bit : lutptr->bits)
					if (bit == RTLIL::State::Sx)
						bit = lut_default_state;
				lutptr = NULL;
				lut_default_state = RTLIL::State::Sx;
			}

			if (sopcell) {
				sopcell = NULL;
				sopmode = -1;
			}

			char *cmd = strtok(buffer, " \t\r\n");

			if (!strcmp(cmd, ".model")) {
				if (module != nullptr)
					goto error;
				module = new RTLIL::Module;
				lastcell = nullptr;
				module->name = RTLIL::escape_id(strtok(NULL, " \t\r\n"));
				obj_attributes = &module->attributes;
				obj_parameters = nullptr;
				if (design->module(module->name))
					log_error("Duplicate definition of module %s in line %d!\n", log_id(module->name), line_count);
				design->add(module);
				continue;
			}

			if (module == nullptr)
				goto error;

			if (!strcmp(cmd, ".blackbox"))
			{
				module->attributes[ID::blackbox] = RTLIL::Const(1);
				continue;
			}

			if (!strcmp(cmd, ".end"))
			{
				for (auto &wp : wideports_cache)
				{
					auto name = wp.first;
					int width = wp.second.first;
					bool isinput = wp.second.second;

					RTLIL::Wire *wire = module->addWire(name, width);
					wire->port_input = isinput;
					wire->port_output = !isinput;

					for (int i = 0; i < width; i++) {
						RTLIL::IdString other_name = name.str() + stringf("[%d]", i);
						RTLIL::Wire *other_wire = module->wire(other_name);
						if (other_wire) {
							other_wire->port_input = false;
							other_wire->port_output = false;
							if (isinput)
								module->connect(other_wire, SigSpec(wire, i));
							else
								module->connect(SigSpec(wire, i), other_wire);
						}
					}
				}

				module->fixup_ports();
				wideports_cache.clear();

				if (run_clean)
				{
					Const buffer_lut(vector<RTLIL::State>({State::S0, State::S1}));
					vector<Cell*> remove_cells;

					for (auto cell : module->cells())
						if (cell->type == ID($lut) && cell->getParam(ID::LUT) == buffer_lut) {
							module->connect(cell->getPort(ID::Y), cell->getPort(ID::A));
							remove_cells.push_back(cell);
						}

					for (auto cell : remove_cells)
						module->remove(cell);

					Wire *true_wire = module->wire(ID($true));
					Wire *false_wire = module->wire(ID($false));
					Wire *undef_wire = module->wire(ID($undef));

					if (true_wire != nullptr)
						module->rename(true_wire, stringf("$true$%d", ++blif_maxnum));

					if (false_wire != nullptr)
						module->rename(false_wire, stringf("$false$%d", ++blif_maxnum));

					if (undef_wire != nullptr)
						module->rename(undef_wire, stringf("$undef$%d", ++blif_maxnum));

					autoidx = std::max(autoidx, blif_maxnum+1);
					blif_maxnum = 0;
				}

				module = nullptr;
				lastcell = nullptr;
				obj_attributes = nullptr;
				obj_parameters = nullptr;
				continue;
			}

			if (!strcmp(cmd, ".inputs") || !strcmp(cmd, ".outputs"))
			{
				char *p;
				while ((p = strtok(NULL, " \t\r\n")) != NULL)
				{
					RTLIL::IdString wire_name(stringf("\\%s", p));
					RTLIL::Wire *wire = module->wire(wire_name);
					if (wire == nullptr)
						wire = module->addWire(wire_name);
					if (!strcmp(cmd, ".inputs"))
						wire->port_input = true;
					else
						wire->port_output = true;

					if (wideports) {
						std::pair<RTLIL::IdString, int> wp = wideports_split(p);
						if (wp.second > 0) {
							wideports_cache[wp.first].first = std::max(wideports_cache[wp.first].first, wp.second);
							wideports_cache[wp.first].second = !strcmp(cmd, ".inputs");
						}
					}
				}
				obj_attributes = nullptr;
				obj_parameters = nullptr;
				continue;
			}

			if (!strcmp(cmd, ".cname"))
			{
				char *p = strtok(NULL, " \t\r\n");
				if (p == NULL)
					goto error;

				if(lastcell == nullptr || module == nullptr)
				{
					err_reason = stringf("No primitive object to attach .cname %s.", p);
					goto error_with_reason;
				}

				module->rename(lastcell, RTLIL::escape_id(p));
				continue;
			}

			if (!strcmp(cmd, ".attr") || !strcmp(cmd, ".param")) {
				char *n = strtok(NULL, " \t\r\n");
				char *v = strtok(NULL, "\r\n");
				IdString id_n = RTLIL::escape_id(n);
				Const const_v;
				if (v[0] == '"') {
					std::string str(v+1);
					if (str.back() == '"')
						str.resize(str.size()-1);
					const_v = Const(str);
				} else {
					int n = strlen(v);
					const_v.bits.resize(n);
					for (int i = 0; i < n; i++)
						const_v.bits[i] = v[n-i-1] != '0' ? State::S1 : State::S0;
				}
				if (!strcmp(cmd, ".attr")) {
					if (obj_attributes == nullptr) {
						err_reason = stringf("No object to attach .attr too.");
						goto error_with_reason;
					}
					(*obj_attributes)[id_n] = const_v;
				} else {
					if (obj_parameters == nullptr) {
						err_reason = stringf("No object to attach .param too.");
						goto error_with_reason;
					}
					(*obj_parameters)[id_n] = const_v;
				}
				continue;
			}

			if (!strcmp(cmd, ".latch"))
			{
				char *d = strtok(NULL, " \t\r\n");
				char *q = strtok(NULL, " \t\r\n");
				char *edge = strtok(NULL, " \t\r\n");
				char *clock = strtok(NULL, " \t\r\n");
				char *init = strtok(NULL, " \t\r\n");
				RTLIL::Cell *cell = nullptr;

				if (clock == nullptr && edge != nullptr) {
					init = edge;
					edge = nullptr;
				}

				if (init != nullptr && (init[0] == '0' || init[0] == '1'))
					blif_wire(q)->attributes[ID::init] = Const(init[0] == '1' ? 1 : 0, 1);

				if (clock == nullptr)
					goto no_latch_clock;

				if (!strcmp(edge, "re"))
					cell = module->addDff(NEW_ID, blif_wire(clock), blif_wire(d), blif_wire(q));
				else if (!strcmp(edge, "fe"))
					cell = module->addDff(NEW_ID, blif_wire(clock), blif_wire(d), blif_wire(q), false);
				else if (!strcmp(edge, "ah"))
					cell = module->addDlatch(NEW_ID, blif_wire(clock), blif_wire(d), blif_wire(q));
				else if (!strcmp(edge, "al"))
					cell = module->addDlatch(NEW_ID, blif_wire(clock), blif_wire(d), blif_wire(q), false);
				else {
			no_latch_clock:
					if (dff_name.empty()) {
						cell = module->addFf(NEW_ID, blif_wire(d), blif_wire(q));
					} else {
						cell = module->addCell(NEW_ID, dff_name);
						cell->setPort(ID::D, blif_wire(d));
						cell->setPort(ID::Q, blif_wire(q));
					}
				}

				lastcell = cell;
				obj_attributes = &cell->attributes;
				obj_parameters = &cell->parameters;
				continue;
			}

			if (!strcmp(cmd, ".gate") || !strcmp(cmd, ".subckt"))
			{
				char *p = strtok(NULL, " \t\r\n");
				if (p == NULL)
					goto error;

				IdString celltype = RTLIL::escape_id(p);
				RTLIL::Cell *cell = module->addCell(NEW_ID, celltype);

				dict<RTLIL::IdString, dict<int, SigBit>> cell_wideports_cache;

				while ((p = strtok(NULL, " \t\r\n")) != NULL)
				{
					char *q = strchr(p, '=');
					if (q == NULL || !q[0])
						goto error;
					*(q++) = 0;

					if (wideports) {
						std::pair<RTLIL::IdString, int> wp = wideports_split(p);
						if (wp.second > 0)
							cell_wideports_cache[wp.first][wp.second-1] = blif_wire(q);
						else
							cell->setPort(RTLIL::escape_id(p), *q ? blif_wire(q) : SigSpec());
					} else {
						cell->setPort(RTLIL::escape_id(p), *q ? blif_wire(q) : SigSpec());
					}
				}

				for (auto &it : cell_wideports_cache)
				{
					int width = 0;
					for (auto &b : it.second)
						width = std::max(width, b.first + 1);

					SigSpec sig;

					for (int i = 0; i < width; i++) {
						if (it.second.count(i))
							sig.append(it.second.at(i));
						else
							sig.append(module->addWire(NEW_ID));
					}

					cell->setPort(it.first, sig);
				}

				lastcell = cell;
				obj_attributes = &cell->attributes;
				obj_parameters = &cell->parameters;
				continue;
			}

			obj_attributes = nullptr;
			obj_parameters = nullptr;

			if (!strcmp(cmd, ".barbuf") || !strcmp(cmd, ".conn"))
			{
				char *p = strtok(NULL, " \t\r\n");
				if (p == NULL)
					goto error;

				char *q = strtok(NULL, " \t\r\n");
				if (q == NULL)
					goto error;

				module->connect(blif_wire(q), blif_wire(p));
				continue;
			}

			if (!strcmp(cmd, ".names"))
			{
				char *p;
				RTLIL::SigSpec input_sig, output_sig;
				while ((p = strtok(NULL, " \t\r\n")) != NULL)
					input_sig.append(blif_wire(p));
				output_sig = input_sig.extract(input_sig.size()-1, 1);
				input_sig = input_sig.extract(0, input_sig.size()-1);

				if (input_sig.size() == 0)
				{
					RTLIL::State state = RTLIL::State::Sa;
					while (1) {
						if (!read_next_line(buffer, buffer_size, line_count, f))
							goto error;
						for (int i = 0; buffer[i]; i++) {
							if (buffer[i] == ' ' || buffer[i] == '\t')
								continue;
							if (i == 0 && buffer[i] == '.')
								goto finished_parsing_constval;
							if (buffer[i] == '0') {
								if (state == RTLIL::State::S1)
									goto error;
								state = RTLIL::State::S0;
								continue;
							}
							if (buffer[i] == '1') {
								if (state == RTLIL::State::S0)
									goto error;
								state = RTLIL::State::S1;
								continue;
							}
							goto error;
						}
					}

				finished_parsing_constval:
					if (state == RTLIL::State::Sa)
						state = RTLIL::State::S0;
					if (output_sig.as_wire()->name == ID($undef))
						state = RTLIL::State::Sx;
					module->connect(RTLIL::SigSig(output_sig, state));
					goto continue_without_read;
				}

				if (sop_mode)
				{
					sopcell = module->addCell(NEW_ID, ID($sop));
					sopcell->parameters[ID::WIDTH] = RTLIL::Const(input_sig.size());
					sopcell->parameters[ID::DEPTH] = 0;
					sopcell->parameters[ID::TABLE] = RTLIL::Const();
					sopcell->setPort(ID::A, input_sig);
					sopcell->setPort(ID::Y, output_sig);
					sopmode = -1;
					lastcell = sopcell;
				}
				else
				{
					RTLIL::Cell *cell = module->addCell(NEW_ID, ID($lut));
					cell->parameters[ID::WIDTH] = RTLIL::Const(input_sig.size());
					cell->parameters[ID::LUT] = RTLIL::Const(RTLIL::State::Sx, 1 << input_sig.size());
					cell->setPort(ID::A, input_sig);
					cell->setPort(ID::Y, output_sig);
					lutptr = &cell->parameters.at(ID::LUT);
					lut_default_state = RTLIL::State::Sx;
					lastcell = cell;
				}
				continue;
			}

			goto error;
		}

		if (lutptr == NULL && sopcell == NULL)
			goto error;

		char *input = strtok(buffer, " \t\r\n");
		char *output = strtok(NULL, " \t\r\n");

		if (input == NULL || output == NULL || (strcmp(output, "0") && strcmp(output, "1")))
			goto error;

		int input_len = strlen(input);

		if (sopcell)
		{
			log_assert(sopcell->parameters[ID::WIDTH].as_int() == input_len);
			sopcell->parameters[ID::DEPTH] = sopcell->parameters[ID::DEPTH].as_int() + 1;

			for (int i = 0; i < input_len; i++)
				switch (input[i]) {
					case '0':
						sopcell->parameters[ID::TABLE].bits.push_back(State::S1);
						sopcell->parameters[ID::TABLE].bits.push_back(State::S0);
						break;
					case '1':
						sopcell->parameters[ID::TABLE].bits.push_back(State::S0);
						sopcell->parameters[ID::TABLE].bits.push_back(State::S1);
						break;
					default:
						sopcell->parameters[ID::TABLE].bits.push_back(State::S0);
						sopcell->parameters[ID::TABLE].bits.push_back(State::S0);
						break;
				}

			if (sopmode == -1) {
				sopmode = (*output == '1');
				if (!sopmode) {
					SigSpec outnet = sopcell->getPort(ID::Y);
					SigSpec tempnet = module->addWire(NEW_ID);
					module->addNotGate(NEW_ID, tempnet, outnet);
					sopcell->setPort(ID::Y, tempnet);
				}
			} else
				log_assert(sopmode == (*output == '1'));
		}

		if (lutptr)
		{
			if (input_len > 12)
				goto error;

			for (int i = 0; i < (1 << input_len); i++) {
				for (int j = 0; j < input_len; j++) {
					char c1 = input[j];
					if (c1 != '-') {
						char c2 = (i & (1 << j)) != 0 ? '1' : '0';
						if (c1 != c2)
							goto try_next_value;
					}
				}
				lutptr->bits.at(i) = !strcmp(output, "0") ? RTLIL::State::S0 : RTLIL::State::S1;
			try_next_value:;
			}

			lut_default_state = !strcmp(output, "0") ? RTLIL::State::S1 : RTLIL::State::S0;
		}
	}

	return;

error:
	log_error("Syntax error in line %d!\n", line_count);
error_with_reason:
	log_error("Syntax error in line %d: %s\n", line_count, err_reason.c_str());
}

struct BlifFrontend : public Frontend {
	BlifFrontend() : Frontend("blif", "read BLIF file") { }
	void help() override
	{
		//   |---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|---v---|
		log("\n");
		log("    read_blif [options] [filename]\n");
		log("\n");
		log("Load modules from a BLIF file into the current design.\n");
		log("\n");
		log("    -sop\n");
		log("        Create $sop cells instead of $lut cells\n");
		log("\n");
		log("    -wideports\n");
		log("        Merge ports that match the pattern 'name[int]' into a single\n");
		log("        multi-bit port 'name'.\n");
		log("\n");
	}
	void execute(std::istream *&f, std::string filename, std::vector<std::string> args, RTLIL::Design *design) override
	{
		bool sop_mode = false;
		bool wideports = false;

		log_header(design, "Executing BLIF frontend.\n");

		size_t argidx;
		for (argidx = 1; argidx < args.size(); argidx++) {
			std::string arg = args[argidx];
			if (arg == "-sop") {
				sop_mode = true;
				continue;
			}
			if (arg == "-wideports") {
				wideports = true;
				continue;
			}
			break;
		}
		extra_args(f, filename, args, argidx);

		parse_blif(design, *f, "", true, sop_mode, wideports);
	}
} BlifFrontend;

YOSYS_NAMESPACE_END
generated by cgit v1.2.3 (git 2.25.1) at 2025-08-19 18:28:37 +0000