najaeda 0.1.2__cp311-cp311-macosx_11_0_arm64.whl → 0.1.4__cp311-cp311-macosx_11_0_arm64.whl

najaeda/netlist.py

@@ -4,6 +4,9 @@
 # SPDX-License-Identifier: Apache-2.0
 
 import itertools
+import time
+import logging
+
 from najaeda import snl
 
 
@@ -46,102 +49,121 @@ class Equipotential:
 
 
 class Net:
-    def __init__(self, path, net):
+    def __init__(self, path, net=None, net_concat=None):
+        if net is not None and net_concat is not None:
+            raise ValueError(
+                "Only one of `net` or `net_concat` should be provided, not both."
+            )
         self.path = path
-        self.net = net
-
-    def __eq__(self, value):
-        return self.net == value.net and self.path == value.path
-
-    def __ne__(self, value):
-        return not self == value
-
-    def __lt__(self, value):
-        if self.path != value.path:
-            return self.path < value.path
-        return self.net < value.net
-
-    def __le__(self, value):
-        if self.path != value.path:
-            return self.path < value.path
-        return self.net <= value.net
+        if net is not None:
+            self.net = net
+        elif net_concat is not None:
+            self.net_concat = net_concat
 
-    def __gt__(self, value):
-        if self.path != value.path:
-            return self.path > value.path
-        return self.net > value.net
+    def __eq__(self, other):
+        if not isinstance(other, Net):
+            return NotImplemented
+        return vars(self) == vars(other)
 
-    def __ge__(self, value):
-        if self.path != value.path:
-            return self.path > value.path
-        return self.net >= value.net
+    def __ne__(self, other):
+        eq_result = self.__eq__(other)
+        if eq_result is NotImplemented:
+            return NotImplemented
+        return not eq_result
 
     def __str__(self):
+        if hasattr(self, "net"):
+            net_str = str(self.net)
+        elif hasattr(self, "net_concat"):
+            net_str = "{" + ",".join(map(str, self.net_concat)) + "}"
         if self.path.size() > 0:
-            return f"{self.path}/{self.net}"
-        return f"{self.net}"
-
-    def __repr__(self):
-        return f"Net({self.path}, {self.net})"
+            return f"{self.path}/{net_str}"
+        return net_str
 
     def get_name(self) -> str:
         """Return the name of the net."""
-        return self.net.getName()
+        if hasattr(self, "net"):
+            return self.net.getName()
+        return "{" + ",".join(map(str, self.net_concat)) + "}"
 
     def get_msb(self) -> int:
         """Return the most significant bit of the net if it is a bus."""
-        if isinstance(self.net, snl.SNLBusNet):
+        if hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet):
             return self.net.getMSB()
         return None
 
     def get_lsb(self) -> int:
         """Return the least significant bit of the net if it is a bus."""
-        if isinstance(self.net, snl.SNLBusNet):
+        if hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet):
             return self.net.getLSB()
         return None
 
     def is_bus(self) -> bool:
         """Return True if the net is a bus."""
-        return isinstance(self.net, snl.SNLBusNet)
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLBusNet)
 
     def is_bus_bit(self) -> bool:
         """Return True if the net is a bit of a bus."""
-        return isinstance(self.net, snl.SNLBusNetBit)
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLBusNetBit)
 
     def is_scalar(self) -> bool:
         """Return True if the net is a scalar."""
-        return isinstance(self.net, snl.SNLScalarNet)
+        return hasattr(self, "net") and isinstance(self.net, snl.SNLScalarNet)
 
     def is_bit(self) -> bool:
         """Return True if the net is a bit."""
         return self.is_scalar() or self.is_bus_bit()
 
-    def is_constant(self) -> bool:
+    def is_concat(self) -> bool:
+        """Return True if the net is a concatenation."""
+        return hasattr(self, "net_concat")
+
+    def is_const(self) -> bool:
         """Return True if the net is a constant generator."""
-        return self.net.isConstant()
+        if hasattr(self, "net"):
+            return self.net.isConstant()
+        for net in self.net_concat:
+            if not net.isConstant():
+                return False
+        return True
 
     def get_width(self) -> int:
         """Return the width of the net."""
-        return self.net.getWidth()
+        if hasattr(self, "net"):
+            return self.net.getWidth()
+        return sum(1 for _ in self.net_concat)
 
     def get_bits(self):
-        if isinstance(self.net, snl.SNLBusNet):
-            for bit in self.net.getBits():
-                yield Net(self.path, bit)
+        if hasattr(self, "net"):
+            if isinstance(self.net, snl.SNLBusNet):
+                for bit in self.net.getBits():
+                    yield Net(self.path, bit)
+            else:
+                yield self
         else:
-            yield self
+            for net in self.net_concat:
+                yield net
 
     def get_bit(self, index: int):
-        if isinstance(self.net, snl.SNLBusNet):
-            return Net(self.path, self.net.getBit(index))
+        if hasattr(self, "net"):
+            if isinstance(self.net, snl.SNLBusNet):
+                return Net(self.path, self.net.getBit(index))
+            else:
+                return None
+        if 0 <= index < len(self.net_concat):
+            return Net(self.path, self.net_concat[index])
         return None
 
     def get_inst_terms(self):
