readabledump.java

The ElectricTM VLSI Design System is an open-source Electronic Design Automation (EDA) system that c

			return;
		}
		abbrev = abbrev.substring(0, closeCurly);

		View v = View.findView(fullName);
		if (v == null)
		{
			v = findOldViewName(fullName);
			if (v != null) abbrev = v.getAbbreviation();
		}
		if (v == null)
		{
			v = View.newInstance(fullName, abbrev);
		} else
		{
			if (!v.getAbbreviation().equals(abbrev))
			{
				System.out.println("Error on line " + lineReader.getLineNumber() + ": view " + fullName + " has abbreviation '" + abbrev +
					"' which does not match the existing abbreviation '" + v.getAbbreviation() + "'");
				return;
			}
		}
	}

	// --------------------------------- CELL PARSING METHODS ---------------------------------

	/**
	 * initialize for a new cell (keyword "***cell")
	 */
	private void keywordNewCel()
	{
		curCellNumber = TextUtils.atoi(keyWord);
//		curCell = nodeProtoList[curCellNumber];

		int curCellGroup = -1;
		int slashPos = keyWord.indexOf('/');
		if (slashPos >= 0) curCellGroup = TextUtils.atoi(keyWord.substring(slashPos+1));
        cellGroups[curCellNumber] = curCellGroup;

		textLevel = INCELL;
		varPos = INVNODEPROTO;
	}

	/**
	 * get the name of the current cell (keyword "name")
	 */
	private void keywordCelNam()
	{
		cellNames[curCellNumber] = CellName.parseName(convertCellName(keyWord));
	}

	/**
	 * get the version of the current cell (keyword "version")
	 */
	private void keywordCelVer()
	{
        CellName curCellName = cellNames[curCellNumber];
        cellNames[curCellNumber] = CellName.newName(curCellName.getName(), curCellName.getView(), TextUtils.atoi(keyWord));
		//curCellName.setVersion(TextUtils.atoi(keyWord));
	}

	/**
	 * get the creation date of the current cell (keyword "creationdate")
	 */
	private void keywordCelCre()
	{
		cellCreationDates[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the revision date of the current cell (keyword "revisiondate")
	 */
	private void keywordCelRev()
	{
		cellRevisionDates[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the low X of the current cell (keyword "lowx")
	 */
	private void keywordCelLX()
	{
		cellLowX[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the high X of the current cell (keyword "highx")
	 */
	private void keywordCelHX()
	{
		cellHighX[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the low Y of the current cell (keyword "lowy")
	 */
	private void keywordCelLY()
	{
		cellLowY[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the high Y of the current cell (keyword "highy")
	 */
	private void keywordCelHY()
	{
		cellHighY[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get tool information for current cell (keyword "bits")
	 */
	private void keywordCelBit()
	{
        cellUserbits[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get tool information for current cell (keyword "userbits")
	 */
	private void keywordCelUsb()
	{
        cellUserbits[curCellNumber] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the external library file (keyword "externallibrary")
	 */
	private void keywordCelExt()
	{
		// get the path to the library file
		String withoutQuotes = keyWord;
		if (withoutQuotes.charAt(0) == '"')
		{
			withoutQuotes = withoutQuotes.substring(1);
			if (withoutQuotes.endsWith("\""))
				withoutQuotes = withoutQuotes.substring(0, withoutQuotes.length()-1);
		}
        cellLibPaths[curCellNumber] = withoutQuotes;
    }

	/**
	 * get the default technology for objects in this cell (keyword "technology")
	 */
	private void keywordTech()
	{
        cellTechNames[curCellNumber] = keyWord;
	}

	/**
	 * get the number of node instances in the current cell (keyword "nodes")
	 */
	private void keywordCelNoC()
	{
//		// this keyword indicates that the cell is NOT external, so establish it now
//		finishCellInitialization();

		// handle the NodeInst count in the cell
		int nodeInstCount = Integer.parseInt(keyWord);
		if (nodeInstCount == 0) return;
        nodeProtoTypeList[curCellNumber] = new String[nodeInstCount];
		nodeInstList[curCellNumber] = new LibraryFiles.NodeInstList(nodeInstCount, false);
	}

	/**
	 * get the number of arc instances in the current cell (keyword "arcs")
	 */
	private void keywordCelArC()
	{
		int arcInstCount = Integer.parseInt(keyWord);
		ArcInstList ail = new ArcInstList();
		arcInstList[curCellNumber] = ail;
		ail.arcList = new ArcInst[arcInstCount];
        ail.arcProtoName = new String[arcInstCount];
		ail.arcProto = new ArcProto[arcInstCount];
		ail.arcInstName = new String[arcInstCount];
        ail.arcNameDescriptor = new TextDescriptor[arcInstCount];
		ail.arcWidth = new int[arcInstCount];
		ail.arcHeadNode = new int[arcInstCount];
		ail.arcHeadPort = new String[arcInstCount];
		ail.arcHeadX = new int[arcInstCount];
		ail.arcHeadY = new int[arcInstCount];
		ail.arcTailNode = new int[arcInstCount];
		ail.arcTailPort = new String[arcInstCount];
		ail.arcTailX = new int[arcInstCount];
		ail.arcTailY = new int[arcInstCount];
		ail.arcUserBits = new int[arcInstCount];
        ail.arcVars = new Variable[arcInstCount][];
	}

	/**
	 * get the number of port prototypes in the current cell (keyword "porttypes")
	 */
	private void keywordCelPtC()
	{
		int exportCount = Integer.parseInt(keyWord);

		ExportList el = new ExportList();
		exportList[curCellNumber] = el;
		el.exportList = new Export[exportCount];
		el.exportName = new String[exportCount];
        el.exportNameDescriptor = new TextDescriptor[exportCount];
		el.exportSubNode = new int[exportCount];
		el.exportSubPort = new String[exportCount];
        el.exportUserBits = new int[exportCount];
        el.exportVars = new Variable[exportCount][];
	}

	// --------------------------------- NODE INSTANCE PARSING METHODS ---------------------------------

	/**
	 * initialize for a new node instance (keyword "**node")
	 */
	private void keywordNewNo()
	{
		curNodeInstIndex = Integer.parseInt(keyWord);
		textLevel = INNODEINST;
		varPos = INVNODEINST;
	}

	/**
	 * get the type of the current nodeinst (keyword "type")
	 */
	private void keywordNodTyp()
	{
        nodeProtoTypeList[curCellNumber][curNodeInstIndex] = keyWord;
    }

	/**
	 * get the bounding box information for the current node instance
	 */
	private void keywordNodLX()
	{
		nodeInstList[curCellNumber].lowX[curNodeInstIndex] = TextUtils.atoi(keyWord);
	}

	private void keywordNodHX()
	{
		nodeInstList[curCellNumber].highX[curNodeInstIndex] = TextUtils.atoi(keyWord);
	}

	private void keywordNodLY()
	{
		nodeInstList[curCellNumber].lowY[curNodeInstIndex] = TextUtils.atoi(keyWord);
	}

	private void keywordNodHY()
	{
		nodeInstList[curCellNumber].highY[curNodeInstIndex] = TextUtils.atoi(keyWord);
	}

	/**
	 * get the instance name of the current node instance (keyword "name")
	 */
	private void keywordNodNam()
	{
		nodeInstList[curCellNumber].name[curNodeInstIndex] = keyWord;
	}

	/**
	 * get the text descriptor of the current node instance (keyword "descript")
	 */
	private void keywordNodDes()
	{
		int td0 = TextUtils.atoi(keyWord);
		int td1 = 0;
		int slashPos = keyWord.indexOf('/');
		if (slashPos >= 0)
			td1 = TextUtils.atoi(keyWord.substring(slashPos+1));
		nodeInstList[curCellNumber].protoTextDescriptor[curNodeInstIndex] = makeDescriptor(td0, td1);
//		mtd.setCBits(td0, td1);
//		nodeInstList[curCellNumber].theNode[curNodeInstIndex].setTextDescriptor(NodeInst.NODE_PROTO_TD, mtd);
	}

	/**
	 * get the rotation for the current nodeinst (keyword "rotation");
	 */
	private void keywordNodRot()
	{
		nodeInstList[curCellNumber].rotation[curNodeInstIndex] = (short)Integer.parseInt(keyWord);
	}

	/**
	 * get the transposition for the current nodeinst (keyword "transpose")
	 */
	private void keywordNodTra()
	{
		nodeInstList[curCellNumber].transpose[curNodeInstIndex] = Integer.parseInt(keyWord);
	}

	/**
	 * get the tool seen bits for the current nodeinst (keyword "aseen")
	 */
	private void keywordNodKse()
	{
		bitCount = 0;
	}

	/**
	 * get the port count for the current nodeinst (keyword "ports")
	 */
	private void keywordNodPoC() {}

	/**
	 * get tool information for current nodeinst (keyword "bits")
	 */
	private void keywordNodBit()
	{
		if (bitCount == 0) nodeInstList[curCellNumber].userBits[curNodeInstIndex] = TextUtils.atoi(keyWord);
		bitCount++;
	}

	/**
	 * get tool information for current nodeinst (keyword "userbits")
	 */
	private void keywordNodUsb()
	{
		nodeInstList[curCellNumber].userBits[curNodeInstIndex] = TextUtils.atoi(keyWord);
	}

	/**
	 * initialize for a new portinst on the current nodeinst (keyword "*port")
	 */
	private void keywordNewPor()
	{
		textLevel = INPOR;
	}

	// --------------------------------- ARC INSTANCE PARSING METHODS ---------------------------------

	/**
	 * initialize for a new arc instance (keyword "**arc")
	 */
	private void keywordNewAr()
	{
		curArcInstIndex = Integer.parseInt(keyWord);
		textLevel = INARCINST;
		varPos = INVARCINST;
	}

	/**
	 * get the type of the current arc instance (keyword "type")
	 */
	private void keywordArcTyp()
	{
        arcInstList[curCellNumber].arcProtoName[curArcInstIndex] = keyWord;
    }

	/**
	 * get the instance name of the current arc instance (keyword "name")
	 */
	private void keywordArcNam()
	{
		arcInstList[curCellNumber].arcInstName[curArcInstIndex] = keyWord;
	}

	/**
	 * get the width of the current arc instance (keyword "width")
	 */
	private void keywordArcWid()
	{
		arcInstList[curCellNumber].arcWidth[curArcInstIndex] = TextUtils.atoi(keyWord);
	}

	/**
	 * initialize for an end of the current arcinst (keyword "*end")
	 */
	private void keywordNewEnd()
	{
		curArcEnd = Integer.parseInt(keyWord);
		textLevel = INARCEND;
	}

	/**
	 * get the node at the current end of the current arcinst (keyword "node")
	 */