/* -*- tab-width: 4 -*- * * Electric(tm) VLSI Design System * * File: Flat.java * Asynchronous Logic Simulator network flattening * Original C Code written by Brent Serbin and Peter J. Gallant * Translated to Java by Steven M. Rubin, Sun Microsystems. * * Copyright (c) 2005 Sun Microsystems and Static Free Software * * Electric(tm) is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 3 of the License, or * (at your option) any later version. * * Electric(tm) is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with Electric(tm); see the file COPYING.  If not, write to * the Free Software Foundation, Inc., 59 Temple Place, Suite 330, * Boston, Mass 02111-1307, USA. */package com.sun.electric.tool.simulation.als;import com.sun.electric.database.hierarchy.Cell;import com.sun.electric.database.text.TextUtils;import com.sun.electric.tool.simulation.als.ALS.IO;import com.sun.electric.tool.simulation.als.ALS.Stat;import java.util.ArrayList;import java.util.Iterator;import java.util.List;/** * Class to flatten circuitry for the ALS Simulator. */public class Flat{	private ALS       als;	private ALS.Model primPtr2;	Flat(ALS als)	{		this.als = als;	}	/**	 * Method to call a series of routines which convert the hierarchical	 * network description into a flattened database representation.  The actual	 * simulation must take place on the flattened network.  Returns true on error.	 */	boolean flattenNetwork(Cell cell)	{		/*		 * create a "dummy" level to use as a mixed signal destination for plotting and		 * screen display.  This level should be bypassed for structure checking and general		 * simulation, however, so in the following code, references to "als.cellRoot"		 * have been changed to als.cellRoot.next (pointing to mainCell).		 * Peter Gallant July 16, 1990		 */		als.cellRoot = new ALS.Connect();		als.cellRoot.instName = "[MIXED_SIGNAL_LEVEL]";		als.cellRoot.modelName = als.cellRoot.instName;		als.cellRoot.exList = new ArrayList<ALS.ALSExport>();		als.cellRoot.parent = null;		als.cellRoot.child = null;		als.cellRoot.next = null;		ALS.Connect tempRoot = als.cellRoot;		// get upper-case version of main proto		String mainName = cell.getName().toUpperCase();		als.cellRoot = new ALS.Connect();		als.cellRoot.instName = mainName;		als.cellRoot.modelName = als.cellRoot.instName;		als.cellRoot.exList = new ArrayList<ALS.ALSExport>();		als.cellRoot.parent = null;		als.cellRoot.child = null;		als.cellRoot.next = null;		// these lines link the mixed level as the head followed by mainCell PJG		tempRoot.next = als.cellRoot;		// shouldn't this be null? ... smr		tempRoot.child = als.cellRoot;		als.cellRoot = tempRoot;		// this code checks to see if model mainCell is present in the netlist PJG		ALS.Model modHead = findModel(mainName);		if (modHead == null) return true;		for(ALS.ALSExport exHead : modHead.exList)		{			findXRefEntry(als.cellRoot.next, (String)exHead.nodeName);		}		if (flattenModel(als.cellRoot.next)) return true;		for(ALS.Node nodeHead : als.nodeList)		{			if (nodeHead.load < 1) nodeHead.load = 1;		}		return false;	}	/**	 * Method to flatten a single model.  If other models are referenced	 * in connection statements in the netlist, this routine is called recursively	 * until a totally flat model is obtained.  Returns true on error.	 *	 * Calling Arguments:	 *	cellHead = pointer to a data structure containing information about	 *		  the model that is going to be flattened	 */	private boolean flattenModel(ALS.Connect cellHead)	{		ALS.Model modHead = findModel(cellHead.modelName);		if (modHead == null) return true;		switch (modHead.type)		{			case 'F':				if (processFunction(cellHead, modHead)) return true;				break;			case 'G':				processGate(cellHead, modHead);				break;			case 'M':				if (processConnectList(cellHead, (ALS.Connect)modHead.ptr)) return true;				for (ALS.Connect subCell = cellHead.child; subCell != null; subCell = subCell.next)				{					if (flattenModel(subCell)) return true;				}				break;		}		if (modHead.setList.size() != 0)		{			processSetEntry(cellHead, modHead.setList);		}		return false;	}	/**	 * Method to step through the connection list specified by the	 * connection list pointer (conHead).  Values are entered into the cross	 * reference table for the present level of hierarchy and new data structures	 * are created for the lower level of hierarchy to store their cross	 * reference tables.  Returns true on error.	 *	 * Calling Arguments:	 *	cellHead = pointer to the cross reference data structure for the model	 *		  that is going to be flattened	 *	conHead  = pointer to a list of connection statements for the model	 *		  that is being flattened by this procedure	 */	private boolean processConnectList(ALS.Connect cellHead, ALS.Connect conHead)	{		while (conHead != null)		{			ALS.Connect cellPtr2 = new ALS.Connect();			cellPtr2.instName = conHead.instName;			cellPtr2.modelName = conHead.modelName;			cellPtr2.exList = new ArrayList<ALS.ALSExport>();			cellPtr2.parent = cellHead;			cellPtr2.child = null;			cellPtr2.next = cellHead.child;			cellHead.child = cellPtr2;			ALS.Model modHead = findModel(conHead.modelName);			if (modHead == null) return true;			Iterator<ALS.ALSExport> it = modHead.exList.iterator();			for(ALS.ALSExport exHead : conHead.exList)			{				if (!it.hasNext()) break;				als.exPtr2 = it.next();				ALS.ALSExport xRefHead = findXRefEntry(cellHead, (String)exHead.nodeName);				if (als.exPtr2 == null)				{					System.out.println("Insufficient parameters declared for model '" + conHead.modelName + "' in netlist");					return true;				}				for(ALS.ALSExport xRefPtr1 : cellPtr2.exList)				{					if (xRefPtr1.nodeName.equals(als.exPtr2.nodeName))					{						System.out.println("Node '" + als.exPtr2.nodeName + "' in model '" +							conHead.modelName + "' connected more than once");						return true;					}				}				ALS.ALSExport xRefPtr2 = new ALS.ALSExport();				xRefPtr2.nodeName = als.exPtr2.nodeName;				xRefPtr2.nodePtr = xRefHead.nodePtr;				cellPtr2.exList.add(xRefPtr2);			}			conHead = conHead.next;		}		return false;	}	/**	 * Method to return a pointer to the model referenced by the	 * calling argument character string.  Returns zero on error.	 *	 * Calling Arguments:	 *	modelName = pointer to a string which contains the name of the model	 *		    to be located by the search procedure	 */	private ALS.Model findModel(String modelName)	{		// convert to proper name		StringBuffer sb = new StringBuffer();		for(int i=0; i<modelName.length(); i++)		{			char chr = modelName.charAt(i);			if (!TextUtils.isLetterOrDigit(chr)) chr = '_';			sb.append(chr);		}		String properName = sb.toString();		for(ALS.Model modHead : als.modelList)		{			if (modHead.name.equals(properName)) return modHead;		}		System.out.println("ERROR: Model '" + properName + "' not found, simulation aborted");		return null;	}	/**	 * Method to return the flattened database node number for the	 * specified model and node name.	 *	 * Calling Arguments:	 *	cellHead = pointer to the xref table for the model being processed	 *	name    = pointer to a char string containing the node name	 */	private ALS.ALSExport findXRefEntry(ALS.Connect cellHead, String name)	{		for(ALS.ALSExport xRefPtr1 : cellHead.exList)		{			if (xRefPtr1.nodeName.equals(name)) return xRefPtr1;		}		ALS.ALSExport xRefPtr2 = new ALS.ALSExport();		xRefPtr2.nodeName = name;		cellHead.exList.add(xRefPtr2);		ALS.Node nodePtr2 = new ALS.Node();		nodePtr2.cellPtr = cellHead;		nodePtr2.statList = new ArrayList<Stat>();		nodePtr2.pinList = new ArrayList<ALS.Load>();		nodePtr2.load = -1;		nodePtr2.visit = 0;		nodePtr2.traceNode = false;		als.nodeList.add(nodePtr2);		xRefPtr2.nodePtr = nodePtr2;		return xRefPtr2;	}	/**	 * Method to step through the gate truth tables and examines all