cif.java

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

					switch (peekNextCharacter())
					{
						case 'T':
							getNextCharacter();
							trans.kind = TRANSLATE;
							trans.xt = getSignedInteger(); if (errorFound) return reportError();
							trans.yt = getSignedInteger(); if (errorFound) return reportError();
							appendTransformEntry(curTList, trans);
							break;

						case 'M':
							trans.kind = MIRROR;
							getNextCharacter(); skipBlanks();
							switch (getNextCharacter())
							{
								case 'X': trans.xCoord = true; break;
								case 'Y': trans.xCoord = false; break;
								default:  errorFound = true; errorType = BADAXIS; return reportError();
							}
							appendTransformEntry(curTList, trans);
							break;

						case 'R':
							trans.kind = ROTATE;
							getNextCharacter();
							trans.xRot = getSignedInteger(); if (errorFound) return reportError();
							trans.yRot = getSignedInteger(); if (errorFound) return reportError();
							appendTransformEntry(curTList, trans);
							break;

						default:
							errorFound = true; errorType = BADTRANS; return reportError();
					}
					skipBlanks();		// between transformation commands
				}	// end of while (1) loop
				break;

			case '(':
				{
					int level = 1;
					command = COMMENT;
					StringBuffer comment = new StringBuffer();
					while (level != 0)
					{
						curChar = getNextCharacter();
						switch (curChar)
						{
							case '(':
								level++;
								comment.append('(');
								break;
							case ')':
								level--;
								if (level != 0) comment.append(')');
								break;
							case -1:
								errorFound = true; errorType = BADCOMMENT; return reportError();
							default:
								comment.append(curChar);
						}
					}
				}
				break;

			case 'E':
				skipBlanks();
				if (isInCellDefinition)
				{
					errorFound = true;
					errorType = NESTEND;
					return reportError();
				}
				if (!atEndOfFile()) errorReport("more text follows end command", ADVISORY);
				endIsSeen = true;
				processEnd();
				return END;

			case ';':
				return NULLCOMMAND;

			default:
				if (TextUtils.isDigit((char)curChar))
				{
					userCommand = curChar - '0';
					if (userCommand == 9)
					{
						curChar = peekNextCharacter();
						if (curChar == ' ' || curChar == '\t' || curChar == '1' || curChar == '2' || curChar == '3')
						{
							switch (getNextCharacter())
							{
								case ' ':
								case '\t':
									skipSpaces(); nameText = parseName(); if (errorFound) return reportError();
									command = SYMNAME;
									break;
								case '1':
								case '2':
								case '3':
									if (!skipSpaces())
									{
										errorFound = true; errorType = NOSPACE;
										return reportError();
									}
									nameText = parseName(); if (errorFound) return reportError();
									switch (curChar)
									{
										case '1':
											command = INSTNAME;
											break;
										case '2':
										{
											command = GEONAME;
											namePoint = getPoint(); if (errorFound) return reportError();
											skipBlanks();
											StringBuffer layName = new StringBuffer();
											for (int i = 0; i<4; i++)
											{
												int chr = peekNextCharacter();
												if (!Character.isUpperCase((char)chr) && !TextUtils.isDigit((char)chr)) break;
												layName.append(getNextCharacter());
											}
											lName = layName.toString();
											break;
										}
										case '3':
											command = LABELCOM;
											namePoint = getPoint(); if (errorFound) return reportError();
											break;
									}
									break;
							}
						} else
						{
							command = USERS;
							userText = getUserText();
							if (atEndOfFile())
							{
								errorFound = true; errorType = BADUSER; return reportError();
							}
						}
					}
				} else
				{
					errorFound = true;
					errorType = BADCOMMAND;
					return reportError();
				}
		}

		// by now we have a syntactically valid command although it might be missing a semi-colon
		switch (command)
		{
			case WIRECOM:
				makeWire(width, curPath);
				break;
			case DEFSTART:
				makeStartDefinition(symbolNumber, multiplier, divisor);
				break;
			case DEFEND:
				makeEndDefinition();
				break;
			case DELETEDEF:
				makeDeleteDefinition(symbolNumber);
				break;
			case CALLCOM:
				makeCall(symbolNumber, curTList);
				break;
			case LAYER:
				makeLayer(lName);
				break;
			case FLASHCOM:
				makeFlash(diameter, center);
				break;
			case POLYCOM:
				makePolygon(curPath);
				break;
			case BOXCOM:
				makeBox(length, width, center, xRotate, yRotate);
				break;
			case COMMENT:
				break;
			case USERS:
				makeUserComment(userCommand, userText);
				break;
			case SYMNAME:
				makeSymbolName(nameText);
				break;
			case INSTNAME:
				makeInstanceName(nameText);
				break;
			case GEONAME:
				makeGeomName(nameText, namePoint, curTech.findLayer(lName));
				break;
			case LABELCOM:
				makeLabel(nameText, namePoint);
				break;
			default:
				errorFound = true;
				errorType = INTERNAL;
				return reportError();
		}
		if (!skipSemicolon()) {errorFound = true; errorType = NOSEMI; return reportError();}

		return command;
	}

	private void makeLabel(String name, Point pt)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
		if (name.length() == 0)
		{
			errorReport("null label ignored", ADVISORY);
			return;
		}
		FrontLabel obj = new FrontLabel();
		if (isInCellDefinition && cellScaleFactor != 1.0)
		{
			pt.x = (int)(cellScaleFactor * pt.x);
			pt.y = (int)(cellScaleFactor * pt.y);
		}
		obj.pos = pt;
		obj.name = name;

		pushTransform();
		Point temp = transformPoint(pt);
		popTransform();
		obj.bb.l = temp.x;
		obj.bb.r = temp.x;
		obj.bb.b = temp.y;
		obj.bb.t = temp.y;

		if (isInCellDefinition)
		{
			// insert into symbol's guts
			obj.next = currentFrontSymbol.guts;
			currentFrontSymbol.guts = obj;
		} else topLevelItem(obj);		// stick into item list
	}

	private void makeGeomName(String name, Point pt, Layer lay)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
		if (name.length() == 0)
		{
			errorReport("null geometry name ignored", ADVISORY);
			return;
		}
		FrontGeomName obj = new FrontGeomName();
		obj.layer = lay;
		if (isInCellDefinition && cellScaleFactor != 1.0)
		{
			pt.x = (int)(cellScaleFactor * pt.x);
			pt.y = (int)(cellScaleFactor * pt.y);
		}

		pushTransform();
		Point temp = transformPoint(pt);
		popTransform();
		obj.bb.l = temp.x;
		obj.bb.r = temp.x;
		obj.bb.b = temp.y;
		obj.bb.t = temp.y;

		if (isInCellDefinition)
		{
			// insert into symbol's guts
			obj.next = currentFrontSymbol.guts;
			currentFrontSymbol.guts = obj;
		} else topLevelItem(obj);		// stick into item list
	}

	private void makeSymbolName(String name)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
		if (!isInCellDefinition)
		{
			errorReport("no symbol to name", FATALSEMANTIC);
			return;
		}
		if (name.length() == 0)
		{
			errorReport("null symbol name ignored", ADVISORY);
			return;
		}
		if (symbolNamed)
		{
			errorReport("symbol is already named, new name ignored", FATALSEMANTIC);
			return;
		}
		symbolNamed = true;
		currentFrontSymbol.name = name;
	}

	private void makeUserComment(int command, String text)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
	}

	private void makeBox(int length, int width, Point center, int xr, int yr)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
		if (currentLayer == null)
		{
			numNullLayerErrors = true;
			return;
		}
		if (length == 0 || width == 0)
		{
			errorReport("box with null length or width specified, ignored", ADVISORY);
			return;
		}

		if (isInCellDefinition && cellScaleFactor != 1.0)
		{
			length = (int) (cellScaleFactor * length);
			width = (int) (cellScaleFactor * width);
			center.x = (int) (cellScaleFactor * center.x);
			center.y = (int) (cellScaleFactor * center.y);
		}

		Rectangle box = boundsBox(length, width, center, xr, yr);
		int tl = box.x;   int tr = box.x + box.width;
		int tb = box.y;   int tt = box.y + box.height;

		// check for manhattan box
		int halfW = width/2;
		int halfL = length/2;
		if (
			(yr == 0 && (length%2) == 0 && (width%2) == 0 &&
			(center.x-halfL) == tl && (center.x+halfL) == tr &&
			(center.y-halfW) == tb && (center.y+halfW) == tt)
			||
			(xr == 0 && (length%2) == 0 && (width%2) == 0 &&
			(center.x-halfW) == tl && (center.x+halfW) == tr &&
			(center.y-halfL) == tb && (center.y+halfL) == tt)
		)
		{
			// a manhattan box
			FrontManBox obj = new FrontManBox();
			obj.layer = currentLayer;
			if (yr == 0)
			{
				obj.bb.l = tl;
				obj.bb.r = tr;
				obj.bb.b = tb;
				obj.bb.t = tt;
			} else
			{
				// this assumes that bb is unaffected by rotation
				obj.bb.l = center.x-halfW;
				obj.bb.r = center.x+halfW;
				obj.bb.b = center.y-halfL;
				obj.bb.t = center.y+halfL;
			}
			if (isInCellDefinition)
			{
				// insert into symbol's guts
				obj.next = currentFrontSymbol.guts;
				currentFrontSymbol.guts = obj;
			} else topLevelItem(obj);		// stick into item list
		} else
		{
			FrontBox obj = new FrontBox();
			obj.layer = currentLayer;
			obj.length = length;
			obj.width = width;
			obj.center = center;
			obj.xRot = xr;
			obj.yRot = yr;

			obj.bb.l = tl;
			obj.bb.r = tr;
			obj.bb.b = tb;
			obj.bb.t = tt;
			if (isInCellDefinition)
			{
				// insert into symbol's guts
				obj.next = currentFrontSymbol.guts;
				currentFrontSymbol.guts = obj;
			} else topLevelItem(obj);		// stick into item list
		}
	}

	private void makeFlash(int diameter, Point center)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
		if (currentLayer == null)
		{
			numNullLayerErrors = true;
			return;
		}
		if (diameter == 0)
		{
			errorReport("flash with null diamter, ignored", ADVISORY);
			return;
		}

		FrontFlash obj = new FrontFlash();
		obj.layer = currentLayer;
		if (isInCellDefinition && cellScaleFactor != 1.0)
		{
			diameter = (int) (cellScaleFactor * diameter);
			center.x = (int) (cellScaleFactor * center.x);
			center.y = (int) (cellScaleFactor * center.y);
		}
		obj.diameter = diameter;
		obj.center = center;

		Rectangle box = boundsFlash(diameter, center);
		obj.bb.l = box.x;
		obj.bb.r = box.x + box.width;
		obj.bb.b = box.y;
		obj.bb.t = box.y + box.height;

		if (isInCellDefinition)
		{
			// insert into symbol's guts
			obj.next = currentFrontSymbol.guts;
			currentFrontSymbol.guts = obj;
		} else topLevelItem(obj);		// stick into item list
	}

	private Rectangle boundsFlash(int diameter, Point center)
	{
		return boundsBox(diameter, diameter, center, 1, 0);
	}

	private Rectangle boundsBox(int length, int width, Point center, int xr, int yr)
	{
		int dx = length/2;
		int dy = width/2;

		pushTransform();	// newtrans
		rotateMatrix(xr, yr);
		translateMatrix(center.x, center.y);
		Point temp = new Point(dx, dy);
		initMinMax(transformPoint(temp));
		temp.y = -dy;
		minMax(transformPoint(temp));
		temp.x = -dx;
		minMax(transformPoint(temp));
		temp.y = dy;
		minMax(transformPoint(temp));
		popTransform();
		Rectangle ret = new Rectangle(getMinMaxMinX(), getMinMaxMinY(),
			getMinMaxMaxX()-getMinMaxMinX(), getMinMaxMaxY()-getMinMaxMinY());
		doneMinMax();
		return ret;
	}

	private void makeLayer(String lName)
	{
		statementsSince91 = true;
		if (ignoreStatements) return;
		currentLayer = cifLayerNames.get(lName);
		if (currentLayer == null)
		{
			unknownLayerNames.add(lName);
		}
	}

	private void makeCall(int symbol, FrontTransformList list)
	{
		if (ignoreStatements) return;
		int j = getFrontTransformListLength(list);
		FrontTransformList newtlist = null;
		if (j != 0) newtlist = new FrontTransformList();

		pushTransform();		// get new frame of reference
		for (int i = 1; i <=j; i++)
		{
			// build up incremental transformations
			FrontTransformEntry temp = removeFrontTransformEntry(list);
			if (temp.kind == MIRROR)
			{
				mirrorMatrix(temp.xCoord);
			} else if (temp.kind == TRANSLATE)
			{
				if (isInCellDefinition && cellScaleFactor != 1.0)
				{
					temp.xt = (int)(cellScaleFactor * temp.xt);
					temp.yt = (int)(cellScaleFactor * temp.yt);
				}