techexplorer.java

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

//            l.resistance = (Double)Layer_getResistance.invoke(layer);
//            l.capacitance = (Double)Layer_getCapacitance.invoke(layer);
//            l.edgeCapacitance = (Double)Layer_getEdgeCapacitance.invoke(layer);
//            t.layers.add(l);
//        }
//        if (Technology_getNumMetals != null)
//            maxMetal = (Integer)Technology_getNumMetals.invoke(tech);
//        t.minNumMetals = t.maxNumMetals = t.defaultNumMetals = maxMetal;
//
//        HashSet<Object> arcPins = new HashSet<Object>();
//        Map<String,?> oldArcNames = Technology_getOldArcNames != null ? (Map)Technology_getOldArcNames.invoke(tech) : Collections.emptyMap();
//        for (Iterator<?> it = (Iterator)Technology_getArcs.invoke(tech); it.hasNext(); ) {
//            Object ap = it.next();
//            String arcName = (String)ArcProto_getName.invoke(ap);
//
//            Xml.ArcProto a = new Xml.ArcProto();
//            a.name = arcName;
//            for (Map.Entry<String,?> e: oldArcNames.entrySet()) {
//                if (e.getValue() == ap)
//                    a.oldName = e.getKey();
//            }
//            a.function = ArcProtoFunctions.get(ArcProto_getFunction.invoke(ap));
//            a.wipable = (Boolean)ArcProto_isWipable.invoke(ap);
//            a.curvable = (Boolean)ArcProto_isCurvable.invoke(ap);
//            a.special = ArcProto_isSpecialArc != null && (Boolean)ArcProto_isSpecialArc.invoke(ap);
//            a.skipSizeInPalette = ArcProto_isSkipSizeInPalette != null && (Boolean)ArcProto_isSkipSizeInPalette.invoke(ap);
//            a.notUsed = (Boolean)ArcProto_isNotUsed.invoke(ap);
//            a.extended = (Boolean)ArcProto_isExtended.invoke(ap);
//            a.fixedAngle = (Boolean)ArcProto_isFixedAngle.invoke(ap);
//            a.angleIncrement = (Integer)ArcProto_getAngleIncrement.invoke(ap);
//            if (ERC_getAntennaRatio != null)
//                a.antennaRatio = (Double)ERC_getAntennaRatio.invoke(ERC_tool.get(null), ap);
//            else if (ArcProto_getAntennaRatio != null)
//                a.antennaRatio = (Double)ArcProto_getAntennaRatio.invoke(ap);
//            double defaultFullWidth = 0;
//            if (ArcProto_getDefaultLambdaFullWidth != null)
//                defaultFullWidth = (Double)ArcProto_getDefaultLambdaFullWidth.invoke(ap);
//            else if (ArcProto_getDefaultWidth != null)
//                defaultFullWidth = (Double)ArcProto_getDefaultWidth.invoke(ap);
//            double widthOffset = 0;
//            if (ArcProto_getLambdaElibWidthOffset != null)
//                widthOffset = (Double)ArcProto_getLambdaElibWidthOffset.invoke(ap);
//            else if (ArcProto_getLambdaWidthOffset != null)
//                widthOffset = (Double)ArcProto_getLambdaWidthOffset.invoke(ap);
//            else if (ArcProto_getWidthOffset != null)
//                widthOffset = (Double)ArcProto_getWidthOffset.invoke(ap);
//            a.elibWidthOffset = round(widthOffset);
//            Object[] arcLayers = (Object[])ArcProto_layers.get(ap);
//            for (Object arcLayer: arcLayers) {
//                Xml.ArcLayer al = new Xml.ArcLayer();
//                al.layer = (String)Layer_getName.invoke(TechnologyArcLayer_getLayer.invoke(arcLayer));
//                al.style = PolyTypes.get(TechnologyArcLayer_getStyle.invoke(arcLayer));
//                double extend = 0;
//                if (TechnologyArcLayer_getGridExtend != null) {
//                    extend = DBMath.gridToLambda((Integer)TechnologyArcLayer_getGridExtend.invoke(arcLayer));
//                } else {
//                    double offset = 0;
//                    if (TechnologyArcLayer_getLambdaOffset != null)
//                        offset = (Double)TechnologyArcLayer_getLambdaOffset.invoke(arcLayer);
//                    else if (TechnologyArcLayer_getOffset != null)
//                        offset = (Double)TechnologyArcLayer_getOffset.invoke(arcLayer);
//                    extend = 0.5*(defaultFullWidth - offset);
//                }
//                al.extend.addLambda(round(extend));
//                a.arcLayers.add(al);
//            }
//            t.arcs.add(a);
//            a.arcPin = makeWipablePin(tech, ap, arcPins);
//        }
//
//        Map<String,?> oldNodeNames = Technology_getOldNodeNames != null ? (Map)Technology_getOldNodeNames.invoke(tech) : Collections.emptyMap();
//        for (Iterator<?> it = (Iterator)Technology_getNodes.invoke(tech); it.hasNext(); ) {
//            Object pn = it.next();
//            if (arcPins.contains(pn)) continue;
//            String nodeName = (String)PrimitiveNode_getName.invoke(pn);
//            PrimitiveNode.Function fun = PrimitiveNodeFunctions.get(PrimitiveNode_getFunction.invoke(pn));
//            Object[] nodeLayersArray = (Object[])PrimitiveNode_getLayers.invoke(pn);
//            double defWidth = (Double)PrimitiveNode_getDefWidth.invoke(pn);
//            double defHeight = (Double)PrimitiveNode_getDefHeight.invoke(pn);
//            Iterator<?> ports = (Iterator)PrimitiveNode_getPorts.invoke(pn);
//            if (fun == PrimitiveNode.Function.NODE && nodeLayersArray.length == 1) {
//                Xml.PureLayerNode pln = new Xml.PureLayerNode();
//                pln.name = nodeName;
//                for (Map.Entry<String,?> e: oldNodeNames.entrySet()) {
//                    if (e.getValue() == pn)
//                        pln.oldName = e.getKey();
//                }
//                Object port = ports.next();
//                pln.port = (String)PrimitivePort_getName.invoke(port);
//                pln.style = PolyTypes.get(TechnologyNodeLayer_getStyle.invoke(nodeLayersArray[0]));
//                pln.size.addLambda(round(defWidth));
//                makePortArcs(pln.portArcs, tech, port, null);
//                Xml.Layer layer = t.findLayer((String)Layer_getName.invoke(TechnologyNodeLayer_getLayer.invoke(nodeLayersArray[0])));
//                layer.pureLayerNode = pln;
//                continue;
//            }
//
//            Xml.PrimitiveNode n = new Xml.PrimitiveNode();
//            n.name = nodeName;
//            for (Map.Entry<String,?> e: oldNodeNames.entrySet()) {
//                if (e.getValue() == pn)
//                    n.oldName = e.getKey();
//            }
//            n.function = fun;
//            n.shrinkArcs = (Boolean)PrimitiveNode_isArcsShrink.invoke(pn);
//            n.square = (Boolean)PrimitiveNode_isSquare.invoke(pn);
//            n.canBeZeroSize = (Boolean)PrimitiveNode_isCanBeZeroSize.invoke(pn);
//            n.wipes = (Boolean)PrimitiveNode_isWipeOn1or2.invoke(pn);
//            n.lockable = (Boolean)PrimitiveNode_isLockedPrim.invoke(pn);
//            n.edgeSelect = (Boolean)PrimitiveNode_isEdgeSelect.invoke(pn);
//            if (PrimitiveNode_isSkipSizeInPalette != null)
//                n.skipSizeInPalette = (Boolean)PrimitiveNode_isSkipSizeInPalette.invoke(pn);
//            n.notUsed = (Boolean)PrimitiveNode_isNotUsed.invoke(pn);
//            if (PrimitiveNode_LOWVTBIT != null)
//                n.lowVt = (Boolean)PrimitiveNode_isNodeBitOn.invoke(pn, PrimitiveNode_LOWVTBIT.get(null));
//            if (PrimitiveNode_HIGHVTBIT != null)
//                n.highVt = (Boolean)PrimitiveNode_isNodeBitOn.invoke(pn, PrimitiveNode_HIGHVTBIT.get(null));
//            if (PrimitiveNode_NATIVEBIT != null)
//                n.nativeBit = (Boolean)PrimitiveNode_isNodeBitOn.invoke(pn, PrimitiveNode_NATIVEBIT.get(null));
//            if (PrimitiveNode_OD18BIT != null)
//                n.od18 = (Boolean)PrimitiveNode_isNodeBitOn.invoke(pn, PrimitiveNode_OD18BIT.get(null));
//            if (PrimitiveNode_OD25BIT != null)
//                n.od25 = (Boolean)PrimitiveNode_isNodeBitOn.invoke(pn, PrimitiveNode_OD25BIT.get(null));
//            if (PrimitiveNode_OD33BIT != null)
//                n.od33 = (Boolean)PrimitiveNode_isNodeBitOn.invoke(pn, PrimitiveNode_OD33BIT.get(null));
//
//            double minWidth = 0, minHeight = 0;
//            String minSizeRule = null;
//            if (classPrimitiveNodeNodeSizeRule != null) {
//                Object rule = PrimitiveNode_getMinSizeRule.invoke(pn);
//                if (rule != null) {
//                    minWidth = (Double)PrimitiveNodeNodeSizeRule_getWidth.invoke(rule);
//                    minHeight = (Double)PrimitiveNodeNodeSizeRule_getHeight.invoke(rule);
//                    minSizeRule = (String)PrimitiveNodeNodeSizeRule_getRuleName.invoke(rule);
//                }
//            } else {
//                minWidth = (Double)PrimitiveNode_getMinWidth.invoke(pn);
//                minHeight = (Double)PrimitiveNode_getMinHeight.invoke(pn);
//                minSizeRule = (String)PrimitiveNode_getMinSizeRule.invoke(pn);
//                if (minWidth == -1 && minHeight == -1 && minSizeRule.equals(""))
//                    minSizeRule = null;
//            }
//            EPoint minFullSize;
//            if (minSizeRule != null) {
//                n.nodeSizeRule = new Xml.NodeSizeRule();
//                n.nodeSizeRule.width = minWidth;
//                n.nodeSizeRule.height = minHeight;
//                n.nodeSizeRule.rule = minSizeRule;
//                minFullSize = EPoint.fromLambda(0.5*minWidth, 0.5*minHeight);
//            } else {
//                minFullSize = EPoint.fromLambda(0.5*defWidth, 0.5*defHeight);
//            }
//            n.spiceTemplate = null; // ??????????
//
//            ERectangle nodeBase;
//            if (PrimitiveNode_getBaseRectangle != null) {
//                Rectangle2D baseRectangle = (Rectangle2D)PrimitiveNode_getBaseRectangle.invoke(pn);
//                nodeBase = ERectangle.fromLambda(baseRectangle);
//            } else {
//                double lx = -minFullSize.getLambdaX();
//                double hx = minFullSize.getLambdaX();
//                double ly = -minFullSize.getLambdaY();
//                double hy = minFullSize.getLambdaY();
//                Object sizeOffset = PrimitiveNode_getProtoSizeOffset.invoke(pn);
//                if (sizeOffset != null) {
//                    lx += (Double)SizeOffset_getLowXOffset.invoke(sizeOffset);
//                    hx -= (Double)SizeOffset_getHighXOffset.invoke(sizeOffset);
//                    ly += (Double)SizeOffset_getLowYOffset.invoke(sizeOffset);
//                    hy -= (Double)SizeOffset_getHighYOffset.invoke(sizeOffset);
//                }
//                nodeBase = ERectangle.fromLambda(lx, ly, hx - lx, hy - ly);
//            }
//            n.nodeBase = nodeBase;
//            if (!minFullSize.equals(EPoint.ORIGIN))
//                n.diskOffset = minFullSize;
////            EPoint p2 = EPoint.fromGrid(nodeBase.getGridWidth() >> 1, nodeBase.getGridHeight() >> 1);
////            if (!p2.equals(minFullSize))
////                n.diskOffset.put(Integer.valueOf(1), minFullSize);
////            if (!p2.equals(EPoint.ORIGIN))
////                n.diskOffset.put(Integer.valueOf(2), p2);
//            n.defaultWidth.addLambda(round(defWidth - 2*minFullSize.getLambdaX()));
//            n.defaultHeight.addLambda(round(defHeight - 2*minFullSize.getLambdaY()));
//
//            List<?> nodeLayers = Arrays.asList(nodeLayersArray);
//            Object[] electricalNodeLayersArray = (Object[])PrimitiveNode_getElectricalLayers.invoke(pn);
//            List<?> electricalNodeLayers = nodeLayers;
//            if (electricalNodeLayersArray != null)
//                electricalNodeLayers = Arrays.asList(electricalNodeLayersArray);
//            boolean isSerp = (Integer)PrimitiveNode_getSpecialType.invoke(pn) == PrimitiveNode.SERPTRANS;
//            int m = 0;
//            for (Object nld: electricalNodeLayers) {
//                int j = nodeLayers.indexOf(nld);
//                if (j < 0) {
//                    n.nodeLayers.add(makeNodeLayerDetails(t, nld, isSerp, minFullSize, false, true));
//                    continue;
//                }
//                while (m < j)
//                    n.nodeLayers.add(makeNodeLayerDetails(t, nodeLayers.get(m++), isSerp, minFullSize, true, false));
//                n.nodeLayers.add(makeNodeLayerDetails(t, nodeLayers.get(m++), isSerp, minFullSize, true, true));
//            }
//            while (m < nodeLayers.size())
//                n.nodeLayers.add(makeNodeLayerDetails(t, nodeLayers.get(m++), isSerp, minFullSize, true, false));
//
//            for (Iterator<?> pit = (Iterator)PrimitiveNode_getPorts.invoke(pn); pit.hasNext(); ) {
//                Object pp = pit.next();
//                Xml.PrimitivePort ppd = new Xml.PrimitivePort();
//                ppd.name = (String)PrimitivePort_getName.invoke(pp);
//                ppd.portAngle = (Integer)PrimitivePort_getAngle.invoke(pp);
//                if (PrimitivePort_getAngleRange != null) {
//                    ppd.portRange = (Integer)PrimitivePort_getAngleRange.invoke(pp);
//                } else {
//                    /** range of valid angles about port angle */		final int PORTARANGE =           0377000;
//                    /** right shift of PORTARANGE field */				final int PORTARANGESH =               9;
//                    ppd.portRange = ((Integer)PrimitivePort_lowLevelGetUserbits.invoke(pp) & PORTARANGE) >> PORTARANGESH;
//                }
//                ppd.portTopology = (Integer)PrimitivePort_getTopology.invoke(pp);
//
//                Object lx = PrimitivePort_getLeft.invoke(pp);
//                Object hx = PrimitivePort_getRight.invoke(pp);
//                Object ly = PrimitivePort_getBottom.invoke(pp);
//                Object hy = PrimitivePort_getTop.invoke(pp);
//                ppd.lx.k = (Double)EdgeH_getMultiplier.invoke(lx)*2;
//                ppd.lx.addLambda(round((Double)EdgeH_getAdder.invoke(lx) + minFullSize.getLambdaX()*ppd.lx.k));
//                ppd.hx.k = (Double)EdgeH_getMultiplier.invoke(hx)*2;
//                ppd.hx.addLambda(round((Double)EdgeH_getAdder.invoke(hx) + minFullSize.getLambdaX()*ppd.hx.k));
//                ppd.ly.k = (Double)EdgeV_getMultiplier.invoke(ly)*2;
//                ppd.ly.addLambda(round((Double)EdgeV_getAdder.invoke(ly) + minFullSize.getLambdaY()*ppd.ly.k));
//                ppd.hy.k = (Double)EdgeV