#!/usr/bin/env python3
# flake8: noqa
# Copyright 2020 Efabless Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

#
# --------------------------------------------------------
# Padframe Editor and Core Floorplanner
#
# --------------------------------------------------------
# Written by Tim Edwards
# efabless, inc.
# April 24, 2019
# Version 0.5
# Based on https://github.com/YosysHQ/padring (requirement)
# Update: May 9, 2019 to add console message window
# Update: May 10, 2019 to incorporate core floorplanning
# Update: Jan 31, 2020 to allow batch operation
# --------------------------------------------------------

import os
import re
import sys
import glob
import json
import math
import shutil
import signal
import select
import subprocess
import faulthandler

import tkinter
from tkinter import ttk

# User preferences file (if it exists)
prefsfile = "~/design/.profile/prefs.json"

# ------------------------------------------------------
# Dialog for entering a pad
# ------------------------------------------------------


class ConsoleText(tkinter.Text):
    linelimit = 500

    class IORedirector(object):
        """A general class for redirecting I/O to this Text widget."""

        def __init__(self, text_area):
            self.text_area = text_area

    class StdoutRedirector(IORedirector):
        """A class for redirecting stdout to this Text widget."""

        def write(self, str):
            self.text_area.write(str, False)

    class StderrRedirector(IORedirector):
        """A class for redirecting stderr to this Text widget."""

        def write(self, str):
            self.text_area.write(str, True)

    def __init__(self, master=None, cnf={}, **kw):
        """See the __init__ for Tkinter.Text."""

        tkinter.Text.__init__(self, master, cnf, **kw)

        self.tag_configure("stdout", background="white", foreground="black")
        self.tag_configure("stderr", background="white", foreground="red")
        # None of these works!  Cannot change selected text background!
        self.config(selectbackground="blue", selectforeground="white")
        self.tag_configure("sel", background="blue", foreground="white")

    def write(self, val, is_stderr=False):
        lines = int(self.index("end-1c").split(".")[0])
        if lines > self.linelimit:
            self.delete("1.0", str(lines - self.linelimit) + ".0")
        self.insert("end", val, "stderr" if is_stderr else "stdout")
        self.see("end")

    def limit(self, val):
        self.linelimit = val


class Dialog(tkinter.Toplevel):
    def __init__(
        self, parent, message=None, title=None, seed=None, border="blue", **kwargs
    ):

        tkinter.Toplevel.__init__(self, parent)
        self.transient(parent)

        if title:
            self.title(title)

        self.configure(background=border, padx=2, pady=2)
        self.obox = ttk.Frame(self)
        self.obox.pack(side="left", fill="both", expand="true")

        self.parent = parent
        self.result = None
        body = ttk.Frame(self.obox)
        self.initial_focus = self.body(body, message, seed, **kwargs)
        body.pack(padx=5, pady=5)
        self.buttonbox()
        self.grab_set()

        if not self.initial_focus:
            self.initial_focus = self

        self.protocol("WM_DELETE_WINDOW", self.cancel)
        self.geometry("+%d+%d" % (parent.winfo_rootx() + 50, parent.winfo_rooty() + 50))

        self.initial_focus.focus_set()
        self.wait_window(self)

    # Construction hooks

    def body(self, master, **kwargs):
        # Create dialog body.  Return widget that should have
        # initial focus.  This method should be overridden
        pass

    def buttonbox(self):
        # Add standard button box.  Override if you don't want the
        # standard buttons

        box = ttk.Frame(self.obox)

        self.okb = ttk.Button(
            box, text="OK", width=10, command=self.ok, default="active"
        )
        self.okb.pack(side="left", padx=5, pady=5)
        w = ttk.Button(box, text="Cancel", width=10, command=self.cancel)
        w.pack(side="left", padx=5, pady=5)

        self.bind("<Return>", self.ok)
        self.bind("<Escape>", self.cancel)
        box.pack(fill="x", expand="true")

    # Standard button semantics

    def ok(self, event=None):

        if not self.validate():
            self.initial_focus.focus_set()  # put focus back
            return

        self.withdraw()
        self.update_idletasks()
        self.result = self.apply()
        self.cancel()

    def cancel(self, event=None):

        # Put focus back to the parent window
        self.parent.focus_set()
        self.destroy()

    def validate(self):
        return 1  # Override this

    def apply(self):
        return None  # Override this


class PadNameDialog(Dialog):
    def body(self, master, warning=None, seed=None):
        if warning:
            ttk.Label(master, text=warning).grid(row=0, columnspan=2, sticky="wns")
        ttk.Label(master, text="Enter new group name:").grid(
            row=1, column=0, sticky="wns"
        )
        self.nentry = ttk.Entry(master)
        self.nentry.grid(row=1, column=1, sticky="ewns")
        if seed:
            self.nentry.insert(0, seed)
        return self.nentry  # initial focus

    def apply(self):
        return self.nentry.get()


# ------------------------------------------------------
# Dialog for entering core dimensions
# ------------------------------------------------------


class CoreSizeDialog(Dialog):
    def body(self, master, warning="Chip core dimensions", seed=None):
        if warning:
            ttk.Label(master, text=warning).grid(row=0, columnspan=2, sticky="wns")
        ttk.Label(master, text="Enter core width x height (microns):").grid(
            row=1, column=0, sticky="wns"
        )
        self.nentry = ttk.Entry(master)
        self.nentry.grid(row=1, column=1, sticky="ewns")

        if seed:
            self.nentry.insert(0, seed)
        return self.nentry  # initial focus

    def apply(self):
        return self.nentry.get()


# ------------------------------------------------
# SoC Floorplanner and Padframe Generator GUI
# ------------------------------------------------