+        if hasattr(self, "net_concat"):
+            raise ValueError("Cannot get inst terms from a net_concat")
         for term in self.net.getInstTerms():
             path = snl.SNLPath(self.path, term.getInstance())
             yield Term(path, term.getBitTerm())
 
     def get_terms(self):
+        if hasattr(self, "net_concat"):
+            raise ValueError("Cannot get terms from a net_concat")
         for term in self.net.getBitTerms():
             yield Term(self.path, term)
 
@@ -151,9 +173,9 @@ class Net:
 
 
 class Term:
-    Input = snl.SNLTerm.Direction.Input
-    Output = snl.SNLTerm.Direction.Output
-    InOut = snl.SNLTerm.Direction.InOut
+    INPUT = snl.SNLTerm.Direction.Input
+    OUTPUT = snl.SNLTerm.Direction.Output
+    INOUT = snl.SNLTerm.Direction.InOut
 
     def __init__(self, path, term):
         self.path = path
@@ -179,15 +201,19 @@ class Term:
     def __ge__(self, other) -> bool:
         return not self < other
 
-    def __str__(self) -> str:
-        return str(self.path) + "." + self.term.getName()
+    def __str__(self):
+        if self.path.size() == 0:
+            return self.term.getName()
+        else:
+            return f"{self.path}/{self.term}"
 
     def __repr__(self) -> str:
         return f"Term({self.path}, {self.term})"
 
     def __make_unique(self):
