techexplorer.java

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

            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));

            EPoint sizeCorrector1 = null;
            EPoint sizeCorrector2 = null;
            if (PrimitiveNode_getSizeCorrector != null) {
                sizeCorrector1 = EPoint.snap((Point2D)PrimitiveNode_getSizeCorrector.invoke(pn, 0));
                sizeCorrector2 = EPoint.snap((Point2D)PrimitiveNode_getSizeCorrector.invoke(pn, 1));
            }
            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 fullSize = null;
            if (minSizeRule != null) {
                n.nodeSizeRule = new Xml.NodeSizeRule();
                n.nodeSizeRule.width = minWidth;
                n.nodeSizeRule.height = minHeight;
                n.nodeSizeRule.rule = minSizeRule;
                fullSize = EPoint.fromLambda(0.5*minWidth, 0.5*minHeight);
            } else if (PrimitiveNode_getFullRectangle != null) {
                Rectangle2D r = (Rectangle2D)PrimitiveNode_getFullRectangle.invoke(pn);
                fullSize = EPoint.fromLambda(0.5*r.getWidth(), 0.5*r.getHeight());
            } else {
                fullSize = sizeCorrector1;
            }
            if (fullSize == null)
                fullSize = EPoint.fromLambda(0.5*defWidth, 0.5*defHeight);
            ERectangle fullRectangle = ERectangle.fromLambda(-fullSize.getX(), -fullSize.getY(),
                    2*fullSize.getX(), 2*fullSize.getY());
            ERectangle baseRectangle;
            if (PrimitiveNode_getBaseRectangle != null) {
                baseRectangle = ERectangle.fromLambda((Rectangle2D)PrimitiveNode_getBaseRectangle.invoke(pn));
            } else {
                double lx = fullRectangle.getLambdaMinX();
                double hx = fullRectangle.getLambdaMaxX();
                double ly = fullRectangle.getLambdaMinY();
                double hy = fullRectangle.getLambdaMaxY();
                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);
                }
                baseRectangle = ERectangle.fromLambda(lx, ly, hx - lx, hy - ly);
            }
            if (!baseRectangle.equals(fullRectangle)) {
                n.sizeOffset = new SizeOffset(
                    baseRectangle.getLambdaMinX() - fullRectangle.getLambdaMinX(),
                    fullRectangle.getLambdaMaxX() - baseRectangle.getLambdaMaxX(),
                    baseRectangle.getLambdaMinY() - fullRectangle.getLambdaMinY(),
                    fullRectangle.getLambdaMaxY() - baseRectangle.getLambdaMaxY());
            }
            if (sizeCorrector1 == null)
                sizeCorrector1 = fullSize;
            if (sizeCorrector2 == null)
                sizeCorrector2 = EPoint.fromGrid(baseRectangle.getGridWidth() >> 1, baseRectangle.getGridHeight() >> 1);
            if (!sizeCorrector2.equals(sizeCorrector1))
                n.diskOffset.put(Integer.valueOf(1), sizeCorrector1);
            if (!sizeCorrector2.equals(EPoint.ORIGIN))
                n.diskOffset.put(Integer.valueOf(2), sizeCorrector2);
            n.defaultWidth.addLambda(round(defWidth - fullRectangle.getLambdaWidth()));
            n.defaultHeight.addLambda(round(defHeight - fullRectangle.getLambdaHeight()));

            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, fullSize, false, true));
                    continue;
                }
                while (m < j)
                    n.nodeLayers.add(makeNodeLayerDetails(t, nodeLayers.get(m++), isSerp, fullSize, true, false));
                n.nodeLayers.add(makeNodeLayerDetails(t, nodeLayers.get(m++), isSerp, fullSize, true, true));
            }
            while (m < nodeLayers.size())
                n.nodeLayers.add(makeNodeLayerDetails(t, nodeLayers.get(m++), isSerp, fullSize, 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) + fullSize.getLambdaX()*ppd.lx.k));
                ppd.hx.k = (Double)EdgeH_getMultiplier.invoke(hx)*2;
                ppd.hx.addLambda(round((Double)EdgeH_getAdder.invoke(hx) + fullSize.getLambdaX()*ppd.hx.k));
                ppd.ly.k = (Double)EdgeV_getMultiplier.invoke(ly)*2;
                ppd.ly.addLambda(round((Double)EdgeV_getAdder.invoke(ly) + fullSize.getLambdaY()*ppd.ly.k));
                ppd.hy.k = (Double)EdgeV_getMultiplier.invoke(hy)*2;
                ppd.hy.addLambda(round((Double)EdgeV_getAdder.invoke(hy) + fullSize.getLambdaY()*ppd.hy.k));

                makePortArcs(ppd.portArcs, tech, pp, null);
                n.ports.add(ppd);
            }
            n.specialType = (Integer)PrimitiveNode_getSpecialType.invoke(pn);
            double[] specialValues = (double[])PrimitiveNode_getSpecialValues.invoke(pn);
            if (specialValues != null)
                n.specialValues = specialValues.clone();
            if (PrimitiveNode_getSpiceTemplate != null)
                n.spiceTemplate = (String)PrimitiveNode_getSpiceTemplate.invoke(pn);
            t.nodes.add(n);
        }

        addSpiceHeader(t, 1, (String[])Technology_getSpiceHeaderLevel1.invoke(tech));
        addSpiceHeader(t, 2, (String[])Technology_getSpiceHeaderLevel2.invoke(tech));
        addSpiceHeader(t, 3, (String[])Technology_getSpiceHeaderLevel3.invoke(tech));

        if (Technology_getNodesGrouped1 != null || Technology_getNodesGrouped2 != null) {
            Object[][] origPalette = null;
            if (Technology_getNodesGrouped1 != null)
                origPalette = (Object[][])Technology_getNodesGrouped1.invoke(tech);
            else if (Technology_getNodesGrouped2 != null)
                origPalette = (Object[][])Technology_getNodesGrouped2.invoke(tech, (Object)null);
            if (origPalette != null) {
                int numRows = origPalette.length;
                int numCols = origPalette[0].length;
                for (Object[] row: origPalette) {
                    assert row.length == numCols;
                }
                t.menuPalette = new Xml.MenuPalette();
                t.menuPalette.numColumns = numCols;
                for (int row = 0; row < numRows; row++) {
                    for (int col = 0; col < numCols; col++) {
                        Object origEntry = origPalette[row][col];
                        Object newEntry = null;
                        ArrayList<Object> newBox = new ArrayList<Object>();
                        if (origEntry instanceof List) {
                            List<?> list = (List<?>)origEntry;
                            for (Object o: list) {
                                if (o instanceof List) {
                                    List<?> list2 = (List<?>)o;
                                    for (Object o2: list2)
                                        newBox.add(makeMenuEntry(t, o2));
                                } else {
                                    newBox.add(makeMenuEntry(t, o));
                                }
                            }
                        } else if (origEntry != null) {
                            newBox.add(makeMenuEntry(t, origEntry));
                        }
                        t.menuPalette.menuBoxes.add(newBox);
                    }
                }
            }
        }
        makeFoundries(t, tech);

        return t;
    }

    private void makeFoundries(Xml.Technology t, Object tech) throws IllegalAccessException, InvocationTargetException {
        if (Technology_getFoundries == null) return;
        
        Object foundries = Technology_getFoundries.invoke(tech);
        Iterator<?> fit = foundries instanceof List ? ((List)foundries).iterator() : (Iterator)foundries;
        for (; fit.hasNext(); ) {
            Object foundry = fit.next();
            Xml.Foundry f = new Xml.Foundry();
            f.name = foundry.toString();
            if (Foundry_getGDSLayers != null) {
                Map<?,String> gdsMap = (Map)Foundry_getGDSLayers.invoke(foundry);
                for (Map.Entry<?,String> e: gdsMap.entrySet()) {
                    String gds = e.getValue();
                    if (gds.length() == 0) continue;
                    Object layer = e.getKey();
                    f.layerGds.put((String)Layer_getName.invoke(layer), gds);
                }
            }

            List<?> rules = (List)Foundry_getRules.invoke(foundry);
            if (rules != null) {
                for (Object rule: rules) {
                    String ruleName = (String)DRCTemplate_ruleName.get(rule);
                    int when = (Integer)DRCTemplate_when.get(rule);
                    final int TSMC = 010000;
                    final int ST = 020000;
                    final int MOSIS = 040000;
                    when = when & ~(TSMC|ST|MOSIS);
                    if (classDRCTemplateDRCMode != null) {
                        int newWhen = 0;
                        for (Map.Entry<Object,DRCTemplate.DRCMode> e: DRCTemplateDRCModes.entrySet()) {