class SoCFloorplanner(ttk.Frame):
    """Open Galaxy Pad Frame Generator."""

    def __init__(self, parent=None, *args, **kwargs):
        """See the __init__ for Tkinter.Toplevel."""
        ttk.Frame.__init__(self, parent, *args[1:], **kwargs)
        self.root = parent
        self.init_data()
        if args[0] == True:
            self.do_gui = True
            self.init_gui()
        else:
            self.do_gui = False
            self.use_console = False

    def on_quit(self):
        """Exits program."""
        quit()

    def init_gui(self):
        """Builds GUI."""
        global prefsfile

        message = []
        fontsize = 11

        # Read user preferences file, get default font size from it.
        prefspath = os.path.expanduser(prefsfile)
        if os.path.exists(prefspath):
            with open(prefspath, "r") as f:
                self.prefs = json.load(f)
            if "fontsize" in self.prefs:
                fontsize = self.prefs["fontsize"]
        else:
            self.prefs = {}

        s = ttk.Style()

        available_themes = s.theme_names()
        s.theme_use(available_themes[0])

        s.configure(
            "normal.TButton", font=("Helvetica", fontsize), border=3, relief="raised"
        )
        s.configure(
            "title.TLabel",
            font=("Helvetica", fontsize, "bold italic"),
            foreground="brown",
            anchor="center",
        )
        s.configure("blue.TLabel", font=("Helvetica", fontsize), foreground="blue")
        s.configure("normal.TLabel", font=("Helvetica", fontsize))
        s.configure("normal.TCheckbutton", font=("Helvetica", fontsize))
        s.configure("normal.TMenubutton", font=("Helvetica", fontsize))
        s.configure("normal.TEntry", font=("Helvetica", fontsize), background="white")
        s.configure(
            "pad.TLabel", font=("Helvetica", fontsize), foreground="blue", relief="flat"
        )
        s.configure(
            "select.TLabel",
            font=("Helvetica", fontsize, "bold"),
            foreground="white",
            background="blue",
            relief="flat",
        )

        # parent.withdraw()
        self.root.title("Padframe Generator and Core Floorplanner")
        self.root.option_add("*tearOff", "FALSE")
        self.pack(side="top", fill="both", expand="true")
        self.root.protocol("WM_DELETE_WINDOW", self.on_quit)

        pane = tkinter.PanedWindow(
            self, orient="vertical", sashrelief="groove", sashwidth=6
        )
        pane.pack(side="top", fill="both", expand="true")

        self.toppane = ttk.Frame(pane)
        self.botpane = ttk.Frame(pane)

        self.toppane.columnconfigure(0, weight=1)
        self.toppane.rowconfigure(0, weight=1)
        self.botpane.columnconfigure(0, weight=1)
        self.botpane.rowconfigure(0, weight=1)

        # Scrolled frame using canvas widget
        self.pframe = tkinter.Frame(self.toppane)
        self.pframe.grid(row=0, column=0, sticky="news")
        self.pframe.rowconfigure(0, weight=1)
        self.pframe.columnconfigure(0, weight=1)

        # Add column on the left, listing all groups and the pads they belong to.
        # This starts as just a frame to be filled.  Use a canvas to create a
        # scrolled frame.

        # The primary frame holds the canvas
        self.canvas = tkinter.Canvas(self.pframe, background="white")
        self.canvas.grid(row=0, column=0, sticky="news")

        # Add Y scrollbar to pad list window
        xscrollbar = ttk.Scrollbar(self.pframe, orient="horizontal")
        xscrollbar.grid(row=1, column=0, sticky="news")
        yscrollbar = ttk.Scrollbar(self.pframe, orient="vertical")
        yscrollbar.grid(row=0, column=1, sticky="news")

        self.canvas.config(xscrollcommand=xscrollbar.set)
        xscrollbar.config(command=self.canvas.xview)
        self.canvas.config(yscrollcommand=yscrollbar.set)
        yscrollbar.config(command=self.canvas.yview)

        self.canvas.bind("<Button-4>", self.on_scrollwheel)
        self.canvas.bind("<Button-5>", self.on_scrollwheel)

        # Configure callback
        self.canvas.bind("<Configure>", self.frame_configure)

        # Add a text window to capture output.  Redirect print statements to it.
        self.console = ttk.Frame(self.botpane)
        self.console.grid(column=0, row=0, sticky="news")
        self.text_box = ConsoleText(self.console, wrap="word", height=4)
        self.text_box.pack(side="left", fill="both", expand="true")
        console_scrollbar = ttk.Scrollbar(self.console)
        console_scrollbar.pack(side="right", fill="y")
        # Attach console to scrollbar
        self.text_box.config(yscrollcommand=console_scrollbar.set)
        console_scrollbar.config(command=self.text_box.yview)

        # Add the bottom bar with buttons
        self.bbar = ttk.Frame(self.botpane)
        self.bbar.grid(column=0, row=1, sticky="news")

        self.bbar.import_button = ttk.Button(
            self.bbar, text="Import", command=self.vlogimport, style="normal.TButton"
        )
        self.bbar.import_button.grid(column=0, row=0, padx=5)

        self.bbar.generate_button = ttk.Button(
            self.bbar, text="Generate", command=self.generate, style="normal.TButton"
        )
        self.bbar.generate_button.grid(column=1, row=0, padx=5)

        self.bbar.save_button = ttk.Button(
            self.bbar, text="Save", command=self.save, style="normal.TButton"
        )
        self.bbar.save_button.grid(column=2, row=0, padx=5)

        self.bbar.cancel_button = ttk.Button(
            self.bbar, text="Quit", command=self.on_quit, style="normal.TButton"
        )
        self.bbar.cancel_button.grid(column=3, row=0, padx=5)

        pane.add(self.toppane)
        pane.add(self.botpane)
        pane.paneconfig(self.toppane, stretch="first")

    def init_data(self):

        self.vlogpads = []
        self.corecells = []
        self.Npads = []
        self.Spads = []
        self.Epads = []
        self.Wpads = []
        self.NEpad = []
        self.NWpad = []
        self.SEpad = []
        self.SWpad = []
        self.coregroup = []

        self.celldefs = []
        self.coredefs = []
        self.selected = []
        self.ioleflibs = []
        self.llx = 0
        self.lly = 0
        self.urx = 0
        self.ury = 0

        self.event_data = {}
        self.event_data["x0"] = 0
        self.event_data["y0"] = 0
        self.event_data["x"] = 0
        self.event_data["y"] = 0
        self.event_data["tag"] = None
        self.scale = 1.0
        self.margin = 100
        self.pad_rotation = 0

        self.init_messages = []
        self.stdout = None
        self.stderr = None

        self.keep_cfg = False
        self.ef_format = False
        self.use_console = False

    def init_padframe(self):
        self.set_project()
        self.vlogimport()
        self.readplacement(precheck=True)
        self.resolve()
        self.generate(0)

    # Local routines for handling printing to the text console

    def print(self, message, file=None, end="\n", flush=True):
        if not file:
            if not self.use_console:
                file = sys.stdout
            else:
                file = ConsoleText.StdoutRedirector(self.text_box)
        if self.stdout:
            print(message, file=file, end=end)
            if flush:
                self.stdout.flush()
                self.update_idletasks()
        else:
            self.init_messages.append(message)

    def text_to_console(self):
        # Redirect stdout and stderr to the console as the last thing to do. . .
        # Otherwise errors in the GUI get sucked into the void.

        self.stdout = sys.stdout
        self.stderr = sys.stderr
        if self.use_console:
            sys.stdout = ConsoleText.StdoutRedirector(self.text_box)
            sys.stderr = ConsoleText.StderrRedirector(self.text_box)

        if len(self.init_messages) > 0:
            for message in self.init_messages:
                self.print(message)
            self.init_messages = []

    # Set the project name(s).  This is the name of the top-level verilog.
    # The standard protocol is that the project directory contains a file
    # project.json that defines a name 'ip-name' that is the same as the
    # layout name, the verilog module name, etc.

    def set_project(self):
        # Check pwd
        pwdname = self.projectpath if self.projectpath else os.getcwd()

        subdir = os.path.split(pwdname)[1]
        if subdir == "mag" or subdir == "verilog":
            projectpath = os.path.split(pwdname)[0]
        else:
            projectpath = pwdname

        projectroot = os.path.split(projectpath)[0]
        projectdirname = os.path.split(projectpath)[1]

        # Check for project.json

        jsonname = None
        if os.path.isfile(projectpath + "/project.json"):
            jsonname = projectpath + "/project.json"
        elif os.path.isfile(projectroot + "/" + projectdirname + ".json"):
            jsonname = projectroot + "/" + projectdirname + ".json"
        if os.path.isfile(projectroot + "/project.json"):
            # Just in case this was started from some other subdirectory
            projectpath = projectroot
            jsonname = projectroot + "/project.json"

        if jsonname:
            self.print("Reading project JSON file " + jsonname)
            with open(jsonname, "r") as ifile:
                topdata = json.load(ifile)
                if "data-sheet" in topdata:
                    dsheet = topdata["data-sheet"]
                    if "ip-name" in dsheet:
                        self.project = dsheet["ip-name"]
                        self.projectpath = projectpath
        else:
            self.print(
                "No project JSON file; using directory name as the project name."
            )
            self.project = os.path.split(projectpath)[1]
            self.projectpath = projectpath

        self.print("Project name is " + self.project + " (" + self.projectpath + ")")

    # Functions for drag-and-drop capability
    def add_draggable(self, tag):
        self.canvas.tag_bind(tag, "<ButtonPress-1>", self.on_button_press)
        self.canvas.tag_bind(tag, "<ButtonRelease-1>", self.on_button_release)
        self.canvas.tag_bind(tag, "<B1-Motion>", self.on_button_motion)
        self.canvas.tag_bind(tag, "<ButtonPress-2>", self.on_button2_press)
        self.canvas.tag_bind(tag, "<ButtonPress-3>", self.on_button3_press)

    def on_button_press(self, event):
        """Begining drag of an object"""
        # Find the closest item, then record its tag.
        locx = event.x + self.canvas.canvasx(0)
        locy = event.y + self.canvas.canvasy(0)
        item = self.canvas.find_closest(locx, locy)[0]
        self.event_data["tag"] = self.canvas.gettags(item)[0]
        self.event_data["x0"] = event.x
        self.event_data["y0"] = event.y
        self.event_data["x"] = event.x
        self.event_data["y"] = event.y

    def on_button2_press(self, event):
        """Flip an object (excluding corners)"""
        locx = event.x + self.canvas.canvasx(0)
        locy = event.y + self.canvas.canvasy(0)
        item = self.canvas.find_closest(locx, locy)[0]
        tag = self.canvas.gettags(item)[0]

        try:
            corecell = next(item for item in self.coregroup if item["name"] == tag)
        except Exception:
            try:
                pad = next(item for item in self.Npads if item["name"] == tag)
            except Exception:
                pad = None
            if not pad:
                try:
                    pad = next(item for item in self.Epads if item["name"] == tag)
                except Exception:
                    pad = None
            if not pad:
                try:
                    pad = next(item for item in self.Spads if item["name"] == tag)
                except Exception:
                    pad = None
            if not pad:
                try:
                    pad = next(item for item in self.Wpads if item["name"] == tag)
                except Exception:
                    pad = None
            if not pad:
                self.print("Error: Object cannot be flipped.")
            else:
                # Flip the pad (in the only way meaningful for the pad).
                orient = pad["o"]
                if orient == "N":
                    pad["o"] = "FN"
                elif orient == "E":
                    pad["o"] = "FW"
                elif orient == "S":
                    pad["o"] = "FS"
                elif orient == "W":
                    pad["o"] = "FE"
                elif orient == "FN":
                    pad["o"] = "N"
                elif orient == "FE":
                    pad["o"] = "W"
                elif orient == "FS":
                    pad["o"] = "S"
                elif orient == "FW":
                    pad["o"] = "E"
        else:
            # Flip the cell.  Use the DEF meaning of flip, which is to
            # add or subtract 'F' from the orientation.
            orient = corecell["o"]
            if not "F" in orient:
                corecell["o"] = "F" + orient
            else:
                corecell["o"] = orient[1:]

        # Redraw
        self.populate(0)

    def on_button3_press(self, event):
        """Rotate a core object (no pads)"""
        locx = event.x + self.canvas.canvasx(0)
        locy = event.y + self.canvas.canvasy(0)
        item = self.canvas.find_closest(locx, locy)[0]
        tag = self.canvas.gettags(item)[0]

        try:
            corecell = next(item for item in self.coregroup if item["name"] == tag)
        except Exception:
            self.print("Error: Object cannot be rotated.")
        else:
            # Modify its orientation
            orient = corecell["o"]
            if orient == "N":
                corecell["o"] = "E"
            elif orient == "E":
                corecell["o"] = "S"
            elif orient == "S":
                corecell["o"] = "W"
            elif orient == "W":
                corecell["o"] = "N"
            elif orient == "FN":
                corecell["o"] = "FW"
            elif orient == "FW":
                corecell["o"] = "FS"
            elif orient == "FS":
                corecell["o"] = "FE"
            elif orient == "FE":
                corecell["o"] = "FN"

            # rewrite the core DEF file
            self.write_core_def()

        # Redraw
        self.populate(0)

    def on_button_motion(self, event):
        """Handle dragging of an object"""
        # compute how much the mouse has moved
        delta_x = event.x - self.event_data["x"]
        delta_y = event.y - self.event_data["y"]
        # move the object the appropriate amount
        self.canvas.move(self.event_data["tag"], delta_x, delta_y)
        # record the new position
        self.event_data["x"] = event.x
        self.event_data["y"] = event.y

    def on_button_release(self, event):
        """End drag of an object"""

        # Find the pad associated with the tag and update its position information
        tag = self.event_data["tag"]

        # Collect pads in clockwise order.  Note that E and S rows are not clockwise
        allpads = []
        allpads.extend(self.Npads)
        allpads.extend(self.NEpad)
        allpads.extend(reversed(self.Epads))
        allpads.extend(self.SEpad)
        allpads.extend(reversed(self.Spads))
        allpads.extend(self.SWpad)
        allpads.extend(self.Wpads)
        allpads.extend(self.NWpad)

        # Create a list of row references (also in clockwise order, but no reversing)
        padrows = [
            self.Npads,
            self.NEpad,
            self.Epads,
            self.SEpad,
            self.Spads,
            self.SWpad,
            self.Wpads,
            self.NWpad,
        ]

        # Record the row or corner where this pad was located before the move
        for row in padrows:
            try:
                pad = next(item for item in row if item["name"] == tag)
            except Exception:
                pass
            else:
                padrow = row
                break

        # Currently there is no procedure to move a pad out of the corner
        # position;  corners are fixed by definition.
        if (
            padrow == self.NEpad
            or padrow == self.SEpad
            or padrow == self.SWpad
            or padrow == self.NWpad
        ):
            # Easier to run generate() than to put the pad back. . .
            self.generate(0)
            return

        # Find the original center point of the pad being moved

        padllx = pad["x"]
        padlly = pad["y"]
        if pad["o"] == "N" or pad["o"] == "S":
            padurx = padllx + pad["width"]
            padury = padlly + pad["height"]
        else:
            padurx = padllx + pad["height"]
            padury = padlly + pad["width"]
        padcx = (padllx + padurx) / 2
        padcy = (padlly + padury) / 2

        # Add distance from drag information (note that drag position in y
        # is negative relative to the chip dimensions)
        padcx += (self.event_data["x"] - self.event_data["x0"]) / self.scale
        padcy -= (self.event_data["y"] - self.event_data["y0"]) / self.scale

        # reset the drag information
        self.event_data["tag"] = None
        self.event_data["x"] = 0
        self.event_data["y"] = 0
        self.event_data["x0"] = 0
        self.event_data["y0"] = 0

        # Find the distance from the pad to all other pads, and get the two
        # closest entries.

        wwidth = self.urx - self.llx
        dist0 = wwidth
        dist1 = wwidth
        pad0 = None
        pad1 = None

        for npad in allpads:
            if npad == pad:
                continue

            npadllx = npad["x"]
            npadlly = npad["y"]
            if npad["o"] == "N" or npad["o"] == "S":
                npadurx = npadllx + npad["width"]
                npadury = npadlly + npad["height"]
            else:
                npadurx = npadllx + npad["height"]
                npadury = npadlly + npad["width"]
            npadcx = (npadllx + npadurx) / 2
            npadcy = (npadlly + npadury) / 2

            deltx = npadcx - padcx
            delty = npadcy - padcy
            pdist = math.sqrt(deltx * deltx + delty * delty)
            if pdist < dist0:
                dist1 = dist0
                pad1 = pad0
                dist0 = pdist
                pad0 = npad

            elif pdist < dist1:
                dist1 = pdist
                pad1 = npad

        # Diagnostic
        # self.print('Two closest pads to pad ' + pad['name'] + ' (' + pad['cell'] + '): ')
        # self.print(pad0['name'] + ' (' + pad0['cell'] + ') dist = ' + str(dist0))
        # self.print(pad1['name'] + ' (' + pad1['cell'] + ') dist = ' + str(dist1))

        # Record the row or corner where these pads are
        for row in padrows:
            try:
                testpad = next(item for item in row if item["name"] == pad0["name"])
            except Exception:
                pass
            else:
                padrow0 = row
                break

        for row in padrows:
            try:
                testpad = next(item for item in row if item["name"] == pad1["name"])
            except Exception:
                pass
            else:
                padrow1 = row
                break

        # Remove pad from its own row
        padrow.remove(pad)

        # Insert pad into new row.  Watch for wraparound from the last entry to the first
        padidx0 = allpads.index(pad0)
        padidx1 = allpads.index(pad1)
        if padidx0 == 0 and padidx1 > 2:
            padidx1 = -1

        if padidx1 > padidx0:
            padafter = pad1
            rowafter = padrow1
            padbefore = pad0
            rowbefore = padrow0
        else:
            padafter = pad0
            rowafter = padrow0
            padbefore = pad1
            rowbefore = padrow1

        # Do not replace corner positions (? may be necessary ?)
        if rowafter == self.NWpad:
            self.Wpads.append(pad)
        elif rowafter == self.NWpad:
            self.Npads.append(pad)
        elif rowafter == self.SEpad:
            self.Epads.insert(0, pad)
        elif rowafter == self.SWpad:
            self.Spads.insert(0, pad)
        elif rowafter == self.Wpads or rowafter == self.Npads:
            idx = rowafter.index(padafter)
            rowafter.insert(idx, pad)
        elif rowbefore == self.NEpad:
            self.Epads.append(pad)
        elif rowbefore == self.SEpad:
            self.Spads.append(pad)
        else:
            # rows E and S are ordered counterclockwise
            idx = rowbefore.index(padbefore)
            rowbefore.insert(idx, pad)

        # Re-run padring
        self.generate(0)

    def on_scrollwheel(self, event):
        if event.num == 4:
            zoomval = 1.1
        elif event.num == 5:
            zoomval = 0.9
        else:
            zoomval = 1.0

        self.scale *= zoomval
        self.canvas.scale("all", -15 * zoomval, -15 * zoomval, zoomval, zoomval)
        self.event_data["x"] *= zoomval
        self.event_data["y"] *= zoomval
        self.event_data["x0"] *= zoomval
        self.event_data["y0"] *= zoomval
        self.frame_configure(event)

    # Callback functions similar to the pad event callbacks above, but for
    # core cells.  Unlike pad cells, core cells can be rotated and flipped
    # arbitrarily, and they do not force a recomputation of the padframe
    # unless their position forces the padframe to expand

    def add_core_draggable(self, tag):
        self.canvas.tag_bind(tag, "<ButtonPress-1>", self.on_button_press)
        self.canvas.tag_bind(tag, "<ButtonRelease-1>", self.core_on_button_release)
        self.canvas.tag_bind(tag, "<B1-Motion>", self.on_button_motion)
        self.canvas.tag_bind(tag, "<ButtonPress-2>", self.on_button2_press)
        self.canvas.tag_bind(tag, "<ButtonPress-3>", self.on_button3_press)

    def core_on_button_release(self, event):
        """End drag of a core cell"""

        # Find the pad associated with the tag and update its position information
        tag = self.event_data["tag"]

        try:
            corecell = next(item for item in self.coregroup if item["name"] == tag)
        except Exception:
            self.print("Error: cell " + item["name"] + " is not in coregroup!")
        else:
            # Modify its position values
            corex = corecell["x"]
            corey = corecell["y"]

            # Add distance from drag information (note that drag position in y
            # is negative relative to the chip dimensions)
            deltax = (self.event_data["x"] - self.event_data["x0"]) / self.scale
            deltay = (self.event_data["y"] - self.event_data["y0"]) / self.scale

            corecell["x"] = corex + deltax
            corecell["y"] = corey - deltay

            # rewrite the core DEF file
            self.write_core_def()

        # reset the drag information
        self.event_data["tag"] = None
        self.event_data["x"] = 0
        self.event_data["y"] = 0
        self.event_data["x0"] = 0
        self.event_data["y0"] = 0

    # Critically needed or else frame does not resize to scrollbars!
    def grid_configure(self, padx, pady):
        pass

    # Redraw the chip frame view in response to changes in the pad list
    def redraw_frame(self):
        self.canvas.coords("boundary", self.llx, self.urx, self.lly, self.ury)

    # Update the canvas scrollregion to incorporate all the interior windows
    def frame_configure(self, event):
        if self.do_gui == False:
            return
        self.update_idletasks()
        bbox = self.canvas.bbox("all")
        try:
            newbbox = (-15, -15, bbox[2] + 15, bbox[3] + 15)
        except Exception:
            pass
        else:
            self.canvas.configure(scrollregion=newbbox)

    # Fill the GUI entries with resident data
    def populate(self, level):
        if self.do_gui == False:
            return

        if level > 1:
            self.print("Recursion error:  Returning now.")
            return

        self.print("Populating floorplan view.")

        # Remove all entries from the canvas
        self.canvas.delete("all")

        allpads = (
            self.Npads
            + self.NEpad
            + self.Epads
            + self.SEpad
            + self.Spads
            + self.SWpad
            + self.Wpads
            + self.NWpad
        )

        notfoundlist = []

        for pad in allpads:
            if "x" not in pad:
                self.print(
                    "Error:  Pad " + pad["name"] + " has no placement information."
                )
                continue
            llx = int(pad["x"])
            lly = int(pad["y"])
            pado = pad["o"]
            try:
                padcell = next(
                    item for item in self.celldefs if item["name"] == pad["cell"]
                )
            except Exception:
                # This should not happen (failsafe)
                if pad["cell"] not in notfoundlist:
                    self.print(
                        "Warning:  there is no cell named "
                        + pad["cell"]
                        + " in the libraries."
                    )
                notfoundlist.append(pad["cell"])
                continue
            padw = padcell["width"]
            padh = padcell["height"]
            if "N" in pado or "S" in pado:
                urx = int(llx + padw)
                ury = int(lly + padh)
            else:
                urx = int(llx + padh)
                ury = int(lly + padw)

            pad["llx"] = llx
            pad["lly"] = lly
            pad["urx"] = urx
            pad["ury"] = ury

        # Note that the DEF coordinate system is reversed in Y from the canvas. . .

        height = self.ury - self.lly
        for pad in allpads:

            llx = pad["llx"]
            lly = height - pad["lly"]
            urx = pad["urx"]
            ury = height - pad["ury"]

            tag_id = pad["name"]
            if "subclass" in pad:
                if pad["subclass"] == "POWER":
                    pad_color = "orange2"
                elif pad["subclass"] == "INOUT":
                    pad_color = "yellow"
                elif pad["subclass"] == "OUTPUT":
                    pad_color = "powder blue"
                elif pad["subclass"] == "INPUT":
                    pad_color = "goldenrod1"
                elif pad["subclass"] == "SPACER":
                    pad_color = "green yellow"
                elif pad["class"] == "ENDCAP":
                    pad_color = "green yellow"
                elif pad["subclass"] == "" or pad["class"] == ";":
                    pad_color = "khaki1"
                else:
                    self.print("Unhandled pad class " + pad["class"])
                    pad_color = "gray"
            else:
                pad_color = "gray"

            sllx = self.scale * llx
            slly = self.scale * lly
            surx = self.scale * urx
            sury = self.scale * ury

            self.canvas.create_rectangle(
                (sllx, slly), (surx, sury), fill=pad_color, tags=[tag_id]
            )
            cx = (sllx + surx) / 2
            cy = (slly + sury) / 2

            s = 10 if pad["width"] >= 10 else pad["width"]
            if pad["height"] < s:
                s = pad["height"]

            # Create an indicator line at the bottom left corner of the cell
            if pad["o"] == "N":
                allx = sllx
                ally = slly - s
                aurx = sllx + s
                aury = slly
            elif pad["o"] == "E":
                allx = sllx
                ally = sury + s
                aurx = sllx + s
                aury = sury
            elif pad["o"] == "S":
                allx = surx
                ally = sury + s
                aurx = surx - s
                aury = sury
            elif pad["o"] == "W":
                allx = surx
                ally = slly - s
                aurx = surx - s
                aury = slly
            elif pad["o"] == "FN":
                allx = surx
                ally = slly - s
                aurx = surx - s
                aury = slly
            elif pad["o"] == "FE":
                allx = surx
                ally = sury + s
                aurx = surx - s
                aury = sury
            elif pad["o"] == "FS":
                allx = sllx
                ally = sury + s
                aurx = sllx + s
                aury = sury
            elif pad["o"] == "FW":
                allx = sllx
                ally = slly - s
                aurx = sllx + s
                aury = slly
            self.canvas.create_line((allx, ally), (aurx, aury), tags=[tag_id])

            # Rotate text on top and bottom rows if the tkinter version allows it.
            if tkinter.TclVersion >= 8.6:
                if pad["o"] == "N" or pad["o"] == "S":
                    angle = 90
                else:
                    angle = 0
                self.canvas.create_text(
                    (cx, cy), text=pad["name"], angle=angle, tags=[tag_id]
                )
            else:
                self.canvas.create_text((cx, cy), text=pad["name"], tags=[tag_id])

            # Make the pad draggable
            self.add_draggable(tag_id)

        # Now add the core cells
        for cell in self.coregroup:
            if "x" not in cell:
                self.print(
                    "Error:  Core cell "
                    + cell["name"]
                    + " has no placement information."
                )
                continue
            # else:
            #     self.print('Diagnostic:  Creating object for core cell ' + cell['name'])
            llx = int(cell["x"])
            lly = int(cell["y"])
            cello = cell["o"]
            try:
                corecell = next(
                    item for item in self.coredefs if item["name"] == cell["cell"]
                )
            except Exception:
                # This should not happen (failsafe)
                if cell["cell"] not in notfoundlist:
                    self.print(
                        "Warning:  there is no cell named "
                        + cell["cell"]
                        + " in the libraries."
                    )
                notfoundlist.append(cell["cell"])
                continue
            cellw = corecell["width"]
            cellh = corecell["height"]
            if "N" in cello or "S" in cello:
                urx = int(llx + cellw)
                ury = int(lly + cellh)
            else:
                urx = int(llx + cellh)
                ury = int(lly + cellw)
                print(
                    "NOTE: cell "
                    + corecell["name"]
                    + " is rotated, w = "
                    + str(urx - llx)
                    + "; h = "
                    + str(ury - lly)
                )

            cell["llx"] = llx
            cell["lly"] = lly
            cell["urx"] = urx
            cell["ury"] = ury

        # Watch for out-of-window position in core cells.
        corellx = self.llx
        corelly = self.lly
        coreurx = self.urx
        coreury = self.ury

        for cell in self.coregroup:

            if "llx" not in cell:
                # Error message for this was handled above
                continue

            llx = cell["llx"]
            lly = height - cell["lly"]
            urx = cell["urx"]
            ury = height - cell["ury"]

            # Check for out-of-window cell
            if llx < corellx:
                corellx = llx
            if lly < corelly:
                corelly = lly
            if urx > coreurx:
                coreurx = urx
            if ury > coreury:
                coreury = ury

            tag_id = cell["name"]
            cell_color = "gray40"

            sllx = self.scale * llx
            slly = self.scale * lly
            surx = self.scale * urx
            sury = self.scale * ury

            self.canvas.create_rectangle(
                (sllx, slly), (surx, sury), fill=cell_color, tags=[tag_id]
            )
            cx = (sllx + surx) / 2
            cy = (slly + sury) / 2

            s = 10 if cell["width"] >= 10 else cell["width"]
            if cell["height"] < s:
                s = cell["height"]

            # Create an indicator line at the bottom left corner of the cell
            if cell["o"] == "N":
                allx = sllx
                ally = slly - s
                aurx = sllx + s
                aury = slly
            elif cell["o"] == "E":
                allx = sllx
                ally = sury + s
                aurx = sllx + s
                aury = sury
            elif cell["o"] == "S":
                allx = surx
                ally = sury + s
                aurx = surx - s
                aury = sury
            elif cell["o"] == "W":
                allx = surx
                ally = slly - s
                aurx = surx - s
                aury = slly
            elif cell["o"] == "FN":
                allx = surx
                ally = slly - s
                aurx = surx - s
                aury = slly
            elif cell["o"] == "FE":
                allx = surx
                ally = sury + s
                aurx = surx - s
                aury = sury
            elif cell["o"] == "FS":
                allx = sllx
                ally = sury + s
                aurx = sllx + s
                aury = sury
            elif cell["o"] == "FW":
                allx = sllx
                ally = slly - s
                aurx = sllx + s
                aury = slly
            self.canvas.create_line((allx, ally), (aurx, aury), tags=[tag_id])

            # self.print('Created entry for cell ' + cell['name'] + ' at {0:g}, {1:g}'.format(cx, cy))

            # Rotate text on top and bottom rows if the tkinter version allows it.
            if tkinter.TclVersion >= 8.6:
                if "N" in cell["o"] or "S" in cell["o"]:
                    angle = 90
                else:
                    angle = 0
                self.canvas.create_text(
                    (cx, cy), text=cell["name"], angle=angle, tags=[tag_id]
                )
            else:
                self.canvas.create_text((cx, cy), text=cell["name"], tags=[tag_id])

            # Make the core cell draggable
            self.add_core_draggable(tag_id)

        # Is there a boundary size defined?
        if self.urx > self.llx and self.ury > self.lly:
            self.create_boundary()

        # Did the core extend into negative X or Y?  If so, adjust all canvas
        # coordinates to fit in the window, or else objects cannot be reached
        # even by zooming out (since zooming is pinned on the top corner).

        offsetx = 0
        offsety = 0

        # NOTE:  Probably want to check if the core exceeds the inner
        # dimension of the pad ring, not the outer (to check and to do).

        if corellx < self.llx:
            offsetx = self.llx - corellx
        if corelly < self.lly:
            offsety = self.lly - corelly
        if offsetx > 0 or offsety > 0:
            self.canvas.move("all", offsetx, offsety)
            # An offset implies that the chip is core limited, and the
            # padframe requires additional space.  This can be accomplished
            # simply by running "Generate".  NOTE:  Since generate() calls
            # populate(), be VERY SURE that this does not infinitely recurse!
            self.generate(level)

    # Generate a DEF file of the core area

    def write_core_def(self):
        self.print('Writing core placementment information in DEF file "core.def".')

        mag_path = self.projectpath + "/mag"

        # The core cells must always clear the I/O pads on the left and
        # bottom (with the ad-hoc margin of self.margin).  If core cells have
        # been moved to the left or down past the padframe edge, then the
        # entire core needs to be repositioned.

        # To be done:  draw a boundary around the core, let the edges of that
        # boundary be draggable, and let the difference between the boundary
        # and the core area define the margin.

        if self.SWpad != []:
            corellx = self.SWpad[0]["x"] + self.SWpad[0]["width"] + self.margin
            corelly = self.SWpad[0]["y"] + self.SWpad[0]["height"] + self.margin
        else:
            corellx = self.Wpads[0]["x"] + self.Wpads[0]["height"] + self.margin
            corelly = self.Spads[0]["x"] + self.Spads[0]["height"] + self.margin

        offsetx = 0
        offsety = 0
        for corecell in self.coregroup:
            if corecell["x"] < corellx:
                if corellx - corecell["x"] > offsetx:
                    offsetx = corellx - corecell["x"]
            if corecell["y"] < corelly:
                if corelly - corecell["y"] > offsety:
                    offsety = corelly - corecell["y"]
        if offsetx > 0 or offsety > 0:
            for corecell in self.coregroup:
                corecell["x"] += offsetx
                corecell["y"] += offsety

        # Now write the core DEF file

        with open(mag_path + "/core.def", "w") as ofile:
            print("DESIGN CORE ;", file=ofile)
            print("UNITS DISTANCE MICRONS 1000 ;", file=ofile)
            print("COMPONENTS {0:d} ;".format(len(self.coregroup)), file=ofile)
            for corecell in self.coregroup:
                print(
                    "  - " + corecell["name"] + " " + corecell["cell"],
                    file=ofile,
                    end="",
                )
                print(
                    " + PLACED ( {0:d} {1:d} ) {2:s} ;".format(
                        int(corecell["x"] * 1000),
                        int(corecell["y"] * 1000),
                        corecell["o"],
                    ),
                    file=ofile,
                )
            print("END COMPONENTS", file=ofile)
            print("END DESIGN", file=ofile)

    # Create the chip boundary area

    def create_boundary(self):
        scale = self.scale
        llx = (self.llx - 10) * scale
        lly = (self.lly - 10) * scale
        urx = (self.urx + 10) * scale
        ury = (self.ury + 10) * scale

        pad_color = "plum1"
        tag_id = "boundary"
        self.canvas.create_rectangle(
            (llx, lly), (urx, ury), outline=pad_color, width=2, tags=[tag_id]
        )
        # Add text to the middle representing the chip and core areas
        cx = ((self.llx + self.urx) / 2) * scale
        cy = ((self.lly + self.ury) / 2) * scale
        width = self.urx - self.llx
        height = self.ury - self.lly
        areatext = "Chip dimensions (um): {0:g} x {1:g}".format(width, height)
        tag_id = "chiparea"
        self.canvas.create_text((cx, cy), text=areatext, tags=[tag_id])

    # Rotate orientation according to self.pad_rotation.

    def rotate_orientation(self, orient_in):
        orient_v = ["N", "E", "S", "W", "N", "E", "S", "W"]
        idxadd = int(self.pad_rotation / 90)
        idx = orient_v.index(orient_in)
        return orient_v[idx + idxadd]

    # Read a list of cell macros (name, size, class) from a LEF library

    def read_lef_macros(self, libpath, libname=None, libtype="iolib"):
        if libtype == "iolib":
            libtext = "I/O "
        elif libtype == "celllib":
            libtext = "core "
        else:
            libtext = ""

        macros = []

        if libname:
            if os.path.splitext(libname)[1] == "":
                libname += ".lef"
            leffiles = glob.glob(libpath + "/" + libname)
        else:
            leffiles = glob.glob(libpath + "/*.lef")
        if leffiles == []:
            if libname:
                self.print("WARNING:  No file " + libpath + "/" + libname + ".lef")
            else:
                self.print("WARNING:  No files " + libpath + "/*.lef")
        for leffile in leffiles:
            libpath = os.path.split(leffile)[0]
            libname = os.path.split(libpath)[1]
            self.print("Reading LEF " + libtext + "library " + leffile)
            with open(leffile, "r") as ifile:
                ilines = ifile.read().splitlines()
                in_macro = False
                for iline in ilines:
                    iparse = iline.split()
                    if iparse == []:
                        continue
                    elif iparse[0] == "MACRO":
                        in_macro = True
                        newmacro = {}
                        newmacro["name"] = iparse[1]
                        newmacro[libtype] = leffile
                        macros.append(newmacro)
                    elif in_macro:
                        if iparse[0] == "END":
                            if len(iparse) > 1 and iparse[1] == newmacro["name"]:
                                in_macro = False
                        elif iparse[0] == "CLASS":
                            newmacro["class"] = iparse[1]
                            if len(iparse) > 2:
                                newmacro["subclass"] = iparse[2]

                                # Use the 'ENDCAP' class to identify pad rotations
                                # other than BOTTOMLEFT.  This is somewhat ad-hoc
                                # depending on the foundry;  may not be generally
                                # applicable.

                                if newmacro["class"] == "ENDCAP":
                                    if newmacro["subclass"] == "TOPLEFT":
                                        self.pad_rotation = 90
                                    elif newmacro["subclass"] == "TOPRIGHT":
                                        self.pad_rotation = 180
                                    elif newmacro["subclass"] == "BOTTOMRIGHT":
                                        self.pad_rotation = 270
                            else:
                                newmacro["subclass"] = None
                        elif iparse[0] == "SIZE":
                            newmacro["width"] = float(iparse[1])
                            newmacro["height"] = float(iparse[3])
                        elif iparse[0] == "ORIGIN":
                            newmacro["x"] = float(iparse[1])
                            newmacro["y"] = float(iparse[2])
        return macros

    # Read a list of cell names from a verilog file
    # If filename is relative, then check in the same directory as the verilog
    # top-level netlist (vlogpath) and in the subdirectory 'source/' of the top-
    # level directory.  Also check in the ~/design/ip/ directory.  These are
    # common include paths for the simulation.

    def read_verilog_lib(self, incpath, vlogpath):
        iocells = []
        if not os.path.isfile(incpath) and incpath[0] != "/":
            locincpath = vlogpath + "/" + incpath
            if not os.path.isfile(locincpath):
                locincpath = vlogpath + "/source/" + incpath
            if not os.path.isfile(locincpath):
                projectpath = os.path.split(vlogpath)[0]
                designpath = os.path.split(projectpath)[0]
                locincpath = designpath + "/ip/" + incpath
        else:
            locincpath = incpath

        if not os.path.isfile(locincpath):
            self.print("File " + incpath + " not found (at " + locincpath + ")!")
        else:
            self.print("Reading verilog library " + locincpath)
            with open(locincpath, "r") as ifile:
                ilines = ifile.read().splitlines()
                for iline in ilines:
                    iparse = re.split("[\t ()]", iline)
                    while "" in iparse:
                        iparse.remove("")
                    if iparse == []:
                        continue
                    elif iparse[0] == "module":
                        iocells.append(iparse[1])
        return iocells

    # Generate a LEF abstract view from a magic layout.  If "outpath" is not
    # "None", then write output to outputpath (this is required if the input
    # file is in a read-only directory).

    def write_lef_file(self, magfile, outpath=None):
        mag_path = os.path.split(magfile)[0]
        magfullname = os.path.split(magfile)[1]
        module = os.path.splitext(magfullname)[0]

        if outpath:
            write_path = outpath
        else:
            write_path = mag_path

        self.print("Generating LEF view from layout for module " + module)

        with open(write_path + "/pfg_write_lef.tcl", "w") as ofile:
            print("drc off", file=ofile)
            print("box 0 0 0 0", file=ofile)
            # NOTE:  Using "-force" option in case an IP with a different but
            # compatible tech is used (e.g., EFHX035A IP inside EFXH035C).  This
            # is not checked for legality!
            if outpath:
                print("load " + magfile + " -force", file=ofile)
            else:
                print("load " + module + " -force", file=ofile)
            print("lef write", file=ofile)
            print("quit", file=ofile)

        magicexec = self.magic_path if self.magic_path else "magic"
        mproc = subprocess.Popen(
            [magicexec, "-dnull", "-noconsole", "pfg_write_lef.tcl"],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            cwd=write_path,
            universal_newlines=True,
        )

        self.watch(mproc)
        os.remove(write_path + "/pfg_write_lef.tcl")

    # Watch a running process, polling for output and updating the GUI message
    # window as output arrives.  Return only when the process has exited.
    # Note that this process cannot handle stdin(), so any input to the process
    # must be passed from a file.

    def watch(self, process):
        if process == None:
            return

        while True:
            status = process.poll()
            if status != None:
                try:
                    outputpair = process.communicate(timeout=1)
                except ValueError:
                    self.print("Process forced stop, status " + str(status))
                else:
                    for line in outputpair[0].splitlines():
                        self.print(line)
                    for line in outputpair[1].splitlines():
                        self.print(line, file=sys.stderr)
                break
            else:
                sresult = select.select([process.stdout, process.stderr], [], [], 0)[0]
                if process.stdout in sresult:
                    outputline = process.stdout.readline().strip()
                    self.print(outputline)
                elif process.stderr in sresult:
                    outputline = process.stderr.readline().strip()
                    self.print(outputline, file=sys.stderr)
                else:
                    self.update_idletasks()

    # Reimport the pad list by reading the top-level verilog netlist.  Determine
    # what pads are listed in the file, and check against the existing pad list.

    # The verilog/ directory should have a .v file containing a module of the
    # same name as self.project (ip-name).  The .v filename should have the
    # same name as well (but not necessarily).  To do:  Handle import of
    # projects having a top-level schematic instead of a verilog netlist.

    def vlogimport(self):
        self.print("Importing verilog sources.")

        # First find the process PDK name for this project.  Read the nodeinfo.json
        # file and find the list of I/O cell libraries.

        techpath = self.techpath if self.techpath else self.projectpath
        if os.path.exists(techpath + "/.config"):
            config_dir = "/.config"
        else:
            config_dir = "/.ef-config"
            if os.path.exists(techpath + config_dir):
                self.ef_format = True

        pdkpath = (
            self.techpath
            if self.techpath
            else os.path.realpath(self.projectpath + config_dir + "/techdir")
        )
        nodeinfopath = pdkpath + config_dir + "/nodeinfo.json"
        ioleflist = []
        if os.path.exists(nodeinfopath):
            self.print("Reading known I/O cell libraries from " + nodeinfopath)
            with open(nodeinfopath, "r") as ifile:
                itop = json.load(ifile)
                if "iocells" in itop:
                    ioleflist = []
                    for iolib in itop["iocells"]:
                        if "/" in iolib:
                            # Entries <lib>/<cell> refer to specific files
                            libcell = iolib.split("/")
                            if self.ef_format:
                                iolibpath = pdkpath + "/libs.ref/lef/" + libcell[0]
                            else:
                                iolibpath = (
                                    pdkpath + "/libs.ref/" + libcell[0] + "/lef/"
                                )
                            ioleflist.extend(
                                glob.glob(iolibpath + "/" + libcell[1] + ".lef")
                            )
                        else:
                            # All other entries refer to everything in the directory.
                            if self.ef_format:
                                iolibpath = pdkpath + "/libs.ref/lef/" + iolib
                            else:
                                iolibpath = pdkpath + "/libs.ref/" + iolib + "/lef/"
                            print(iolibpath)
                            ioleflist.extend(glob.glob(iolibpath + "/*.lef"))
        else:
            # Diagnostic
            print("Cannot read PDK information file " + nodeinfopath)

        # Fallback behavior:  List everything in libs.ref/lef/ beginning with "IO"
        if len(ioleflist) == 0:
            if self.ef_format:
                ioleflist = glob.glob(pdkpath + "/libs.ref/lef/IO*/*.lef")
            else:
                ioleflist = glob.glob(pdkpath + "/libs.ref/IO*/lef/*.lef")

        if len(ioleflist) == 0:
            self.print("Cannot find any I/O cell libraries for this technology")
            return

        # Read the LEF libraries to get a list of all available cells.  Keep
        # this list of cells in "celldefs".

        celldefs = []
        ioliblist = []
        ioleflibs = []
        for iolib in ioleflist:
            iolibpath = os.path.split(iolib)[0]
            iolibfile = os.path.split(iolib)[1]
            ioliblist.append(os.path.split(iolibpath)[1])
            celldefs.extend(self.read_lef_macros(iolibpath, iolibfile, "iolib"))

        verilogcells = []
        newpadlist = []
        coredefs = []
        corecells = []
        corecelllist = []
        lefprocessed = []

        busrex = re.compile(".*\[[ \t]*([0-9]+)[ \t]*:[ \t]*([0-9]+)[ \t]*\]")

        vlogpath = self.projectpath + "/verilog"
        vlogfile = vlogpath + "/" + self.project + ".v"
        if os.path.isfile(vlogfile):
            with open(vlogfile, "r") as ifile:
                vloglines = ifile.read().splitlines()
                for vlogline in vloglines:
                    vlogparse = re.split("[\t ()]", vlogline)
                    while "" in vlogparse:
                        vlogparse.remove("")
                    if vlogparse == []:
                        continue
                    elif vlogparse[0] == "//":
                        continue
                    elif vlogparse[0] == "`include":
                        incpath = vlogparse[1].strip('"')
                        libpath = os.path.split(incpath)[0]
                        libname = os.path.split(libpath)[1]
                        libfile = os.path.split(incpath)[1]

                        # Read the verilog library for module names to match
                        # against macro names in celldefs.
                        modulelist = self.read_verilog_lib(incpath, vlogpath)
                        matching = list(
                            item for item in celldefs if item["name"] in modulelist
                        )
                        for imatch in matching:
                            verilogcells.append(imatch["name"])
                            leffile = imatch["iolib"]
                            if leffile not in ioleflibs:
                                ioleflibs.append(leffile)

                        # Read a corresponding LEF file entry for non-I/O macros, if one
                        # can be found (this handles files in the PDK).
                        if len(matching) == 0:
                            if libname != "":
                                # (NOTE:  Assumes full path starting with '/')
                                lefpath = libpath.replace("verilog", "lef")
                                lefname = libfile.replace(".v", ".lef")
                                if not os.path.exists(lefpath + "/" + lefname):
                                    leffiles = glob.glob(lefpath + "/*.lef")
                                else:
                                    leffiles = [lefpath + "/" + lefname]

                                for leffile in leffiles:
                                    if leffile in ioleflibs:
                                        continue
                                    elif leffile in lefprocessed:
                                        continue
                                    else:
                                        lefprocessed.append(leffile)

                                    lefname = os.path.split(leffile)[1]

                                    newcoredefs = self.read_lef_macros(
                                        lefpath, lefname, "celllib"
                                    )
                                    coredefs.extend(newcoredefs)
                                    corecells.extend(
                                        list(item["name"] for item in newcoredefs)
                                    )

                                if leffiles == []:
                                    maglefname = libfile.replace(".v", ".mag")

                                    # Handle PDK files with a maglef/ view but no LEF file.
                                    maglefpath = libpath.replace("verilog", "maglef")
                                    if not os.path.exists(
                                        maglefpath + "/" + maglefname
                                    ):
                                        magleffiles = glob.glob(maglefpath + "/*.mag")
                                    else:
                                        magleffiles = [maglefpath + "/" + maglefname]

                                    if magleffiles == []:
                                        # Handle user ip/ files with a maglef/ view but
                                        # no LEF file.
                                        maglefpath = libpath.replace(
                                            "verilog", "maglef"
                                        )
                                        designpath = os.path.split(self.projectpath)[0]
                                        maglefpath = designpath + "/ip/" + maglefpath

                                        if not os.path.exists(
                                            maglefpath + "/" + maglefname
                                        ):
                                            magleffiles = glob.glob(
                                                maglefpath + "/*.mag"
                                            )
                                        else:
                                            magleffiles = [
                                                maglefpath + "/" + maglefname
                                            ]

                                    for magleffile in magleffiles:
                                        # Generate LEF file.  Since PDK and ip/ entries
                                        # are not writeable, write into the project mag/
                                        # directory.
                                        magpath = self.projectpath + "/mag"
                                        magname = os.path.split(magleffile)[1]
                                        magroot = os.path.splitext(magname)[0]
                                        leffile = magpath + "/" + magroot + ".lef"
                                        if not os.path.isfile(leffile):
                                            self.write_lef_file(magleffile, magpath)

                                        if leffile in ioleflibs:
                                            continue
                                        elif leffile in lefprocessed:
                                            continue
                                        else:
                                            lefprocessed.append(leffile)

                                        lefname = os.path.split(leffile)[1]

                                        newcoredefs = self.read_lef_macros(
                                            magpath, lefname, "celllib"
                                        )
                                        coredefs.extend(newcoredefs)
                                        corecells.extend(
                                            list(item["name"] for item in newcoredefs)
                                        )
                                        # LEF files generated on-the-fly are not needed
                                        # after they have been parsed.
                                        # os.remove(leffile)

                            # Check if all modules in modulelist are represented by
                            # corresponding LEF macros.  If not, then go looking for a LEF
                            # file in the mag/ or maglef/ directory.  Then, go looking for
                            # a .mag file in the mag/ or maglef/ directory, and build a
                            # LEF macro from it.

                            matching = list(
                                item["name"]
                                for item in coredefs
                                if item["name"] in modulelist
                            )
                            for module in modulelist:
                                if module not in matching:
                                    lefpath = self.projectpath + "/lef"
                                    magpath = self.projectpath + "/mag"
                                    maglefpath = self.projectpath + "/mag"
                                    lefname = libfile.replace(".v", ".lef")

                                    # If the verilog file root name is not the same as
                                    # the module name, then make a quick check for a
                                    # LEF file with the same root name as the verilog.
                                    # That indicates that the module does not exist in
                                    # the LEF file, probably because it is a primary
                                    # module that does not correspond to any layout.

                                    leffile = lefpath + "/" + lefname
                                    if os.path.exists(leffile):
                                        self.print(
                                            "Diagnostic: module "
                                            + module
                                            + " is not in "
                                            + leffile
                                            + " (probably a primary module)"
                                        )
                                        continue

                                    leffile = magpath + "/" + lefname
                                    istemp = False
                                    if not os.path.exists(leffile):
                                        magname = libfile.replace(".v", ".mag")
                                        magfile = magpath + "/" + magname
                                        if os.path.exists(magfile):
                                            self.print(
                                                "Diagnostic: Found a .mag file for "
                                                + module
                                                + " in "
                                                + magfile
                                            )
                                            self.write_lef_file(magfile)
                                            istemp = True
                                        else:
                                            magleffile = maglefpath + "/" + lefname
                                            if not os.path.exists(magleffile):
                                                self.print(
                                                    "Diagnostic: (module "
                                                    + module
                                                    + ") has no LEF file "
                                                    + leffile
                                                    + " or "
                                                    + magleffile
                                                )
                                                magleffile = maglefpath + "/" + magname
                                                if os.path.exists(magleffile):
                                                    self.print(
                                                        "Diagnostic: Found a .mag file for "
                                                        + module
                                                        + " in "
                                                        + magleffile
                                                    )
                                                    if os.access(maglefpath, os.W_OK):
                                                        self.write_lef_file(magleffile)
                                                        leffile = magleffile
                                                        istemp = True
                                                    else:
                                                        self.write_lef_file(
                                                            magleffile, magpath
                                                        )
                                                else:
                                                    self.print(
                                                        "Did not find a file " + magfile
                                                    )
                                                    # self.print('Warning: module ' + module + ' has no LEF or .mag views')
                                                    pass
                                            else:
                                                self.print(
                                                    "Diagnostic: Found a LEF file for "
                                                    + module
                                                    + " in "
                                                    + magleffile
                                                )
                                                leffile = magleffile
                                    else:
                                        self.print(
                                            "Diagnostic: Found a LEF file for "
                                            + module
                                            + " in "
                                            + leffile
                                        )

                                    if os.path.exists(leffile):
                                        if leffile in lefprocessed:
                                            continue
                                        else:
                                            lefprocessed.append(leffile)

                                        newcoredefs = self.read_lef_macros(
                                            magpath, lefname, "celllib"
                                        )
                                        # The LEF file generated on-the-fly is not needed
                                        # any more after parsing the macro(s).
                                        # if istemp:
                                        #     os.remove(leffile)
                                        coredefs.extend(newcoredefs)
                                        corecells.extend(
                                            list(item["name"] for item in newcoredefs)
                                        )
                                    else:
                                        # self.print('Failed to find a LEF view for module ' + module)
                                        pass

                    elif vlogparse[0] in verilogcells:
                        # Check for array of pads
                        bushigh = buslow = -1
                        if len(vlogparse) >= 3:
                            bmatch = busrex.match(vlogline)
                            if bmatch:
                                bushigh = int(bmatch.group(1))
                                buslow = int(bmatch.group(2))

                        for i in range(buslow, bushigh + 1):
                            newpad = {}
                            if i >= 0:
                                newpad["name"] = vlogparse[1] + "[" + str(i) + "]"
                            else:
                                newpad["name"] = vlogparse[1]
                            # hack
                            newpad["name"] = newpad["name"].replace("\\", "")
                            newpad["cell"] = vlogparse[0]
                            padcell = next(
                                item
                                for item in celldefs
                                if item["name"] == vlogparse[0]
                            )
                            newpad["iolib"] = padcell["iolib"]
                            newpad["class"] = padcell["class"]
                            newpad["subclass"] = padcell["subclass"]
                            newpad["width"] = padcell["width"]
                            newpad["height"] = padcell["height"]
                            newpadlist.append(newpad)

                    elif vlogparse[0] in corecells:
                        # Check for array of cells
                        bushigh = buslow = -1
                        if len(vlogparse) >= 3:
                            bmatch = busrex.match(vlogline)
                            if bmatch:
                                bushigh = int(bmatch.group(1))
                                buslow = int(bmatch.group(2))

                        for i in range(buslow, bushigh + 1):
                            newcorecell = {}
                            if i >= 0:
                                newcorecell["name"] = vlogparse[1] + "[" + str(i) + "]"
                            else:
                                newcorecell["name"] = vlogparse[1]
                            newcorecell["cell"] = vlogparse[0]
                            corecell = next(
                                item
                                for item in coredefs
                                if item["name"] == vlogparse[0]
                            )
                            newcorecell["celllib"] = corecell["celllib"]
                            newcorecell["class"] = corecell["class"]
                            newcorecell["subclass"] = corecell["subclass"]
                            newcorecell["width"] = corecell["width"]
                            newcorecell["height"] = corecell["height"]
                            corecelllist.append(newcorecell)

        self.print("")
        self.print("Source file information:")
        self.print("Source filename: " + vlogfile)
        self.print("Number of I/O libraries is " + str(len(ioleflibs)))
        self.print(
            "Number of library cells in I/O libraries used: " + str(len(verilogcells))
        )
        self.print("Number of core celldefs is " + str(len(coredefs)))
        self.print("")
        self.print("Number of I/O cells in design: " + str(len(newpadlist)))
        self.print("Number of core cells in design: " + str(len(corecelllist)))
        self.print("")

        # Save the results
        self.celldefs = celldefs
        self.coredefs = coredefs
        self.vlogpads = newpadlist
        self.corecells = corecelllist
        self.ioleflibs = ioleflibs

    # Check self.vlogpads, which was created during import (above) against
    # self.(N,S,W,E)pads, which was read from the DEF file (if there was one)
    # Also check self.corecells, which was created during import against
    # self.coregroup, which was read from the DEF file.

    def resolve(self):
        self.print("Resolve differences in verilog and LEF views.")

        samepads = []
        addedpads = []
        removedpads = []

        # (1) Create list of entries that are in both self.vlogpads and self.()pads
        # (2) Create list of entries that are in self.vlogpads but not in self.()pads

        allpads = (
            self.Npads
            + self.NEpad
            + self.Epads
            + self.SEpad
            + self.Spads
            + self.SWpad
            + self.Wpads
            + self.NWpad
        )

        for pad in self.vlogpads:
            newpadname = pad["name"]
            try:
                lpad = next(item for item in allpads if item["name"] == newpadname)
            except Exception:
                addedpads.append(pad)
            else:
                samepads.append(lpad)

        # (3) Create list of entries that are in allpads but not in self.vlogpads
        for pad in allpads:
            newpadname = pad["name"]
            try:
                lpad = next(
                    item for item in self.vlogpads if item["name"] == newpadname
                )
            except Exception:
                removedpads.append(pad)

        # Print results
        if len(addedpads) > 0:
            self.print("Added pads:")
            for pad in addedpads:
                self.print(pad["name"] + " (" + pad["cell"] + ")")

        if len(removedpads) > 0:
            plist = []
            nspacers = 0
            for pad in removedpads:
                if "subclass" in pad:
                    if pad["subclass"] != "SPACER":
                        plist.append(pad)
                    else:
                        nspacers += 1

            if nspacers > 0:
                self.print(str(nspacers) + " spacer cells ignored.")
            if len(plist) > 0:
                self.print("Removed pads:")
                for pad in removedpads:
                    self.print(pad["name"] + " (" + pad["cell"] + ")")

        if len(addedpads) + len(removedpads) == 0:
            self.print("Pad list has not changed.")

        # Remove all cells from the "removed" list, with comment

        allpads = [
            self.Npads,
            self.NEpad,
            self.Epads,
            self.SEpad,
            self.Spads,
            self.SWpad,
            self.Wpads,
            self.NWpad,
        ]

        for pad in removedpads:
            rname = pad["name"]
            for row in allpads:
                try:
                    rpad = next(item for item in row if item["name"] == rname)
                except Exception:
                    rpad = None
                else:
                    row.remove(rpad)

        # Now the verilog file has no placement information, so the old padlist
        # entries (if they exist) are preferred.  Add to these the new padlist
        # entries

        # First pass for unassigned pads:  Use of "CLASS ENDCAP" is preferred
        # for identifying corner pads.  Otherwise, if 'CORNER' or 'corner' is
        # in the pad name, then make sure there is one per row in the first
        # position.  This is not foolproof and depends on the cell library
        # using the text 'corner' in the name of the corner cell.  However,
        # if the ad hoc methods fail, the user can still manually move the
        # corner cells to the right place (to be done:  Identify if library
        # uses ENDCAP designation for corner cells up front;  don't go
        # looking for 'corner' text if the cells are easily identifiable by
        # LEF class).

        for pad in addedpads[:]:
            iscorner = False
            if "class" in pad and pad["class"] == "ENDCAP":
                iscorner = True
            elif "CORNER" in pad["cell"].upper():
                iscorner = True

            if iscorner:
                if self.NWpad == []:
                    self.NWpad.append(pad)
                    pad["o"] = "E"
                    addedpads.remove(pad)
                elif self.NEpad == []:
                    self.NEpad.append(pad)
                    pad["o"] = "S"
                    addedpads.remove(pad)
                elif self.SEpad == []:
                    self.SEpad.append(pad)
                    pad["o"] = "W"
                    addedpads.remove(pad)
                elif self.SWpad == []:
                    self.SWpad.append(pad)
                    pad["o"] = "N"
                    addedpads.remove(pad)

        numN = len(self.Npads)
        numS = len(self.Spads)
        numE = len(self.Epads)
        numW = len(self.Wpads)

        minnum = min(numN, numS, numE, numW)
        minnum = max(minnum, int(len(addedpads) / 4))

        # Add pads in clockwise order.  Note that S and E pads are defined counterclockwise
        for pad in addedpads:
            if numN < minnum:
                self.Npads.append(pad)
                numN += 1
                pad["o"] = "S"
                self.print("Adding pad " + pad["name"] + " to Npads")
            elif numE < minnum:
                self.Epads.insert(0, pad)
                numE += 1
                pad["o"] = "W"
                self.print("Adding pad " + pad["name"] + " to Epads")
            elif numS < minnum:
                self.Spads.insert(0, pad)
                numS += 1
                pad["o"] = "N"
                self.print("Adding pad " + pad["name"] + " to Spads")
            # elif numW < minnum:
            else:
                self.Wpads.append(pad)
                numW += 1
                pad["o"] = "E"
                self.print("Adding pad " + pad["name"] + " to Wpads")

            minnum = min(numN, numS, numE, numW)
            minnum = max(minnum, int(len(addedpads) / 4))

        # Make sure all pads have included information from the cell definition

        allpads = (
            self.Npads
            + self.NEpad
            + self.Epads
            + self.SEpad
            + self.Spads
            + self.SWpad
            + self.Wpads
            + self.NWpad
        )

        for pad in allpads:
            if "width" not in pad:
                try:
                    celldef = next(
                        item for item in celldefs if item["name"] == pad["cell"]
                    )
                except Exception:
                    self.print("Cell " + pad["cell"] + " not found!")
                else:
                    pad["width"] = celldef["width"]
                    pad["height"] = celldef["height"]
                    pad["class"] = celldef["class"]
                    pad["subclass"] = celldef["subclass"]

        # Now treat the core cells in the same way (resolve list parsed from verilog
        # against the list parsed from DEF)

        # self.print('Diagnostic: ')
        # self.print('self.corecells = ' + str(self.corecells))
        # self.print('self.coregroup = ' + str(self.coregroup))

        samecore = []
        addedcore = []
        removedcore = []

        # (1) Create list of entries that are in both self.corecells and self.coregroup
        # (2) Create list of entries that are in self.corecells but not in self.coregroup

        for cell in self.corecells:
            newcellname = cell["name"]
            try:
                lcore = next(
                    item for item in self.coregroup if item["name"] == newcellname
                )
            except Exception:
                addedcore.append(cell)
            else:
                samecore.append(lcore)

        # (3) Create list of entries that are in self.coregroup but not in self.corecells
        for cell in self.coregroup:
            newcellname = cell["name"]
            try:
                lcore = next(
                    item for item in self.corecells if item["name"] == newcellname
                )
            except Exception:
                removedcore.append(cell)

        # Print results
        if len(addedcore) > 0:
            self.print("Added core cells:")
            for cell in addedcore:
                self.print(cell["name"] + " (" + cell["cell"] + ")")

        if len(removedcore) > 0:
            clist = []
            for cell in removedcore:
                clist.append(cell)

            if len(clist) > 0:
                self.print("Removed core cells:")
                for cell in removedcore:
                    self.print(cell["name"] + " (" + cell["cell"] + ")")

        if len(addedcore) + len(removedcore) == 0:
            self.print("Core cell list has not changed.")

        # Remove all cells from the "removed" list

        coregroup = self.coregroup
        for cell in removedcore:
            rname = cell["name"]
            try:
                rcell = next(item for item in coregroup if item["name"] == rname)
            except Exception:
                rcell = None
            else:
                coregroup.remove(rcell)

        # Add all cells from the "added" list to coregroup

        for cell in addedcore:
            rname = cell["name"]
            try:
                rcell = next(item for item in coregroup if item["name"] == rname)
            except Exception:
                coregroup.append(cell)
                if not "o" in cell:
                    cell["o"] = "N"
                if not "x" in cell:
                    if len(self.Wpads) > 0:
                        pad = self.Wpads[0]
                        padx = pad["x"] if "x" in pad else 0
                        cell["x"] = padx + pad["height"] + self.margin
                    else:
                        cell["x"] = self.margin
                if not "y" in cell:
                    if len(self.Spads) > 0:
                        pad = self.Spads[0]
                        pady = pad["y"] if "y" in pad else 0
                        cell["y"] = pady + pad["height"] + self.margin
                    else:
                        cell["y"] = self.margin
            else:
                rcell = None

        # Make sure all core cells have included information from the cell definition

        for cell in coregroup:
            if "width" not in cell:
                try:
                    coredef = next(
                        item for item in coredefs if item["name"] == cell["cell"]
                    )
                except Exception:
                    self.print("Cell " + cell["cell"] + " not found!")
                else:
                    cell["width"] = coredef["width"]
                    cell["height"] = coredef["height"]
                    cell["class"] = coredef["class"]
                    cell["subclass"] = coredef["subclass"]

    # Generate a new padframe by writing the configuration file, running
    # padring, reading back the DEF file, and (re)poplulating the workspace

    def generate(self, level):
        self.print("Generate legal padframe using padring")

        # Write out the configuration file
        self.writeconfig()
        # Run the padring app
        self.runpadring()
        # Rotate pads in the output if pad orientations are different from
        # padring's expectations
        self.rotate_pads_in_def()
        # Read the placement information back from the generated DEF file
        self.readplacement()
        # Resolve differences (e.g., remove spacers)
        self.resolve()
        # Recreate and draw the padframe view on the canvas
        self.populate(level + 1)
        self.frame_configure(None)

    # Write a new configuration file

    def writeconfig(self):
        mag_path = self.projectpath + "/mag"

        self.print("Writing padring configuration file.")

        # Determine cell width and height from pad sizes.
        # NOTE:  This compresses the chip to the minimum dimensions
        # allowed by the arrangement of pads.  Use a "core" block to
        # force the area larger than minimum (not yet implemented)

        topwidth = 0
        for pad in self.Npads:
            if "width" not in pad:
                self.print("No width: pad = " + str(pad))
            topwidth += pad["width"]

        # Add in the corner cells
        if self.NWpad != []:
            topwidth += self.NWpad[0]["height"]
        if self.NEpad != []:
            topwidth += self.NEpad[0]["width"]

        botwidth = 0
        for pad in self.Spads:
            botwidth += pad["width"]

        # Add in the corner cells
        if self.SWpad != []:
            botwidth += self.SWpad[0]["width"]
        if self.SEpad != []:
            botwidth += self.SEpad[0]["height"]

        width = max(botwidth, topwidth)

        # if width < self.urx - self.llx:
        #     width = self.urx - self.llx

        leftheight = 0
        for pad in self.Wpads:
            leftheight += pad["width"]

        # Add in the corner cells
        if self.NWpad != []:
            leftheight += self.NWpad[0]["height"]
        if self.SWpad != []:
            leftheight += self.SWpad[0]["width"]

        rightheight = 0
        for pad in self.Epads:
            rightheight += pad["width"]

        # Add in the corner cells
        if self.NEpad != []:
            rightheight += self.NEpad[0]["width"]
        if self.SEpad != []:
            rightheight += self.SEpad[0]["height"]

        height = max(leftheight, rightheight)

        # Check the dimensions of the core cells.  If they exceed the available
        # padframe area, then expand the padframe to accomodate the core.

        corellx = coreurx = (self.llx + self.urx) / 2
        corelly = coreury = (self.lly + self.ury) / 2

        for corecell in self.coregroup:
            corient = corecell["o"]
            if "S" in corient or "N" in corient:
                cwidth = corecell["width"]
                cheight = corecell["height"]
            else:
                cwidth = corecell["height"]
                cheight = corecell["width"]

            if corecell["x"] < corellx:
                corellx = corecell["x"]
            if corecell["x"] + cwidth > coreurx:
                coreurx = corecell["x"] + cwidth
            if corecell["y"] < corelly:
                corelly = corecell["y"]
            if corecell["y"] + cheight > coreury:
                coreury = corecell["y"] + cheight

        coreheight = coreury - corelly
        corewidth = coreurx - corellx

        # Ignoring the possibility of overlaps with nonstandard-sized pads,
        # assuming that the user has visually separated them.  Only check
        # the core bounds against the standard padframe inside edge.

        if self.SWpad != [] and self.SEpad != []:
            if corewidth > width - self.SWpad[0]["width"] - self.SEpad[0]["width"]:
                width = corewidth + self.SWpad[0]["width"] + self.SEpad[0]["width"]
        if self.NWpad != [] and self.SWpad != []:
            if coreheight > height - self.NWpad[0]["height"] - self.SWpad[0]["height"]:
                height = coreheight + self.NWpad[0]["height"] + self.SWpad[0]["height"]

        # Core cells are given a margin of self.margin from the pad inside edge, so the
        # core area passed to the padring app is 2 * self.margin larger than the
        # measured size of the core area.
        width += 2 * self.margin
        height += 2 * self.margin

        # SCALE UP
        # width *= 1.4
        # height *= 1.4

        if self.keep_cfg == False or not os.path.exists(mag_path + "/padframe.cfg"):

            if os.path.exists(mag_path + "/padframe.cfg"):
                # Copy the previous padframe.cfg file to a backup.  In case something
                # goes badly wrong, this should be the only file overwritten, and can
                # be recovered from the backup.
                shutil.copy(mag_path + "/padframe.cfg", mag_path + "/padframe.cfg.bak")

            with open(mag_path + "/padframe.cfg", "w") as ofile:
                print(
                    "AREA " + str(int(width)) + " " + str(int(height)) + " ;",
                    file=ofile,
                )
                print("", file=ofile)
                for pad in self.NEpad:
                    print(
                        "CORNER " + pad["name"] + " SW " + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.SEpad:
                    print(
                        "CORNER " + pad["name"] + " NW " + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.SWpad:
                    print(
                        "CORNER " + pad["name"] + " NE " + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.NWpad:
                    print(
                        "CORNER " + pad["name"] + " SE " + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.Npads:
                    flip = "F " if "F" in pad["o"] else ""
                    print(
                        "PAD " + pad["name"] + " N " + flip + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.Epads:
                    flip = "F " if "F" in pad["o"] else ""
                    print(
                        "PAD " + pad["name"] + " E " + flip + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.Spads:
                    flip = "F " if "F" in pad["o"] else ""
                    print(
                        "PAD " + pad["name"] + " S " + flip + pad["cell"] + " ;",
                        file=ofile,
                    )
                for pad in self.Wpads:
                    flip = "F " if "F" in pad["o"] else ""
                    print(
                        "PAD " + pad["name"] + " W " + flip + pad["cell"] + " ;",
                        file=ofile,
                    )

    # Run the padring app.

    def runpadring(self):
        self.print("Running padring")

        mag_path = self.projectpath + "/mag"
        if self.padring_path:
            padringopts = [self.padring_path]
        else:
            padringopts = ["padring"]

        # Diagnostic
        # self.print('Used libraries (self.ioleflibs) = ' + str(self.ioleflibs))

        for iolib in self.ioleflibs:
            padringopts.append("-L")
            padringopts.append(iolib)
        padringopts.append("--def")
        padringopts.append("padframe.def")
        padringopts.append("padframe.cfg")

        self.print("Running " + str(padringopts))

        p = subprocess.Popen(
            padringopts, stdout=subprocess.PIPE, stderr=subprocess.PIPE, cwd=mag_path
        )
        self.watch(p)

    # Read placement information from the DEF file generated by padring.

    def readplacement(self, precheck=False):
        self.print("Reading placement information from DEF file")

        mag_path = self.projectpath + "/mag"
        if not os.path.isfile(mag_path + "/padframe.def"):
            if not precheck:
                self.print("No file padframe.def:  pad frame was not generated.")
            return False

        # Very simple DEF file parsing.  The placement DEF only contains a
        # COMPONENTS section.  Certain assumptions are made about the syntax
        # that depends on the way 'padring' writes its output.  This is not
        # a rigorous DEF parser!

        units = 1000
        in_components = False
        Npadlist = []
        Spadlist = []
        Epadlist = []
        Wpadlist = []
        NEpad = []
        NWpad = []
        SEpad = []
        SWpad = []
        coregroup = []

        # Reset bounds
        self.llx = self.lly = self.urx = self.ury = 0
        corners = 0

        with open(mag_path + "/padframe.def", "r") as ifile:
            deflines = ifile.read().splitlines()
            for line in deflines:
                if "UNITS DISTANCE MICRONS" in line:
                    units = line.split()[3]
                elif in_components:
                    lparse = line.split()
                    if lparse[0] == "-":
                        instname = lparse[1]
                        cellname = lparse[2]

                    elif lparse[0] == "+":
                        if lparse[1] == "FIXED":
                            placex = lparse[3]
                            placey = lparse[4]
                            placeo = lparse[6]

                            newpad = {}
                            newpad["name"] = instname
                            newpad["cell"] = cellname

                            try:
                                celldef = next(
                                    item
                                    for item in self.celldefs
                                    if item["name"] == cellname
                                )
                            except Exception:
                                celldef = None
                            else:
                                newpad["iolib"] = celldef["iolib"]
                                newpad["width"] = celldef["width"]
                                newpad["height"] = celldef["height"]
                                newpad["class"] = celldef["class"]
                                newpad["subclass"] = celldef["subclass"]

                            newpad["x"] = float(placex) / float(units)
                            newpad["y"] = float(placey) / float(units)
                            newpad["o"] = placeo

                            # Adjust bounds
                            if celldef:
                                if newpad["x"] < self.llx:
                                    self.llx = newpad["x"]
                                if newpad["y"] < self.lly:
                                    self.lly = newpad["y"]

                                if newpad["o"] == "N" or newpad["o"] == "S":
                                    padurx = newpad["x"] + celldef["width"]
                                    padury = newpad["y"] + celldef["height"]
                                else:
                                    padurx = newpad["x"] + celldef["height"]
                                    padury = newpad["y"] + celldef["width"]

                                if padurx > self.urx:
                                    self.urx = padurx
                                if padury > self.ury:
                                    self.ury = padury

                            # First four entries in the DEF file are corners
                            # padring puts the lower left corner at zero, so
                            # use the zero coordinates to determine which pads
                            # are which.  Note that padring assumes the corner
                            # pad is drawn in the SW corner position!

                            if corners < 4:
                                if newpad["x"] == 0 and newpad["y"] == 0:
                                    SWpad.append(newpad)
                                elif newpad["x"] == 0:
                                    NWpad.append(newpad)
                                elif newpad["y"] == 0:
                                    SEpad.append(newpad)
                                else:
                                    NEpad.append(newpad)
                                corners += 1
                            else:
                                # Place according to orientation.  If orientation
                                # is not standard, be sure to make it standard!
                                placeo = self.rotate_orientation(placeo)
                                if placeo == "N":
                                    Spadlist.append(newpad)
                                elif placeo == "E":
                                    Wpadlist.append(newpad)
                                elif placeo == "S":
                                    Npadlist.append(newpad)
                                else:
                                    Epadlist.append(newpad)

                    elif "END COMPONENTS" in line:
                        in_components = False
                elif "COMPONENTS" in line:
                    in_components = True

            self.Npads = Npadlist
            self.Wpads = Wpadlist
            self.Spads = Spadlist
            self.Epads = Epadlist

            self.NWpad = NWpad
            self.NEpad = NEpad
            self.SWpad = SWpad
            self.SEpad = SEpad

        # The padframe has its own DEF file from the padring app, but the core
        # does not.  The core needs to be floorplanned in a very similar manner.
        # This will be done by searching for a DEF file of the project top-level
        # layout.  If none exists, it is created by generating it from the layout.
        # If the top-level layout does not exist, then all core cells are placed
        # at the origin, and the origin placed at the padframe inside corner.

        mag_path = self.projectpath + "/mag"
        if not os.path.isfile(mag_path + "/" + self.project + ".def"):
            if os.path.isfile(mag_path + "/" + self.project + ".mag"):

                # Create a DEF file from the layout
                with open(mag_path + "/pfg_write_def.tcl", "w") as ofile:
                    print("drc off", file=ofile)
                    print("box 0 0 0 0", file=ofile)
                    print("load " + self.project, file=ofile)
                    print("def write", file=ofile)
                    print("quit", file=ofile)

                magicexec = self.magic_path if self.magic_path else "magic"
                mproc = subprocess.Popen(
                    [magicexec, "-dnull", "-noconsole", "pfg_write_def.tcl"],
                    stdin=subprocess.PIPE,
                    stdout=subprocess.PIPE,
                    stderr=subprocess.PIPE,
                    cwd=mag_path,
                    universal_newlines=True,
                )

                self.watch(mproc)
                os.remove(mag_path + "/pfg_write_def.tcl")

            elif not os.path.isfile(mag_path + "/core.def"):

                # With no other information available, copy the corecells
                # (from the verilog file) into the coregroup list.
                # Position all core cells starting at the padframe top left
                # inside corner, and arranging in rows without overlapping.
                # Note that no attempt is made to organize the cells or
                # otherwise produce an efficient layout.  Any dimension larger
                # than the current padframe overruns to the right or bottom.

                if self.SWpad != []:
                    corellx = SWpad[0]["x"] + SWpad[0]["width"] + self.margin
                    corelly = SWpad[0]["y"] + SWpad[0]["height"] + self.margin
                else:
                    corellx = Wpadlist[0]["x"] + Wpadlist[0]["height"] + self.margin
                    corelly = Spadlist[0]["x"] + Spadlist[0]["height"] + self.margin
                if self.NEpad != []:
                    coreurx = NEpad[0]["x"] - self.margin
                    coreury = NEpad[0]["y"] - self.margin
                else:
                    coreurx = Epadlist[0]["x"] - self.margin
                    coreury = Npadlist[0]["x"] - self.margin
                locllx = corellx
                testllx = corellx
                loclly = corelly
                testlly = corelly
                nextlly = corelly

                for cell in self.corecells:

                    testllx = locllx + cell["width"]
                    if testllx > coreurx:
                        locllx = corellx
                        corelly = nextlly
                        loclly = nextlly

                    newcore = cell
                    newcore["x"] = locllx
                    newcore["y"] = loclly
                    newcore["o"] = "N"

                    locllx += cell["width"] + self.margin

                    testlly = corelly + cell["height"] + self.margin
                    if testlly > nextlly:
                        nextlly = testlly

                    coregroup.append(newcore)

                self.coregroup = coregroup

        if os.path.isfile(mag_path + "/" + self.project + ".def"):
            # Read the top-level DEF, and use it to position the core cells.
            self.print("Reading the top-level cell DEF for core cell placement.")

            units = 1000
            in_components = False
            with open(mag_path + "/" + self.project + ".def", "r") as ifile:
                deflines = ifile.read().splitlines()
                for line in deflines:
                    if "UNITS DISTANCE MICRONS" in line:
                        units = line.split()[3]
                    elif in_components:
                        lparse = line.split()
                        if lparse[0] == "-":
                            instname = lparse[1]
                            # NOTE: Magic should not drop the entire path to the
                            # cell for the cellname;  this needs to be fixed!  To
                            # work around it, remove any path components.
                            cellpath = lparse[2]
                            cellname = os.path.split(cellpath)[1]

                        elif lparse[0] == "+":
                            if lparse[1] == "PLACED":
                                placex = lparse[3]
                                placey = lparse[4]
                                placeo = lparse[6]

                                newcore = {}
                                newcore["name"] = instname
                                newcore["cell"] = cellname

                                try:
                                    celldef = next(
                                        item
                                        for item in self.coredefs
                                        if item["name"] == cellname
                                    )
                                except Exception:
                                    celldef = None
                                else:
                                    newcore["celllib"] = celldef["celllib"]
                                    newcore["width"] = celldef["width"]
                                    newcore["height"] = celldef["height"]
                                    newcore["class"] = celldef["class"]
                                    newcore["subclass"] = celldef["subclass"]

                                newcore["x"] = float(placex) / float(units)
                                newcore["y"] = float(placey) / float(units)
                                newcore["o"] = placeo
                                coregroup.append(newcore)

                        elif "END COMPONENTS" in line:
                            in_components = False
                    elif "COMPONENTS" in line:
                        in_components = True

            self.coregroup = coregroup

        elif os.path.isfile(mag_path + "/core.def"):
            # No DEF or .mag file, so fallback position is the last core.def
            # file generated by this script.
            self.read_core_def(precheck=precheck)

        return True

    # Read placement information from the "padframe.def" file and rotate
    # all cells according to self.pad_rotation.  This accounts for the
    # problem that the default orientation of pads is arbitrarily defined
    # by the foundry, while padring assumes that the corner pad is drawn
    # in the lower-left position and other pads are drawn with the pad at
    # the bottom and the buses at the top.

    def rotate_pads_in_def(self):
        if self.pad_rotation == 0:
            return

        self.print("Rotating pads in padframe DEF file.")
        mag_path = self.projectpath + "/mag"

        if not os.path.isfile(mag_path + "/padframe.def"):
            self.print("No file padframe.def:  Cannot modify pad rotations.")
            return

        deflines = []
        with open(mag_path + "/padframe.def", "r") as ifile:
            deflines = ifile.read().splitlines()

        outlines = []
        in_components = False
        for line in deflines:
            if in_components:
                lparse = line.split()
                if lparse[0] == "+":
                    if lparse[1] == "PLACED":
                        lparse[1] = "FIXED"
                        neworient = lparse[6]
                        lparse[6] = neworient
                        line = " ".join(lparse)

                elif "END COMPONENTS" in line:
                    in_components = False
            elif "COMPONENTS" in line:
                in_components = True
            outlines.append(line)

        with open(mag_path + "/padframe.def", "w") as ofile:
            for line in outlines:
                print(line, file=ofile)

    # Read placement information from the DEF file for the core (created by
    # a previous run of this script)

    def read_core_def(self, precheck=False):
        self.print("Reading placement information from core DEF file.")

        mag_path = self.projectpath + "/mag"

        if not os.path.isfile(mag_path + "/core.def"):
            if not precheck:
                self.print("No file core.def:  core placement was not generated.")
            return False

        # Very simple DEF file parsing, similar to the padframe.def reading
        # routine above.

        units = 1000
        in_components = False

        coregroup = []

        with open(mag_path + "/core.def", "r") as ifile:
            deflines = ifile.read().splitlines()
            for line in deflines:
                if "UNITS DISTANCE MICRONS" in line:
                    units = line.split()[3]
                elif in_components:
                    lparse = line.split()
                    if lparse[0] == "-":
                        instname = lparse[1]
                        cellname = lparse[2]

                    elif lparse[0] == "+":
                        if lparse[1] == "PLACED":
                            placex = lparse[3]
                            placey = lparse[4]
                            placeo = lparse[6]

                            newcore = {}
                            newcore["name"] = instname
                            newcore["cell"] = cellname

                            try:
                                celldef = next(
                                    item
                                    for item in self.coredefs
                                    if item["name"] == cellname
                                )
                            except Exception:
                                celldef = None
                            else:
                                newcore["celllib"] = celldef["celllib"]
                                newcore["width"] = celldef["width"]
                                newcore["height"] = celldef["height"]
                                newcore["class"] = celldef["class"]
                                newcore["subclass"] = celldef["subclass"]

                            newcore["x"] = float(placex) / float(units)
                            newcore["y"] = float(placey) / float(units)
                            newcore["o"] = placeo
                            coregroup.append(newcore)

                    elif "END COMPONENTS" in line:
                        in_components = False
                elif "COMPONENTS" in line:
                    in_components = True

            self.coregroup = coregroup

        return True

    # Save the layout to a Magic database file (to be completed)

    def save(self):
        self.print("Saving results in a magic layout database.")

        # Generate a list of (unique) LEF libraries for all padframe and core cells
        leflist = []
        for pad in self.celldefs:
            if pad["iolib"] not in leflist:
                leflist.append(pad["iolib"])

        for core in self.coredefs:
            if core["celllib"] not in leflist:
                leflist.append(core["celllib"])

        # Run magic, and generate the padframe with a series of commands
        mag_path = self.projectpath + "/mag"

        with open(mag_path + "/pfg_write_mag.tcl", "w") as ofile:
            print("drc off", file=ofile)
            print("box 0 0 0 0", file=ofile)
            for leffile in leflist:
                print("lef read " + leffile, file=ofile)
            print("def read padframe", file=ofile)
            print("select top cell", file=ofile)
            print("select area", file=ofile)
            print("select save padframe", file=ofile)
            print("delete", file=ofile)
            print("def read core", file=ofile)
            print("getcell padframe", file=ofile)
            print("save " + self.project, file=ofile)
            print("writeall force " + self.project, file=ofile)
            print("quit", file=ofile)

        magicexec = self.magic_path if self.magic_path else "magic"
        mproc = subprocess.Popen(
            [magicexec, "-dnull", "-noconsole", "pfg_write_mag.tcl"],
            stdin=subprocess.PIPE,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            cwd=mag_path,
            universal_newlines=True,
        )
        self.watch(mproc)
        os.remove(mag_path + "/pfg_write_mag.tcl")
        self.print("Done writing layout " + self.project + ".mag")

        # Write the core DEF file if it does not exist yet.
        if not os.path.isfile(mag_path + "/core.def"):
            self.write_core_def()


if __name__ == "__main__":
    faulthandler.register(signal.SIGUSR2)
    options = []
    arguments = []
    for item in sys.argv[1:]:
        if item.find("-", 0) == 0:
            options.append(item)
        else:
            arguments.append(item)

    if "-help" in options:
        print(sys.argv[0] + " [options]")
        print("")
        print("options:")
        print("   -noc    Print output to terminal, not the gui window")
        print("   -nog    No graphics, run in batch mode")
        print("   -cfg    Use existing padframe.cfg, do not regenerate")
        print("   -padring-path=<path>	path to padring executable")
        print("   -magic-path=<path>	path to magic executable")
        print("   -tech-path=<path>	path to tech root folder")
        print("   -project-path=<path>	path to project root folder")
        print("   -help   Print this usage information")
        print("")
        sys.exit(0)

    root = tkinter.Tk()
    do_gui = False if ("-nog" in options or "-nogui" in options) else True
    app = SoCFloorplanner(root, do_gui)

    # Allow option -noc to bypass the text-to-console redirection, so crash
    # information doesn't disappear with the app.

    app.use_console = False if ("-noc" in options or "-noconsole" in options) else True
    if do_gui == False:
        app.use_console = False

    # efabless format can be specified on the command line, but note that it
    # is otherwise auto-detected by checking for .config vs. .ef-config in
    # the project space.

    app.ef_format = True if "-ef_format" in options else False
    app.keep_cfg = True if "-cfg" in options else False

    app.padring_path = None
    app.magic_path = None
    app.techpath = None
    app.projectpath = None

    for option in options:
        if option.split("=")[0] == "-padring-path":
            app.padring_path = option.split("=")[1]
        elif option.split("=")[0] == "-magic-path":
            app.magic_path = option.split("=")[1]
        elif option.split("=")[0] == "-tech-path":
            app.techpath = option.split("=")[1]
        elif option.split("=")[0] == "-project-path":
            app.projectpath = option.split("=")[1]
            app.projectpath = (
                app.projectpath[:-1] if app.projectpath[-1] == "/" else app.projectpath
            )

    app.text_to_console()
    app.init_padframe()
    if app.do_gui:
        root.mainloop()
    else:
        # Run 'save' in non-GUI mode
        app.save()
        sys.exit(0)