-        if self.path.size() > 0:
-            snl.SNLUniquifier(self.path)
+        if self.path.size() > 1:
+            path = self.path.getHeadPath()
+            snl.SNLUniquifier(path)
             if self.is_bus_bit():
                 term = (
                     self.path.getTailInstance().getModel().getTerm(self.term.getName())
@@ -237,24 +263,74 @@ class Term:
     def get_direction(self) -> snl.SNLTerm.Direction:
         """Return the direction of the term."""
         if self.term.getDirection() == snl.SNLTerm.Direction.Input:
-            return Term.Input
+            return Term.INPUT
         elif self.term.getDirection() == snl.SNLTerm.Direction.Output:
-            return Term.Output
+            return Term.OUTPUT
         elif self.term.getDirection() == snl.SNLTerm.Direction.InOut:
-            return Term.InOut
+            return Term.INOUT
 
-    def get_net(self) -> Net:
-        if isinstance(self.term, snl.SNLBusTerm):
-            return None  # FIXME xtof in the future
-        net = None
+    def __get_snl_bitnet(self, bit) -> Net:
+        # single bit
         if self.path.size() > 0:
-            instTerm = self.path.getTailInstance().getInstTerm(self.term)
-            net = instTerm.getNet()
+            instTerm = self.path.getTailInstance().getInstTerm(bit)
+            return instTerm.getNet()
+        else:
+            return bit.getNet()
+
+    def __get_snl_lower_bitnet(self, bit) -> Net:
+        return bit.getNet()
+
+    def __get_snl_busnet(self, snl_nets) -> snl.SNLBusNet:
+        # iterate on all elements of the list and check if
+        # a full SNLBusNet can be reconstructed
+        snl_bus_net = None
+        for i in range(len(snl_nets)):
+            snl_net = snl_nets[i]
+            if not isinstance(snl_net, snl.SNLBusNetBit):
+                return None
+            bit_bus = snl_net.getBus()
+            if bit_bus.getWidth() != len(snl_nets):
+                return None
+            if snl_bus_net is None:
+                snl_bus_net = bit_bus
+            if snl_bus_net != bit_bus:
+                return None
+            if snl_bus_net.getBitAtPosition(i) != snl_net:
+                return None
+        return snl_bus_net
+
+    def __get_net(self, path, snl_term_net_accessor) -> Net:
+        if isinstance(self.term, snl.SNLBusTerm):
+            snl_nets = []
+            for bit in self.term.getBits():
+                snl_net = snl_term_net_accessor(bit)
+                snl_nets.append(snl_net)
+            snl_bus_net = self.__get_snl_busnet(snl_nets)
+            if snl_bus_net is not None:
+                return Net(path, snl_bus_net)
+            else:
+                if all(element is not None for element in snl_nets):
+                    return Net(path, net_concat=snl_nets)
         else:
-            net = get_top().model.getTerm(self.term.getName()).getNet()
-        return Net(self.path, net)
+            snl_net = snl_term_net_accessor(self.term)
+            if snl_net is not None:
+                return Net(path, snl_net)
+        return None
+
+    def get_lower_net(self) -> Net:
+        """Return the lower net of the term."""
+        return self.__get_net(self.path, self.__get_snl_lower_bitnet)
+
+    def get_net(self) -> Net:
+        """Return the net of the term."""
+        if self.path.empty():
+            return None
+        # path is one level up
+        path = self.path.getHeadPath()
+        return self.__get_net(path, self.__get_snl_bitnet)
 
     def get_instance(self):
+        """Return the instance of the term."""
         return Instance(self.path)
 
     def get_flat_fanout(self):
@@ -295,6 +371,7 @@ class Term:
             raise ValueError("Width mismatch")
         if self.get_instance().is_top():
             for bterm, bnet in zip(self.term.getBits(), net.net.getBits()):
+                logging.debug(f"Connecting {bterm} to {bnet}")
                 bterm.setNet(bnet)
         else:
             self.__make_unique()
@@ -348,8 +425,15 @@ class Instance:
     def __eq__(self, other) -> bool:
         return self.path == other.path
 
-    def __str__(self) -> str:
-        return str(self.path)
+    def __str__(self):
+        if self.is_top():
+            top = self.__get_snl_model()
+            if top is not None:
+                return top.getName()
+            else:
+                return ""
+        else:
+            return str(self.path)
 
     def __repr__(self) -> str:
         return f"Instance({self.path})"
@@ -396,8 +480,6 @@ class Instance:
 
     def __find_snl_model(self, name: str) -> snl.SNLDesign:
         u = snl.SNLUniverse.get()
-        if u is None:
-            return None
         for db in u.getUserDBs():
             for lib in db.getLibraries():
                 found_model = lib.getDesign(name)
@@ -419,15 +501,21 @@ class Instance:
     def get_number_of_child_instances(self) -> int:
         return sum(1 for _ in self.__get_snl_model().getInstances())
 
-    def get_terms(self):
-        for term in self.__get_snl_model().getTerms():
-            yield Term(self.path, term)
-
-    def get_term(self, name: str) -> Term:
-        term = self.__get_snl_model().getTerm(name)
-        if term is not None:
-            return Term(self.path, self.__get_snl_model().getTerm(name))
-        return None
+    # def get_flat_primitive_instances(self):
+    #    FIXME: concat first local path with the path of the instance
+    #    model = self.__get_snl_model()
+    #    for inst in model.getInstances():
+    #        path = snl.SNLPath(inst)
+    #        stack = [[inst, path]]
+    #        while stack:
+    #            current = stack.pop()
+    #            current_inst = current[0]
+    #            current_path = current[1]
+    #            for inst_child in current_inst.getModel().getInstances():
+    #                path_child = snl.SNLPath(current_path, inst_child)
+    #                if inst_child.getModel().isPrimitive():
+    #                    yield Instance(path_child)
+    #                stack.append([inst_child, path_child])
 
     def get_nets(self):
         for net in self.__get_snl_model().getNets():
@@ -448,8 +536,23 @@ class Instance:
         return None
 
     def is_primitive(self) -> bool:
+        """Return True if this is a primitive."""
         return self.__get_snl_model().isPrimitive()
 
+    def get_terms(self):
+        for term in self.__get_snl_model().getTerms():
+            yield Term(self.path, term)
+
+    def get_flat_terms(self):
+        for term in self.__get_snl_model().getBitTerms():
+            yield Term(self.path, term)
+
+    def get_term(self, name: str) -> Term:
+        term = self.__get_snl_model().getTerm(name)
+        if term is not None:
+            return Term(self.path, self.__get_snl_model().getTerm(name))
+        return None
+
     def get_input_terms(self):
         for term in self.__get_snl_model().getTerms():
             if term.getDirection() == snl.SNLTerm.Direction.Input:
@@ -531,9 +634,10 @@ class Instance:
     def create_input_term(self, name: str) -> Term:
         return self.create_term(name, snl.SNLTerm.Direction.Input)
 
-    def create_bus_term(
-        self, name: str, msb: int, lsb: int, direction: snl.SNLTerm.Direction
-    ) -> Term:
+    def create_inout_term(self, name: str) -> Term:
+        return self.create_term(name, snl.SNLTerm.Direction.InOut)
+
+    def create_bus_term(self, name: str, msb: int, lsb: int, direction) -> Term:
         if self.path.size() > 0:
             path = self.path
             snl.SNLUniquifier(path)
@@ -542,6 +646,9 @@ class Instance:
         newSNLTerm = snl.SNLBusTerm.create(design, direction, msb, lsb, name)
         return Term(self.path, newSNLTerm)
 
+    def create_inout_bus_term(self, name: str, msb: int, lsb: int) -> Term:
+        return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.InOut)
+
     def create_output_bus_term(self, name: str, msb: int, lsb: int) -> Term:
         return self.create_bus_term(name, msb, lsb, snl.SNLTerm.Direction.Output)
 
@@ -594,14 +701,29 @@ def create_top(name: str) -> Instance:
 
 
 def load_verilog(files: list):
+    start_time = time.time()
+    logging.info(f"Loading verilog: {', '.join(files)}")
     get_top_db().loadVerilog(files)
+    execution_time = time.time() - start_time
+    logging.info(f"Loading done in {execution_time:.2f} seconds")
     return get_top()
 
 
 def load_liberty(files: list):
+    logging.info(f"Loading liberty: {', '.join(files)}")
     get_top_db().loadLibertyPrimitives(files)
 
 
