jelibparser.java

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

						case 'F': objArray = new Float[limit];          break;
						case 'G': objArray = new Long[limit];           break;
						case 'H': objArray = new Short[limit];          break;
						case 'I': objArray = new Integer[limit];        break;
						case 'L': objArray = new LibId[limit];          break;
						case 'O': objArray = new Tool[limit];           break;
						case 'P': objArray = new PrimitiveNodeId[limit];break;
						case 'R': objArray = new ArcProtoId[limit];     break;
						case 'S': objArray = new String[limit];         break;
						case 'T': objArray = new TechId[limit];         break;
						case 'V': objArray = new EPoint[limit];         break;
						case 'Y': objArray = new Byte[limit];           break;
                        default: throw new AssertionError();
					}
					for(int j=0; j<limit; j++)
						objArray[j] = objList.get(j);
					obj = objArray;
				} else
				{
					// a scalar Variable
					obj = getVariableValue(piece.substring(objectPos), varType);
                    if (obj == null) {
                        // ????
                        continue;
                    }
				}
			}

			// create the variable
            TextDescriptorAndCode tdc = loadTextDescriptor(varBits, true);
            obj = Variable.withCode(obj, tdc.code);
            Variable d = Variable.newInstance(varKey, obj, tdc.td);
            variablesBuf.add(d);
		}
        return variablesBuf.toArray(Variable.NULL_ARRAY);
	}

	/**
	 * Method to load a TextDescriptor from a String description of it.
	 * @param varBits the String that describes the TextDescriptor.
     * @param onVar true if this TextDescriptor resides on a Variable
	 * It may be false if the TextDescriptor is on a NodeInst or Export.
	 * @return loaded TextDescriptor
	 */
	private TextDescriptorAndCode loadTextDescriptor(String varBits, boolean onVar)
	{
        HashMap<String,TextDescriptorAndCode> parsedDescriptors = onVar ? parsedDescriptorsT : parsedDescriptorsF;
        TextDescriptorAndCode tdc = parsedDescriptors.get(varBits);
        if (tdc != null) return tdc;

        boolean error = false;
        mtd.setCBits(0, 0, 0);
        CodeExpression.Code code = CodeExpression.Code.NONE;
        if (!onVar) mtd.setDisplay(TextDescriptor.Display.SHOWN);
		double xoff = 0, yoff = 0;
		for(int j=0; j<varBits.length(); j++)
		{
			char varBit = varBits.charAt(j);
			switch (varBit)
			{
				case 'D':		// display position
				case 'd':		// display position
					mtd.setDisplay(varBit == 'D' ? TextDescriptor.Display.SHOWN : TextDescriptor.Display.HIDDEN);
					j++;
					if (j >= varBits.length())
					{
						logError("Incorrect display specification: " + varBits);
                        error = true;
						break;
					}
					switch (varBits.charAt(j))
					{
						case '5': mtd.setPos(TextDescriptor.Position.CENT);       break;
						case '8': mtd.setPos(TextDescriptor.Position.UP);         break;
						case '2': mtd.setPos(TextDescriptor.Position.DOWN);       break;
						case '4': mtd.setPos(TextDescriptor.Position.LEFT);       break;
						case '6': mtd.setPos(TextDescriptor.Position.RIGHT);      break;
						case '7': mtd.setPos(TextDescriptor.Position.UPLEFT);     break;
						case '9': mtd.setPos(TextDescriptor.Position.UPRIGHT);    break;
						case '1': mtd.setPos(TextDescriptor.Position.DOWNLEFT);   break;
						case '3': mtd.setPos(TextDescriptor.Position.DOWNRIGHT);  break;
						case '0': mtd.setPos(TextDescriptor.Position.BOXED);      break;
					}
					break;
				case 'N':		// display type
					mtd.setDispPart(TextDescriptor.DispPos.NAMEVALUE);
					break;
				case 'A':		// absolute text size
					int semiPos = varBits.indexOf(';', j);
					if (semiPos < 0)
					{
						logError("Bad absolute size (semicolon missing): " + varBits);
                        error = true;
						break;
					}
					mtd.setAbsSize(Integer.valueOf(varBits.substring(j+1, semiPos)));
					j = semiPos;
					break;
				case 'G':		// relative text size
					semiPos = varBits.indexOf(';', j);
					if (semiPos < 0)
					{
						logError("Bad relative size (semicolon missing): " + varBits);
                        error = true;
						break;
					}
					mtd.setRelSize(readDouble(varBits.substring(j+1, semiPos)));
					j = semiPos;
					break;
				case 'X':		// X offset
					semiPos = varBits.indexOf(';', j);
					if (semiPos < 0)
					{
						logError("Bad X offset (semicolon missing): " + varBits);
                        error = true;
						break;
					}
					xoff = readDouble(varBits.substring(j+1, semiPos));
					j = semiPos;
					break;
				case 'Y':		// Y offset
					semiPos = varBits.indexOf(';', j);
					if (semiPos < 0)
					{
						logError("Bad Y offset (semicolon missing): " + varBits);
                        error = true;
						break;
					}
					yoff = readDouble(varBits.substring(j+1, semiPos));
					j = semiPos;
					break;
				case 'B':		// bold
					mtd.setBold(true);
					break;
				case 'I':		// italic
					mtd.setItalic(true);
					break;
				case 'L':		// underlined
					mtd.setUnderline(true);
					break;
				case 'F':		// font
					semiPos = varBits.indexOf(';', j);
					if (semiPos < 0)
					{
						logError("Bad font (semicolon missing): " + varBits);
                        error = true;
						break;
					}
					TextDescriptor.ActiveFont af = TextDescriptor.ActiveFont.findActiveFont(varBits.substring(j+1, semiPos));
                    if (af != null)
                        mtd.setFace(af.getIndex());
					j = semiPos;
					break;
				case 'C':		// color
					semiPos = varBits.indexOf(';', j);
					if (semiPos < 0)
					{
						logError("Bad color (semicolon missing): " + varBits);
                        error = true;
						break;
					}
					mtd.setColorIndex(Integer.valueOf(varBits.substring(j+1, semiPos)));
					j = semiPos;
					break;
				case 'R':		// rotation
					TextDescriptor.Rotation rot = TextDescriptor.Rotation.ROT90;
					if (j+1 < varBits.length() && varBits.charAt(j+1) == 'R')
					{
						rot = TextDescriptor.Rotation.ROT180;
						j++;
					}
					if (j+1 < varBits.length() && varBits.charAt(j+1) == 'R')
					{
						rot = TextDescriptor.Rotation.ROT270;
						j++;
					}
					mtd.setRotation(rot);
					break;
				case 'H':		// inheritable
					mtd.setInherit(true);
					break;
				case 'T':		// interior
					mtd.setInterior(true);
					break;
				case 'P':		// parameter
					mtd.setParam(true);
					break;
				case 'O':		// code
					j++;
					if (j >= varBits.length())
					{
						logError("Bad language specification: " + varBits);
                        error = true;
						break;
					}
					char codeLetter = varBits.charAt(j);
					if (!onVar)
					{
						logError("Illegal use of language specification: " + varBits);
						error = true;
						break;
					}
                    switch (codeLetter) {
                        case 'J': code = CodeExpression.Code.JAVA; break;
                        case 'L': code = CodeExpression.Code.SPICE; break;
                        case 'T': code = CodeExpression.Code.TCL; break;
                        default:
                            logError("Unknown language specification: " + varBits);
                            error = true;
                    }
					break;
				case 'U':		// units
					j++;
					if (j >= varBits.length())
					{
						logError("Bad units specification: " + varBits);
                        error = true;
						break;
					}
					char unitsLetter = varBits.charAt(j);
					if (unitsLetter == 'R') mtd.setUnit(TextDescriptor.Unit.RESISTANCE); else
					if (unitsLetter == 'C') mtd.setUnit(TextDescriptor.Unit.CAPACITANCE); else
					if (unitsLetter == 'I') mtd.setUnit(TextDescriptor.Unit.INDUCTANCE); else
					if (unitsLetter == 'A') mtd.setUnit(TextDescriptor.Unit.CURRENT); else
					if (unitsLetter == 'V') mtd.setUnit(TextDescriptor.Unit.VOLTAGE); else
					if (unitsLetter == 'D') mtd.setUnit(TextDescriptor.Unit.DISTANCE); else
					if (unitsLetter == 'T') mtd.setUnit(TextDescriptor.Unit.TIME); else
					{
						logError("Unknown units specification: " + varBits);
                        error = true;
					}
					break;
			}
		}
		mtd.setOff(xoff, yoff);
		TextDescriptor td = TextDescriptor.newTextDescriptor(mtd);
        tdc = new TextDescriptorAndCode(td, code);
        if (!error) parsedDescriptors.put(varBits, tdc);
        return tdc;
	}

	/**
	 * Method to convert a String to an Object so that it can be stored in a Variable.
	 * @param piece the String to be converted.
	 * @param varType the type of the object to convert (a letter from the file).
	 * @return the Object representation of the given String.
	 */
	private Object getVariableValue(String piece, char varType)
	{
		int colonPos;
		String libName;
		int secondColonPos;
		String cellName;
		int commaPos;

        if (piece.length() == 0)
            return null;
		if (revision >= 1)
			piece = unQuote(piece);
		switch (varType)
		{
			case 'B':		// Boolean
				return new Boolean(piece.charAt(0)=='T' ? true : false);
			case 'C':		// Cell (should delay analysis until database is built!!!)
				if (piece.length() == 0) return null;
				colonPos = piece.indexOf(':');
				if (colonPos < 0)
				{
					logError("Badly formed Cell (missing colon): " + piece);
					break;
				}
				libName = piece.substring(0, colonPos);
                LibId libId = idManager.newLibId(libName);
				cellName = piece.substring(colonPos+1);
				commaPos = cellName.indexOf(',');
				if (commaPos >= 0) cellName = cellName.substring(0, commaPos);
                return libId.newCellId(CellName.parseName(cellName));
			case 'D':		// Double
				return Double.valueOf(piece);
			case 'E':		// Export (should delay analysis until database is built!!!)
				colonPos = piece.indexOf(':');
				if (colonPos < 0)
				{
					logError("Badly formed Export (missing library colon): " + piece);
					break;
				}
				libName = piece.substring(0, colonPos);
                libId = idManager.newLibId(libName);
				secondColonPos = piece.indexOf(':', colonPos+1);
				if (secondColonPos < 0)
				{
					logError("Badly formed Export (missing cell colon): " + piece);
					break;
				}
				cellName = piece.substring(colonPos+1, secondColonPos);
                CellId cellId = libId.newCellId(CellName.parseName(cellName));
				String exportName = piece.substring(secondColonPos+1);
				commaPos = exportName.indexOf(',');
				if (commaPos >= 0) exportName = exportName.substring(0, commaPos);
                return cellId.newPortId(exportName);
			case 'F':		// Float
				return Float.valueOf(piece);
			case 'G':		// Long
				return Long.valueOf(piece);
			case 'H':		// Short
				return Short.valueOf(piece);
			case 'I':		// Integer
				return Integer.valueOf(piece);
			case 'L':		// Library (should delay analysis until database is built!!!)
				libName = piece;
				commaPos = libName.indexOf(',');
				if (commaPos >= 0) libName = libName.substring(0, commaPos);
				return idManager.newLibId(libName);
			case 'O':		// Tool
				String toolName = piece;
				commaPos = toolName.indexOf(',');
				if (commaPos >= 0) toolName = toolName.substring(0, commaPos);
				Tool tool = Tool.findTool(toolName);
				if (tool == null)
					logError("Unknown Tool: " + piece);
				return tool;
			case 'P':		// PrimitiveNodeId
				colonPos = piece.indexOf(':');
				if (colonPos < 0)
				{
					logError("Badly formed PrimitiveNode (missing colon): " + piece);
					break;
				}
				String techName = piece.substring(0, colonPos);
                TechId techId = idManager.newTechId(techName);
				String nodeName = piece.substring(colonPos+1);
				commaPos = nodeName.indexOf(',');
				if (commaPos >= 0) nodeName = nodeName.substring(0, commaPos);
				return techId.newPrimitiveNodeId(nodeName);
			case 'R':		// ArcProtoId
				colonPos = piece.indexOf(':');
				if (colonPos < 0)
				{
					logError("Badly formed ArcProto (missing colon): " + piece);
					break;
				}
				techName = piece.substring(0, colonPos);
                techId = idManager.newTechId(techName);
				String arcName = piece.substring(colonPos+1);
				commaPos = arcName.indexOf(',');
				if (commaPos >= 0) arcName = arcName.substring(0, commaPos);
				return techId.newArcProtoId(arcName);
			case 'S':		// String
				if (revision >= 1) return piece;
				if (piece.charAt(0) != '"')
				{
					logError("Badly formed string variable (missing open quote): " + piece);
					break;
				}
				StringBuffer sb = new StringBuffer();
				int len = piece.length();
				int objectPos = 0;
				while (objectPos < len)
				{
					objectPos++;
					if (piece.charAt(objectPos) == '"') break;
					if (piece.charAt(objectPos) == '^')
					{
						objectPos++;
						if (objectPos <= len - 2 && piece.charAt(objectPos) == '\\' && piece.charAt(objectPos+1) == 'n')
						{
							sb.append('\n');
							objectPos++;
							continue;
						}
					}
					sb.append(piece.charAt(objectPos));
				}
				return sb.toString();
			case 'T':		// TechId
				techName = piece;
				commaPos = techName.indexOf(',');
				if (commaPos >= 0) techName = techName.substring(0, commaPos);
                return idManager.newTechId(techName);
			case 'V':		// Point2D
				int slashPos = piece.indexOf('/');
				if (slashPos < 0)
				{
					logError("Badly formed Point2D variable (missing slash): " + piece);
					break;
				}
				double x = Double.valueOf(piece.substring(0, slashPos));
				double y = Double.valueOf(piece.substring(slashPos+1));
				return new EPoint(x, y);
			case 'Y':		// Byte
				return Byte.valueOf(piece);
		}
		return null;
	}

    private static double readDouble(String s) {
        return s.length() > 0 ? Double.parseDouble(s) : 0;
    }

    private void logError(String message) {
        String s = curReadFile + ", line " + lineReader.getLineNumber() + ", " + message;
        errorLogger.logError(s, -1);
    }

    private void logWarning(String message) {
        String s = curReadFile + ", line " + lineReader.getLineNumber() + ", " + message;
        errorLogger.logWarning(s, null, -1);
    }

    private void logError(String message, CellId cellId) {
        String s = curReadFile + ", line " + lineReader.getLineNumber() + ", " + message;
        errorLogger.logError(s, cellId, -1);
    }
}