xmlparam.java

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

                            if (extraFunStr.equals("depletion_heavy"))
                                curLayer.extraFunction = com.sun.electric.technology.Layer.Function.DEPLETION|com.sun.electric.technology.Layer.Function.HEAVY;
                            else if (extraFunStr.equals("depletion_light"))
                                curLayer.extraFunction = com.sun.electric.technology.Layer.Function.DEPLETION|com.sun.electric.technology.Layer.Function.LIGHT;
                            else if (extraFunStr.equals("enhancement_heavy"))
                                curLayer.extraFunction = com.sun.electric.technology.Layer.Function.ENHANCEMENT|com.sun.electric.technology.Layer.Function.HEAVY;
                            else if (extraFunStr.equals("enhancement_light"))
                                curLayer.extraFunction = com.sun.electric.technology.Layer.Function.ENHANCEMENT|com.sun.electric.technology.Layer.Function.LIGHT;
                            else
                                curLayer.extraFunction = com.sun.electric.technology.Layer.Function.parseExtraName(extraFunStr);
                        }
                    }
                    break;
                case cifLayer:
                    curLayer.cif = a("cif");
                    break;
                case skillLayer:
                    curLayer.skill = a("skill");
                    break;
                case parasitics:
                    curLayer.resistance = Double.parseDouble(a("resistance"));
                    curLayer.capacitance = Double.parseDouble(a("capacitance"));
                    curLayer.edgeCapacitance = Double.parseDouble(a("edgeCapacitance"));
                    break;
                case pureLayerNode:
                    curLayer.pureLayerNode = new PureLayerNode();
                    curLayer.pureLayerNode.name = a("name");
                    String styleStr = a_("style");
                    curLayer.pureLayerNode.style = styleStr != null ? Type.valueOf(styleStr) : Type.FILLED;
                    curLayer.pureLayerNode.port = a("port");
                    break;
                case arcProto:
                    curArc = new ArcProto();
                    curArc.name = a("name");
                    curArc.function = com.sun.electric.technology.ArcProto.Function.valueOf(a("fun"));
                    break;
                case wipable:
                    curArc.wipable = true;
                    break;
                case curvable:
                    curArc.curvable = true;
                    break;
                case special:
                    curArc.special = true;
                    break;
                case notUsed:
                    if (curArc != null)
                        curArc.notUsed = true;
                    if (curNode != null)
                        curNode.notUsed = true;
                    break;
                case skipSizeInPalette:
                    if (curArc != null)
                        curArc.skipSizeInPalette = true;
                    if (curNode != null)
                        curNode.skipSizeInPalette = true;
                    break;
                case arcLayer:
                    ArcLayer arcLay = new ArcLayer();
                    arcLay.layer = a("layer");
                    curDistance = arcLay.extend;
                    arcLay.style = Type.valueOf(a("style"));
                    curArc.arcLayers.add(arcLay);
                    break;
                case arcPin:
                    curArc.arcPin = new ArcPin();
                    curArc.arcPin.name = a("name");
                    curArc.arcPin.portName = a("port");
                    curArc.arcPin.elibSize = Double.valueOf(a("elibSize"));
                    break;
                case primitiveNode:
                    curNode = new PrimitiveNode();
                    curNode.name = a("name");
                    curNode.function = com.sun.electric.technology.PrimitiveNode.Function.valueOf(a("fun"));
                    break;
                case shrinkArcs:
                    curNode.shrinkArcs = true;
                    break;
                case square:
                    curNode.square = true;
                    break;
                case canBeZeroSize:
                    curNode.canBeZeroSize = true;
                    break;
                case wipes:
                    curNode.wipes = true;
                    break;
                case lockable:
                    curNode.lockable = true;
                    break;
                case edgeSelect:
                    curNode.edgeSelect = true;
                    break;
                case lowVt:
                    curNode.lowVt = true;
                    break;
                case highVt:
                    curNode.highVt = true;
                    break;
                case nativeBit:
                    curNode.nativeBit = true;
                    break;
                case od18:
                    curNode.od18 = true;
                    break;
                case od25:
                    curNode.od25 = true;
                    break;
                case od33:
                    curNode.od33 = true;
                    break;
                case diskOffset:
                    curNode.diskOffset = EPoint.fromLambda(Double.parseDouble(a("x")), Double.parseDouble(a("y")));
                    break;
                case defaultWidth:
                    curDistance = curNode.defaultWidth;
                    break;
                case defaultHeight:
                    curDistance = curNode.defaultHeight;
                    break;
                case nodeBase:
                    double lx = Double.parseDouble(a("lx"));
                    double hx = Double.parseDouble(a("hx"));
                    double ly = Double.parseDouble(a("ly"));
                    double hy = Double.parseDouble(a("hy"));
                    curNode.nodeBase = ERectangle.fromLambda(lx, ly, hx - lx, hy - ly);
                    break;
                case nodeLayer:
                    curNodeLayer = new NodeLayer();
                    curNodeLayer.layer = a("layer");
                    curNodeLayer.style = Type.valueOf(a("style"));
                    String portNum = a_("portNum");
                    if (portNum != null)
                        curNodeLayer.portNum = Integer.parseInt(portNum);
                    String electrical = a_("electrical");
                    if (electrical != null) {
                        if (Boolean.parseBoolean(electrical))
                            curNodeLayer.inElectricalLayers = true;
                        else
                            curNodeLayer.inLayers = true;
                    } else {
                        curNodeLayer.inElectricalLayers = curNodeLayer.inLayers = true;
                    }
                    break;
                case box:
                    if (curNodeLayer != null) {
                        curNodeLayer.representation = com.sun.electric.technology.Technology.NodeLayer.BOX;
                        curNodeLayer.lx.k = da_("klx", -1);
                        curNodeLayer.hx.k = da_("khx", 1);
                        curNodeLayer.ly.k = da_("kly", -1);
                        curNodeLayer.hy.k = da_("khy", 1);
                    }
                    if (curPort != null) {
                        curPort.lx.k = da_("klx", -1);
                        curPort.hx.k = da_("khx", 1);
                        curPort.ly.k = da_("kly", -1);
                        curPort.hy.k = da_("khy", 1);
                    }
                    break;
                case points:
                    curNodeLayer.representation = com.sun.electric.technology.Technology.NodeLayer.POINTS;
                    break;
                case multicutbox:
                    curNodeLayer.representation = com.sun.electric.technology.Technology.NodeLayer.MULTICUTBOX;
                    curNodeLayer.lx.k = da_("klx", -1);
                    curNodeLayer.hx.k = da_("khx", 1);
                    curNodeLayer.ly.k = da_("kly", -1);
                    curNodeLayer.hy.k = da_("khy", 1);
                    curNodeLayer.sizeRule = a("sizeRule");
                    curNodeLayer.sepRule = a("sepRule");
                    curNodeLayer.sepRule2D = a_("sepRule2D");
                    break;
                case serpbox:
                    curNodeLayer.representation = com.sun.electric.technology.Technology.NodeLayer.BOX;
                    curNodeLayer.lx.k = da_("klx", -1);
                    curNodeLayer.hx.k = da_("khx", 1);
                    curNodeLayer.ly.k = da_("kly", -1);
                    curNodeLayer.hy.k = da_("khy", 1);
                    curNodeLayer.lWidth = Double.parseDouble(a("lWidth"));
                    curNodeLayer.rWidth = Double.parseDouble(a("rWidth"));
                    curNodeLayer.tExtent = Double.parseDouble(a("tExtent"));
                    curNodeLayer.bExtent = Double.parseDouble(a("bExtent"));
                    break;
                case lambdaBox:
                    if (curNodeLayer != null) {
                        curNodeLayer.lx.addLambda(Double.parseDouble(a("klx")));
                        curNodeLayer.hx.addLambda(Double.parseDouble(a("khx")));
                        curNodeLayer.ly.addLambda(Double.parseDouble(a("kly")));
                        curNodeLayer.hy.addLambda(Double.parseDouble(a("khy")));
                    }
                    if (curPort != null) {
                        curPort.lx.addLambda(Double.parseDouble(a("klx")));
                        curPort.hx.addLambda(Double.parseDouble(a("khx")));
                        curPort.ly.addLambda(Double.parseDouble(a("kly")));
                        curPort.hy.addLambda(Double.parseDouble(a("khy")));
                    }
                    break;
                case techPoint:
                    double xm = Double.parseDouble(a("xm"));
                    double xa = Double.parseDouble(a("xa"));
                    double ym = Double.parseDouble(a("ym"));
                    double ya = Double.parseDouble(a("ya"));
                    TechPoint p = new TechPoint(new EdgeH(xm, xa), new EdgeV(ym, ya));
                    if (curNodeLayer != null)
                        curNodeLayer.techPoints.add(p);
                    break;
                case primitivePort:
                    curPort = new PrimitivePort();
                    curPort.name = a("name");
                    break;
                case portAngle:
                    curPort.portAngle = Integer.parseInt(a("primary"));
                    curPort.portRange = Integer.parseInt(a("range"));
                    break;
                case polygonal:
                    curNode.specialType = com.sun.electric.technology.PrimitiveNode.POLYGONAL;
                    break;
                case serpTrans:
                    curNode.specialType = com.sun.electric.technology.PrimitiveNode.SERPTRANS;
                    curNode.specialValues = new double[6];
                    curSpecialValueIndex = 0;
                    break;
                case minSizeRule:
                    curNode.nodeSizeRule = new NodeSizeRule();
                    curNode.nodeSizeRule.width = Double.parseDouble(a("width"));
                    curNode.nodeSizeRule.height = Double.parseDouble(a("height"));
                    curNode.nodeSizeRule.rule = a("rule");
                    break;
                case spiceTemplate:
                	curNode.spiceTemplate = a("value");
                	break;
                case spiceHeader:
                    curSpiceHeader = new SpiceHeader();
                    curSpiceHeader.level = Integer.parseInt(a("level"));
                    tech.spiceHeaders.add(curSpiceHeader);
                    break;
                case spiceLine:
                    curSpiceHeader.spiceLines.add(a("line"));
                    break;
                    
                case displayStyle:
                    curDisplayStyle = new DisplayStyle();
                    curDisplayStyle.name = a("name");
                    tech.displayStyles.add(curDisplayStyle);
                    break;
                case transparentLayer:
                    curTransparent = Integer.parseInt(a("transparent"));
                    curR = curG = curB = 0;
                    break;
                case transparentColor:
                    curTransparent = Integer.parseInt(a("transparent"));
                    if (curTransparent > 0) {
                        Color color = curDisplayStyle.transparentLayers.get(curTransparent - 1);
                        curR = color.getRed();
                        curG = color.getGreen();
                        curB = color.getBlue();
                    }
                    break;
                case opaqueColor:
                    curR = Integer.parseInt(a("r"));
                    curG = Integer.parseInt(a("g"));
                    curB = Integer.parseInt(a("b"));
                    break;
                case display3D:
                    curLayerDisplayStyle.mode3D = a("mode");
                    curLayerDisplayStyle.factor3D = Double.parseDouble(a("factor"));
                    break;
                    
                case menuPalette:
                    tech.menuPalette = new MenuPalette();
                    tech.menuPalette.numColumns = Integer.parseInt(a("numColumns"));
                    break;
                case menuBox:
                    curMenuBox = new ArrayList<Object>();
                    tech.menuPalette.menuBoxes.add(curMenuBox);
                    break;
                case menuCell:
                    curMenuCell = new MenuCell();
                    curMenuCell.cellName = a("cellName");
                    break;
                case menuNodeInst:
                    curMenuNodeInst = new MenuNodeInst();
                    curMenuNodeInst.protoName = a("protoName");
                    curMenuNodeInst.function =  com.sun.electric.technology.PrimitiveNode.Function.valueOf(a("function"));
                    String rotField = a_("rotation");
                    if (rotField != null) curMenuNodeInst.rotation = Integer.parseInt(rotField);
                    break;
                case menuNodeText:
                    curMenuNodeInst.text = a("text");
                    curMenuNodeInst.fontSize = Double.parseDouble(a("size"));
                    break;
                case rule:
                    String kStr = a_("k");
                    Layer layer = null;
                    Layer layer2 = null;
                    String layerStr = a_("layer");
                    if (layerStr != null) {
                        layer = tech.findLayer(layerStr);
                        assert layer != null;
                    }
                    String layerStr2 = layerStr != null ? a_("layer2") : null;
                    if (layerStr2 != null) {
                        layer2 = tech.findLayer(layerStr2);
                        assert layer2 != null;
                    }
                    curDistance.addRule(a("ruleName"), layer, layer2, kStr != null ? Double.valueOf(kStr) : 1);
                    break;
                case ruleSet:
                    curRuleSet = tech.newRuleSet(a("ruleName"));
                    break;
                case layerRule:
                    curLayerRule = curRuleSet.newLayerRule(a("ruleName"));
                    break;
                case Foundry:
                    curFoundry = new Foundry();
                    curFoundry.name = a("name");
                    tech.foundries.add(curFoundry);
                    break;
                case layerGds:
                    curFoundry.layerGds.put(a("layer"), a("gds"));
                    break;
                case LayerRule:
                case LayersRule:
                case NodeLayersRule:
                case NodeRule:
                    DRCTemplate.parseXmlElement(curFoundry.rules, key.name(), attributes);
                    break;
                default:
                    assert key.hasText;
                    beginCharacters();
//                    System.out.print(">");