+def load_primitives(name: str):
+    if name == "xilinx":
+        logging.info("Loading xilinx primitives")
+        from najaeda.primitives import xilinx
+
+        xilinx.load(get_top_db())
+    else:
+        raise ValueError(f"Unknown primitives library: {name}")
+
+
 def get_primitives_library() -> snl.SNLLibrary:
     lib = get_top_db().getLibrary("PRIMS")
     if lib is None:
@@ -621,20 +743,3 @@ def get_model_name(id: tuple[int, int, int]) -> str:
                 if model:
                     return model.getName()
     return None
-
-
-def get_all_primitive_instances():
-    top = snl.SNLUniverse.get().getTopDesign()
-
-    for inst in top.getInstances():
-        path = snl.SNLPath(inst)
-        stack = [[inst, path]]
-        while stack:
-            current = stack.pop()
-            current_inst = current[0]
-            current_path = current[1]
-            for inst_child in current_inst.getModel().getInstances():
-                path_child = snl.SNLPath(current_path, inst_child)
-                if inst_child.getModel().isPrimitive():
-                    yield Instance(path_child)
-                stack.append([inst_child, path_child])

najaeda/primitives/xilinx.py

@@ -0,0 +1,452 @@
+# SPDX-FileCopyrightText: 2024 The Naja authors <https://github.com/najaeda/naja/blob/main/AUTHORS>
+#
+# SPDX-License-Identifier: Apache-2.0
+
+from najaeda import snl
+
+
+def constructIBUF(lib):
+    ibuf = snl.SNLDesign.createPrimitive(lib, "IBUF")
+    i = snl.SNLScalarTerm.create(ibuf, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(ibuf, snl.SNLTerm.Direction.Output, "O")
+    ibuf.addCombinatorialArcs(i, o)
+
+
+def constructOBUF(lib):
+    obuf = snl.SNLDesign.createPrimitive(lib, "OBUF")
+    i = snl.SNLScalarTerm.create(obuf, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(obuf, snl.SNLTerm.Direction.Output, "O")
+    obuf.addCombinatorialArcs(i, o)
+
+
+def constructBUFG(lib):
+    bufg = snl.SNLDesign.createPrimitive(lib, "BUFG")
+    i = snl.SNLScalarTerm.create(bufg, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(bufg, snl.SNLTerm.Direction.Output, "O")
+    bufg.addCombinatorialArcs(i, o)
+
+
+def constructDSP48E1(lib):
+    dsp48e1 = snl.SNLDesign.createPrimitive(lib, "DSP48E1")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 29, 0, "ACOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 17, 0, "BCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "CARRYCASCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "MULTSIGNOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "PCOUT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "OVERFLOW")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "PATTERNBDETECT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "PATTERNDETECT")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, "UNDERFLOW")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 3, 0, "CARRYOUT")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Output, 47, 0, "P")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 29, 0, "ACIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 17, 0, "BCIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CARRYCASCIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "MULTSIGNIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "PCIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 3, 0, "ALUMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 2, 0, "CARRYINSEL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CLK")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 4, 0, "INMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 6, 0, "OPMODE")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 29, 0, "A")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 17, 0, "B")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 47, 0, "C")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CARRYIN")
+    snl.SNLBusTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, 24, 0, "D")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEA1")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEA2")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEAD")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEALUMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEB1")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEB2")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEC")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CECARRYIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CECTRL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CED")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEINMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEM")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "CEP")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTA")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTALLCARRYIN")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTALUMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTB")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTC")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTCTRL")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTD")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTINMODE")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTM")
+    snl.SNLScalarTerm.create(dsp48e1, snl.SNLTerm.Direction.Input, "RSTP")
+    snl.SNLParameter.create_decimal(dsp48e1, "ACASCREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "ADREG", 1)
+    snl.SNLParameter.create_string(dsp48e1, "A_INPUT", "DIRECT")
+    snl.SNLParameter.create_decimal(dsp48e1, "ALUMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "AREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "BCASCREG", 1)
+    snl.SNLParameter.create_string(dsp48e1, "B_INPUT", "DIRECT")
+    snl.SNLParameter.create_decimal(dsp48e1, "BREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CARRYINREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CARRYINSELREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "CREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "DREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "INMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "MREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "OPMODEREG", 1)
+    snl.SNLParameter.create_decimal(dsp48e1, "PREG", 1)
+    snl.SNLParameter.create_boolean(dsp48e1, "USE_DPORT", False)
+    snl.SNLParameter.create_string(dsp48e1, "USE_MULT", "MULTIPLY")
+    snl.SNLParameter.create_string(dsp48e1, "USE_SIMD", "ONE48")
+
+
+def constructINV(lib):
+    inv = snl.SNLDesign.createPrimitive(lib, "INV")
+    i = snl.SNLScalarTerm.create(inv, snl.SNLTerm.Direction.Input, "I")
+    o = snl.SNLScalarTerm.create(inv, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs(i, o)
+
+
+def constructCARRY4(lib):
+    carry4 = snl.SNLDesign.createPrimitive(lib, "CARRY4")
+    o = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Output, 3, 0, "O")
+    co = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Output, 3, 0, "CO")
+    di = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Input, 3, 0, "DI")
+    s = snl.SNLBusTerm.create(carry4, snl.SNLTerm.Direction.Input, 3, 0, "S")
+    cyinit = snl.SNLScalarTerm.create(carry4, snl.SNLTerm.Direction.Input, "CYINIT")
+    ci = snl.SNLScalarTerm.create(carry4, snl.SNLTerm.Direction.Input, "CI")
+    o_bits = [b for b in o.getBits()]
+    co_bits = [b for b in co.getBits()]
+    di_bits = [b for b in di.getBits()]
+    s_bits = [b for b in s.getBits()]
+    # cyinit and ci are in combinatorial dependency with o and co outputs
+    snl.SNLDesign.addCombinatorialArcs([cyinit, ci], [o, co])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[0], [o, co])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[1], [o_bits[1], o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[1], [co_bits[1], co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[2], [o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[2], [co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[3], o_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(s_bits[3], co_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[0], [o_bits[1], o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[0], co)
+    snl.SNLDesign.addCombinatorialArcs(di_bits[1], [o_bits[2], o_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[1], [co_bits[1], co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[2], o_bits[3])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[2], [co_bits[2], co_bits[3]])
+    snl.SNLDesign.addCombinatorialArcs(di_bits[3], co_bits[3])
+
+
+def constructLUT1(lib):
+    lut1 = snl.SNLDesign.createPrimitive(lib, "LUT1")
+    i0 = snl.SNLScalarTerm.create(lut1, snl.SNLTerm.Direction.Input, "I0")
+    o = snl.SNLScalarTerm.create(lut1, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs(i0, o)
+    snl.SNLParameter.create_binary(lut1, "INIT", 2, 0b00)
+
+
+def constructLUT2(lib):
+    lut2 = snl.SNLDesign.createPrimitive(lib, "LUT2")
+    i0 = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(lut2, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1], o)
+    snl.SNLParameter.create_binary(lut2, "INIT", 4, 0x0)
+
+
+def constructLUT3(lib):
+    lut3 = snl.SNLDesign.createPrimitive(lib, "LUT3")
+    i0 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Input, "I2")
+    o = snl.SNLScalarTerm.create(lut3, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2], o)
+    snl.SNLParameter.create_binary(lut3, "INIT", 8, 0x00)
+
+
+def constructLUT4(lib):
+    lut4 = snl.SNLDesign.createPrimitive(lib, "LUT4")
+    i0 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Input, "I3")
+    o = snl.SNLScalarTerm.create(lut4, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3], o)
+    snl.SNLParameter.create_binary(lut4, "INIT", 16, 0x0000)
+
+
+def constructLUT5(lib):
+    lut5 = snl.SNLDesign.createPrimitive(lib, "LUT5")
+    i0 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I3")
+    i4 = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Input, "I4")
+    o = snl.SNLScalarTerm.create(lut5, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3, i4], o)
+    snl.SNLParameter.create_binary(lut5, "INIT", 32, 0x00000000)
+
+
+def constructLUT6(lib):
+    lut6 = snl.SNLDesign.createPrimitive(lib, "LUT6")
+    i0 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I1")
+    i2 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I2")
+    i3 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I3")
+    i4 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I4")
+    i5 = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Input, "I5")
+    o = snl.SNLScalarTerm.create(lut6, snl.SNLTerm.Direction.Output, "O")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, i2, i3, i4, i5], o)
+    snl.SNLParameter.create_binary(lut6, "INIT", 64, 0x0000000000000000)
+
+
+def constructMUXF7(lib):
+    muxf7 = snl.SNLDesign.createPrimitive(lib, "MUXF7")
+    i0 = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Output, "O")
+    s = snl.SNLScalarTerm.create(muxf7, snl.SNLTerm.Direction.Input, "S")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, s], o)
+
+
+def constructMUXF8(lib):
+    muxf8 = snl.SNLDesign.createPrimitive(lib, "MUXF8")
+    i0 = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "I0")
+    i1 = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "I1")
+    o = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Output, "O")
+    s = snl.SNLScalarTerm.create(muxf8, snl.SNLTerm.Direction.Input, "S")
+    snl.SNLDesign.addCombinatorialArcs([i0, i1, s], o)
+
+
+def constructSRL16E(lib):
+    srl16e = snl.SNLDesign.createPrimitive(lib, "SRL16E")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "CE")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "CLK")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Output, "Q")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A0")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A1")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A2")
+    snl.SNLScalarTerm.create(srl16e, snl.SNLTerm.Direction.Input, "A3")
+    snl.SNLParameter.create_binary(srl16e, "INIT", 16, 0x0000)
+    snl.SNLParameter.create_binary(srl16e, "IS_CLK_INVERTED", 1, 0)
+
+
+def constructFDCE(lib):
+    fdce = snl.SNLDesign.createPrimitive(lib, "FDCE")
+    q = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "CE")
+    clr = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "CLR")
+    d = snl.SNLScalarTerm.create(fdce, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdce, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, clr, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDPE(lib):
+    fdpe = snl.SNLDesign.createPrimitive(lib, "FDPE")
+    q = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "CE")
+    pre = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "PRE")
+    d = snl.SNLScalarTerm.create(fdpe, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdpe, "INIT", 1, 0b1)
+    snl.SNLDesign.addInputsToClockArcs([ce, pre, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDRE(lib):
+    fdre = snl.SNLDesign.createPrimitive(lib, "FDRE")
+    q = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "CE")
+    r = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "R")
+    d = snl.SNLScalarTerm.create(fdre, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdre, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, r, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructFDSE(lib):
+    fdse = snl.SNLDesign.createPrimitive(lib, "FDSE")
+    q = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Output, "Q")
+    c = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "C")
+    ce = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "CE")
+    s = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "S")
+    d = snl.SNLScalarTerm.create(fdse, snl.SNLTerm.Direction.Input, "D")
+    snl.SNLParameter.create_binary(fdse, "INIT", 1, 0b0)
+    snl.SNLDesign.addInputsToClockArcs([ce, s, d], c)
+    snl.SNLDesign.addClockToOutputsArcs(c, q)
+
+
+def constructRAM32M(lib):
+    ram32m = snl.SNLDesign.createPrimitive(lib, "RAM32M")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Output, 1, 0, "DOD")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 4, 0, "ADDRD")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIA")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIB")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DIC")
+    snl.SNLBusTerm.create(ram32m, snl.SNLTerm.Direction.Input, 1, 0, "DID")
+    snl.SNLScalarTerm.create(ram32m, snl.SNLTerm.Direction.Input, "WCLK")
+    snl.SNLScalarTerm.create(ram32m, snl.SNLTerm.Direction.Input, "WE")
+    snl.SNLParameter.create_binary(ram32m, "INIT_A", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_B", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_C", 64, 0)
+    snl.SNLParameter.create_binary(ram32m, "INIT_D", 64, 0)
+
+
+def constructRAM64M(lib):
+    ram64m = snl.SNLDesign.createPrimitive(lib, "RAM64M")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOA")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOB")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOC")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Output, "DOD")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRA")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRB")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRC")
+    snl.SNLBusTerm.create(ram64m, snl.SNLTerm.Direction.Input, 5, 0, "ADDRD")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIA")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIB")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DIC")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "DID")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "WCLK")
+    snl.SNLScalarTerm.create(ram64m, snl.SNLTerm.Direction.Input, "WE")
+    snl.SNLParameter.create_binary(ram64m, "INIT_A", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_B", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_C", 64, 0)
+    snl.SNLParameter.create_binary(ram64m, "INIT_D", 64, 0)
+
+
+def constructRAMB18E1(lib):
+    ramb18e1 = snl.SNLDesign.createPrimitive(lib, "RAMB18E1")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 13, 0, "ADDRARDADDR")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 13, 0, "ADDRBWRADDR")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "CLKARDCLK")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "CLKBWRCLK")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 15, 0, "DIADI")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 15, 0, "DIBDI")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "DIPADIP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "DIPBDIP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 15, 0, "DOADO")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 15, 0, "DOBDO")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 1, 0, "DOPADOP")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Output, 1, 0, "DOPBDOP")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "ENARDEN")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "ENBWREN")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "REGCEAREGCE")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "REGCEB")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTRAMARSTRAM")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTRAMB")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTREGARSTREG")
+    snl.SNLScalarTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, "RSTREGB")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 1, 0, "WEA")
+    snl.SNLBusTerm.create(ramb18e1, snl.SNLTerm.Direction.Input, 3, 0, "WEBWE")
+    snl.SNLParameter.create_decimal(ramb18e1, "DOA_REG", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "DOB_REG", 0)
+    snl.SNLParameter.create_binary(ramb18e1, "INIT_A", 18, 0x00000)
+    snl.SNLParameter.create_binary(ramb18e1, "INIT_B", 18, 0x00000)
+    for i in range(64):
+        paramName = "INIT_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb18e1, paramName, 256, 0)
+    for i in range(8):
+        paramName = "INITP_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb18e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb18e1, "RAM_MODE", "TDP")
+    snl.SNLParameter.create_decimal(ramb18e1, "READ_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "READ_WIDTH_B", 0)
+    snl.SNLParameter.create_binary(ramb18e1, "SRVAL_A", 18, 0)
+    snl.SNLParameter.create_binary(ramb18e1, "SRVAL_B", 18, 0)
+    snl.SNLParameter.create_string(ramb18e1, "WRITE_MODE_A", "WRITE_FIRST")
+    snl.SNLParameter.create_string(ramb18e1, "WRITE_MODE_B", "WRITE_FIRST")
+    snl.SNLParameter.create_decimal(ramb18e1, "WRITE_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb18e1, "WRITE_WIDTH_B", 0)
+
+
+def constructRAMB36E1(lib):
+    ramb36e1 = snl.SNLDesign.createPrimitive(lib, "RAMB36E1")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 15, 0, "ADDRARDADDR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 15, 0, "ADDRBWRADDR")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CASCADEINA")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CASCADEINB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "CASCADEOUTA")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "CASCADEOUTB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CLKARDCLK")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "CLKBWRCLK")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "DBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 31, 0, "DIADI")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 31, 0, "DIBDI")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "DIPADIP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "DIPBDIP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 31, 0, "DOADO")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 31, 0, "DOBDO")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 3, 0, "DOPADOP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 3, 0, "DOPBDOP")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 7, 0, "ECCPARITY")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "ENARDEN")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "ENBWREN")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "INJECTDBITERR")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "INJECTSBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, 8, 0, "RDADDRECC")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "REGCEAREGCE")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "REGCEB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTRAMARSTRAM")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTRAMB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTREGARSTREG")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, "RSTREGB")
+    snl.SNLScalarTerm.create(ramb36e1, snl.SNLTerm.Direction.Output, "SBITERR")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 3, 0, "WEA")
+    snl.SNLBusTerm.create(ramb36e1, snl.SNLTerm.Direction.Input, 7, 0, "WEBWE")
+
+    snl.SNLParameter.create_decimal(ramb36e1, "DOA_REG", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "DOB_REG", 0)
+    snl.SNLParameter.create_binary(ramb36e1, "INIT_A", 36, 0)
+    snl.SNLParameter.create_binary(ramb36e1, "INIT_B", 36, 0)
+    for i in range(128):
+        paramName = "INIT_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb36e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb36e1, "RAM_EXTENSION_A", "NONE")
+    snl.SNLParameter.create_string(ramb36e1, "RAM_EXTENSION_B", "NONE")
+    for i in range(16):
+        paramName = "INITP_" + hex(i)[2:].zfill(2).upper()
+        snl.SNLParameter.create_binary(ramb36e1, paramName, 256, 0)
+    snl.SNLParameter.create_string(ramb36e1, "RAM_MODE", "TDP")
+    snl.SNLParameter.create_decimal(ramb36e1, "READ_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "READ_WIDTH_B", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "WRITE_WIDTH_A", 0)
+    snl.SNLParameter.create_decimal(ramb36e1, "WRITE_WIDTH_B", 0)
+    snl.SNLParameter.create_binary(ramb36e1, "SRVAL_A", 36, 0)
+    snl.SNLParameter.create_binary(ramb36e1, "SRVAL_B", 36, 0)
+    snl.SNLParameter.create_string(ramb36e1, "WRITE_MODE_A", "WRITE_FIRST")
+    snl.SNLParameter.create_string(ramb36e1, "WRITE_MODE_B", "WRITE_FIRST")
+
+
+def load(db):
+    lib = snl.SNLLibrary.createPrimitives(db, "xilinx")
+    constructIBUF(lib)
+    constructOBUF(lib)
+    constructBUFG(lib)
+    constructDSP48E1(lib)
+    constructINV(lib)
+    constructCARRY4(lib)
+    constructLUT1(lib)
+    constructLUT2(lib)
+    constructLUT3(lib)
+    constructLUT4(lib)
+    constructLUT5(lib)
+    constructLUT6(lib)
+    constructMUXF7(lib)
+    constructMUXF8(lib)
+    constructSRL16E(lib)
+    constructFDCE(lib)
+    constructFDPE(lib)
+    constructFDRE(lib)
+    constructFDSE(lib)
+    constructRAM32M(lib)
+    constructRAM64M(lib)
+    constructRAMB18E1(lib)
+    constructRAMB36E1(lib)

{najaeda-0.1.2.dist-info → najaeda-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: najaeda
-Version: 0.1.2
+Version: 0.1.4
 Summary: Naja EDA Python package
 Author-Email: Naja Authors <contact@keplertech.io>
 License: Apache License 2.0
@@ -11,15 +11,8 @@ Description-Content-Type: text/x-rst
 Naja EDA Python Package
 =======================
 
-Naja EDA is a Python package that provides data structures and APIs for developing post-synthesis Electronic Design Automation (EDA) algorithms. It serves as the Python counterpart to the `Naja C++ project <https://github.com/najaeda/naja>`_.
-
-Features
---------
-
-- **Netlist Simplification**: Perform constant propagation and dead logic elimination.
-- **Logic Replication**: Facilitate duplication of logic elements for optimization.
-- **Netlist Partitioning**: Divide netlists into manageable sections.
-- **Place and Route Support**: Assist in ASIC and FPGA design flows.
+Naja EDA is a Python package that provides data structures and APIs for developing post-synthesis Electronic Design Automation (EDA) algorithms.
+It serves as the Python counterpart to the `Naja C++ project <https://github.com/najaeda/naja>`_.
 
 Installation
 ------------
@@ -32,24 +25,48 @@ Install Naja EDA using pip:
 
 Examples
 --------
+
+Load a design from a liberty file and a Verilog file
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Following snippet shows how to load primitive cells from a liberty file and
 a netlist from a Verilog file.
+
 .. code-block:: python
 
-    from os import path
-    from najaeda import netlist
-    
     benchmarks = path.join('..','benchmarks')
-    liberty_files = ['NangateOpenCellLibrary_typical.lib', 'fakeram45_1024x32.lib', 'fakeram45_64x32.lib']
+    liberty_files = [
+        'NangateOpenCellLibrary_typical.lib',
+        'fakeram45_1024x32.lib',
+        'fakeram45_64x32.lib'
+    ]
     liberty_files = list(map(lambda p:path.join(benchmarks, 'liberty', p), liberty_files))
         
     netlist.load_liberty(liberty_files)
     top = netlist.load_verilog([path.join(benchmarks, 'verilog', 'tinyrocket.v')])
     
-    #dump verilog
-    top.dump_verilog('tinyrocket_naja.v')
+    top.dump_verilog('.', 'tinyrocket_naja.v')
+
+Load a design with pre-existing libraries
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+In FPGA design environments, Liberty files are often unavailable.
+To address this, the following example demonstrates how to load primitives
+without relying on Liberty files.
 
+najaeda comes with pre-configured libraries to simplify this process.
+Currently, it includes support for partial Xilinx primitives, but this can be
+easily extended in the future. Don't hesitate to reach out if you need help.
+
+.. code-block:: python
+
+    netlist.load_primitives('xilinx')
+    benchmarks = path.join('..','benchmarks')
+    top = netlist.load_verilog([path.join(benchmarks, 'verilog', 'arm_core_netlist.v')])
+    #
+
+Print all the instances in the netlist
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 Next example shows how to browse all the netlist and print all its content.
+
 .. code-block:: python
 
     def print_netlist(instance):
@@ -59,8 +76,9 @@ Next example shows how to browse all the netlist and print all its content.
 
 Documentation
 -------------
+najaeda is a work in progress, and the documentation is still under development.
 
-Comprehensive documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
+Naja documentation is available on the `Naja GitHub repository <https://github.com/najaeda/naja>`_.
 
 License
 -------

najaeda-0.1.4.dist-info/RECORD

@@ -0,0 +1,12 @@
+najaeda-0.1.4.dist-info/RECORD,,
+najaeda-0.1.4.dist-info/WHEEL,sha256=vqMBchNIsmW0K9HInUQuY_xePW9YD3coNJy6G1Yfto8,114
+najaeda-0.1.4.dist-info/METADATA,sha256=rpver3Febf2UhLXS-HAceNHU3YnNLGKde1icywDK_-Y,2842
+najaeda-0.1.4.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+najaeda-0.1.4.dist-info/licenses/AUTHORS,sha256=7NYEGDAX_1QZvCCHfq8YVXC5ZbwH_pbNI8DcSmm70GU,377
+najaeda/netlist.py,sha256=ena4A9S1UxQV-pO1XWxO_qbG-4ELnorKInJgX0zN3M0,25633
+najaeda/libnaja_snl_python.dylib,sha256=PvesumeH7pjidMQSU_i0UYsSvca4fnHw2tEkptLURvg,740160
+najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
+najaeda/snl.so,sha256=d9W9rNMzNl0T88DpH7thDuP3NK6nyVgJYXYKx3Uxm7I,97888
+najaeda/primitives/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+najaeda/primitives/xilinx.py,sha256=fuu4KxEIuC0ueCK4C_gds6hzgtJsLE3tjDtOHtY9McM,25947

{najaeda-0.1.2.dist-info → najaeda-0.1.4.dist-info}/licenses/AUTHORS

@@ -3,4 +3,5 @@
 # This does not necessarily list everyone who has contributed code, since in
 # some cases, their employer may be the copyright holder.  To see the full list
 # of contributors, see the revision history in source control.
-Christophe Alexandre <christophe.alex@gmail.com>
+Christophe Alexandre <christophe.alexandre@keplertech.io>
+Noam Cohen <noam.cohen@keplertech.io>

najaeda-0.1.2.dist-info/RECORD

@@ -1,11 +0,0 @@
-najaeda-0.1.2.dist-info/RECORD,,
-najaeda-0.1.2.dist-info/WHEEL,sha256=vqMBchNIsmW0K9HInUQuY_xePW9YD3coNJy6G1Yfto8,114
-najaeda-0.1.2.dist-info/METADATA,sha256=agjVbL5DID69VNnjngj23q1t-TEOHBaCUhMnhIGEjZI,2267
-najaeda-0.1.2.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-najaeda-0.1.2.dist-info/licenses/AUTHORS,sha256=e4DCPGHo6wKMyQz24V59EP7zMwalK-KBDBHHlMLFxHY,330
-najaeda/netlist.py,sha256=usJ__3Vh_A8GFK7xUdhwJSdsTc7DWhaIF3Ptp3dfuZU,21251
-najaeda/libnaja_snl_python.dylib,sha256=OZ222EZCWFrvmsDs6asQWMl0QP8Wqhny8kOFBjznGH4,739872
-najaeda/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-najaeda/libnaja_snl.dylib,sha256=8Ei7KKU0b14IqlvH_8yQSSCpH0rjbxpeRaXgyfSemMY,574112
-najaeda/snl.so,sha256=qBdtIcQsyMywHa-xUMdCJaTwG6yl189Bm6Zr96ZR6pU,97888
-najaeda/.dylibs/Python,sha256=Gju99qyqKDZ_AHI35mL42rySLjq0Ww_yvHDxtQSu7Kw,14303584