/* -*- tab-width: 4 -*- * * Electric(tm) VLSI Design System * * File: GDS.java * Input/output tool: GDS output * Original C Code written by Sid Penstone, Queens University * Translated to Java by Steven M. Rubin, Sun Microsystems. * * Copyright (c) 2003 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.io.output;import com.sun.electric.database.geometry.Poly;import com.sun.electric.database.geometry.PolyBase;import com.sun.electric.database.hierarchy.Cell;import com.sun.electric.database.hierarchy.Export;import com.sun.electric.database.hierarchy.Nodable;import com.sun.electric.database.hierarchy.View;import com.sun.electric.database.prototype.PortOriginal;import com.sun.electric.database.prototype.PortProto;import com.sun.electric.database.text.TextUtils;import com.sun.electric.database.topology.ArcInst;import com.sun.electric.database.topology.NodeInst;import com.sun.electric.database.topology.PortInst;import com.sun.electric.database.variable.VarContext;import com.sun.electric.technology.ArcProto;import com.sun.electric.technology.Layer;import com.sun.electric.technology.PrimitiveNode;import com.sun.electric.technology.Technology;import com.sun.electric.technology.technologies.Generic;import com.sun.electric.tool.io.GDSLayers;import com.sun.electric.tool.io.IOTool;import com.sun.electric.tool.ncc.basic.NccCellAnnotations;import java.awt.geom.AffineTransform;import java.awt.geom.Point2D;import java.awt.geom.Rectangle2D;import java.io.ByteArrayOutputStream;import java.io.IOException;import java.math.BigDecimal;import java.util.Calendar;import java.util.Collection;import java.util.Comparator;import java.util.Date;import java.util.HashMap;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Set;import java.util.TreeSet;/** * This class writes files in GDS format. */public class GDS extends Geometry{	private static final int GDSVERSION        =      3;	private static final int BYTEMASK          =   0xFF;	private static final int DSIZE             =    512;		/* data block */	private static final int MAXPOINTS         =    510;		/* maximum points in a polygon */	private static final int EXPORTPRESENTATION=      0;		/* centered (was 8 for bottomleft) */	// GDSII bit assignments in STRANS record	private static final int STRANS_REFLX      = 0x8000;//	private static final int STRANS_ABSA       =    0x2;	// data type codes	private static final int DTYP_NONE         =      0;	// header codes	private static final short HDR_HEADER      = 0x0002;	private static final short HDR_BGNLIB      = 0x0102;	private static final short HDR_LIBNAME     = 0x0206;	private static final short HDR_UNITS       = 0x0305;	private static final short HDR_ENDLIB      = 0x0400;	private static final short HDR_BGNSTR      = 0x0502;	private static final short HDR_STRNAME     = 0x0606;	private static final short HDR_ENDSTR      = 0x0700;	private static final short HDR_BOUNDARY    = 0x0800;	private static final short HDR_PATH        = 0x0900;	private static final short HDR_SREF        = 0x0A00;//	private static final short HDR_AREF        = 0x0B00;	private static final short HDR_TEXT        = 0x0C00;	private static final short HDR_LAYER       = 0x0D02;	private static final short HDR_DATATYPE    = 0x0E02;	private static final short HDR_XY          = 0x1003;	private static final short HDR_ENDEL       = 0x1100;	private static final short HDR_SNAME       = 0x1206;	private static final short HDR_TEXTTYPE    = 0x1602;	private static final short HDR_PRESENTATION= 0x1701;	private static final short HDR_STRING	   = 0x1906;	private static final short HDR_STRANS      = 0x1A01;	private static final short HDR_MAG         = 0x1B05;	private static final short HDR_ANGLE       = 0x1C05;//    private static final short HDR_PROPATTR    = 0x2B02;//    private static final short HDR_PROPVALUE   = 0x2C06;	// Header byte counts	private static final short HDR_N_BGNLIB    =     28;	private static final short HDR_N_UNITS     =     20;	private static final short HDR_N_ANGLE     =     12;	private static final short HDR_N_MAG       =     12;	// Maximum string sizes	private static final int HDR_M_SNAME       =     32;	//private static final int HDR_M_STRNAME     =     32; // replace by preference IOTool.getGDSCellNameMaxLen	private static final int HDR_M_ASCII       =    256;	// contour gathering thresholds for polygon accumulation//	private static final double BESTTHRESH     =   0.001;		/* 1/1000 of a millimeter *///	private static final double WORSTTHRESH    =   0.1;			/* 1/10 of a millimeter */	/** for buffering output data */			private static byte [] dataBufferGDS = new byte[DSIZE];	/** for buffering output data */			private static byte [] emptyBuffer = new byte[DSIZE];	/** Current layer for gds output */			private static GDSLayers currentLayerNumbers;	/** Position of next byte in the buffer */	private static int bufferPosition;						/** Number data buffers output so far */	private static int blockCount;					/** constant for GDS units */				private static double scaleFactor;					/** cell naming map */						private Map<Cell,String> cellNames;	/** layer number map */						private Map<Layer,GDSLayers> layerNumbers;    /** separator string for lib + cell concatanated cell names */  public static final String concatStr = ".";    /** Name remapping if NCC annotation */     private Map<String,Set<String>> nameRemapping;    /** write pins at Export locations ? */     private final boolean writeExportPins;    /** converts bracket to underscores in export names.*/ private final boolean convertBracketsInExports;    	/**	 * Main entry point for GDS output.     * @param cell the top-level cell to write.     * @param context the hierarchical context to the cell.	 * @param filePath the disk file to create.	 */	public static GDS writeGDSFile(Cell cell, VarContext context, String filePath)	{        return writeGDSFile(cell, context, filePath, IOTool.isGDSOutWritesExportPins(), IOTool.getGDSOutputConvertsBracketsInExports());	}	/**	 * Main entry point for GDS output.     * @param cell the top-level cell to write.     * @param context the hierarchical context to the cell.	 * @param filePath the disk file to create.     * @param writeExportPins write pins at Export locations.     * @param convertBracketsInExports converts bracket to underscores in export names.	 */	public static GDS writeGDSFile(Cell cell, VarContext context, String filePath,            boolean writeExportPins, boolean convertBracketsInExports)	{		if (cell.getView() != View.LAYOUT)		{			System.out.println("Can only write GDS for layout cells");			return null;		}		GDS out = new GDS(writeExportPins, convertBracketsInExports);		if (out.openBinaryOutputStream(filePath)) return null;		BloatVisitor visitor = out.makeBloatVisitor(getMaxHierDepth(cell));		if (out.writeCell(cell, context, visitor)) return null;		if (out.closeBinaryOutputStream()) return null;		System.out.println(filePath + " written");		// warn if library name was changed		String topCellName = cell.getName();		String mangledTopCellName = makeGDSName(topCellName, HDR_M_ASCII);		if (!topCellName.equals(mangledTopCellName))			System.out.println("Warning: library name in this file is " + mangledTopCellName +				" (special characters were changed)");        return out;	}    private GDS(boolean writeExportPins, boolean convertBracketsInExports) {        this.writeExportPins = writeExportPins;        this.convertBracketsInExports = convertBracketsInExports;    }	protected void start()	{		initOutput();		outputBeginLibrary(topCell);	}	protected void done()	{		outputHeader(HDR_ENDLIB, 0);		doneWritingOutput();	}	/** Method to write cellGeom */	protected void writeCellGeom(CellGeom cellGeom)	{		// write this cell		Cell cell = cellGeom.cell;		outputBeginStruct(cell);        boolean renamePins = (cell == topCell && IOTool.getGDSConvertNCCExportsConnectedByParentPins());        boolean colapseGndVddNames = (cell == topCell && IOTool.isGDSColapseVddGndPinNames());        if (renamePins) {            // rename pins to allow external LVS programs to virtually connect nets as specified            // by the NCC annotation exportsConnectedByParent            NccCellAnnotations annotations = NccCellAnnotations.getAnnotations(cell);            if (annotations == null)                renamePins = false;            else                nameRemapping = createExportNameMap(annotations, cell);        }		// write all polys by Layer		Set<Layer> layers = cellGeom.polyMap.keySet();		for (Layer layer : layers)		{            // No technology associated, case when art elements are added in layout            // r.getTechnology() == Generic.tech for layer Glyph            if (layer == null || layer.getTechnology() == null || layer.getTechnology() == Generic.tech()) continue;			if (!selectLayer(layer))            {                System.out.println("Skipping " + layer + " in GDS:writeCellGeom");                continue;            }			List<Object> polyList = cellGeom.polyMap.get(layer);			for (Object obj : polyList)			{				PolyBase poly = (PolyBase)obj;				Integer firstLayer = currentLayerNumbers.getFirstLayer();				int layerNum = firstLayer.intValue() & 0xFFFF;				int layerType = (firstLayer.intValue() >> 16) & 0xFFFF;				writePoly(poly, layerNum, layerType);			}		}		// write all instances		for (Nodable no : cellGeom.nodables)		{			writeNodable(no);		}		// now write exports		if (IOTool.getGDSOutDefaultTextLayer() >= 0)		{			for(Iterator<PortProto> it = cell.getPorts(); it.hasNext(); )			{				Export pp = (Export)it.next();				// find the node at the bottom of this export				PortOriginal fp = new PortOriginal(pp.getOriginalPort());				PortInst bottomPort = fp.getBottomPort();				NodeInst bottomNi = bottomPort.getNodeInst();				// find the layer associated with this node				PrimitiveNode pNp = (PrimitiveNode)bottomNi.getProto();				Technology.NodeLayer [] nLay = pNp.getLayers();				Layer layer = nLay[0].getLayer().getNonPseudoLayer();				selectLayer(layer);//				int textLayer = IOTool.getGDSOutDefaultTextLayer(), textType = 0;//				if (currentLayerNumbers.getTextLayer() != -1)//				{//					textLayer = currentLayerNumbers.getTextLayer() & 0xFFFF;//					textType = (currentLayerNumbers.getTextLayer() >> 16) & 0xFFFF;//				}				int pinLayer = IOTool.getGDSOutDefaultTextLayer(), pinType = 0;				if (currentLayerNumbers.getPinLayer() != -1)				{					pinLayer = currentLayerNumbers.getPinLayer() & 0xFFFF;					pinType = (currentLayerNumbers.getPinLayer() >> 16) & 0xFFFF;				}				// put out a pin if requested				if (writeExportPins)                {					writeExportOnLayer(pp, pinLayer, pinType, renamePins, colapseGndVddNames);                    // write the text                    //writeExportOnLayer(pp, textLayer, textType);                }			}		}		outputHeader(HDR_ENDSTR, 0);	}    private Map<String,Set<String>> createExportNameMap(NccCellAnnotations ann, Cell cell) {        Map<String,Set<String>> nameMap = new HashMap<String,Set<String>>();        for (Iterator<List<NccCellAnnotations.NamePattern>> it2 = ann.getExportsConnected(); it2.hasNext(); )		{            List<NccCellAnnotations.NamePattern> list = it2.next();            // list of all patterns that should be connected            Set<String> connectedExports = new TreeSet<String>(new StringComparator());            for (NccCellAnnotations.NamePattern pat : list)			{                for (Iterator<PortProto> it = cell.getPorts(); it.hasNext(); )				{                    Export e = (Export)it.next();                    String name = e.getName();                    if (pat.matches(name))					{                        connectedExports.add(name);                        nameMap.put(name, connectedExports);                    }                }            }        }        return nameMap;    }    private static class StringComparator implements Comparator<String>    {		/**		 * Method to sort Objects by their string name.		 */        public int compare(String s1, String s2)		{            return s1.compareTo(s2);        }        public boolean equals(Object obj)		{            return (this == obj);        }    }    private void writeExportOnLayer(Export pp, int layer, int type, boolean remapNames, boolean colapseGndVddNames)	{		outputHeader(HDR_TEXT, 0);		outputHeader(HDR_LAYER, layer);		outputHeader(HDR_TEXTTYPE, type);		outputHeader(HDR_PRESENTATION, EXPORTPRESENTATION);		// now the orientation		NodeInst ni = pp.getOriginalPort().getNodeInst();		int transValue = 0;		int angle = ni.getAngle();		if (ni.isXMirrored() != ni.isYMirrored()) transValue |= STRANS_REFLX;		if (ni.isYMirrored()) angle = (3600 - angle)%3600;		if (ni.isXMirrored()) angle = (1800 - angle)%3600;		outputHeader(HDR_STRANS, transValue);		// reduce the size of export text by a factor of 2		outputMag(0.5);		outputAngle(angle);		outputShort((short)12);		outputShort(HDR_XY);		Poly portPoly = pp.getOriginalPort().getPoly();		outputInt(scaleDBUnit(portPoly.getCenterX()));		outputInt(scaleDBUnit(portPoly.getCenterY()));		// now the string		String str = pp.getName();        if (remapNames) {            Set<String> nameSet = nameRemapping.get(str);            if (nameSet != null) {                str = nameSet.iterator().next();                str = str + ":" + str;                //System.out.println("Remapping export "+pp.getName()+" to "+str);            }        }        if (convertBracketsInExports) {            // convert brackets to underscores            str = str.replaceAll("[\\[\\]]", "_");        }        if (colapseGndVddNames)        {            String tmp = str.toLowerCase();            // Detecting string in lower case and later search for "_"            if (tmp.startsWith("vdd_") || tmp.startsWith("gnd_"))