techexplorer.java

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

                            int oldMode = (Integer)DRCTemplateDrcMode_mode.invoke(e.getKey());
                            if ((when & oldMode) == oldMode)
                                newWhen |= e.getValue().mode();
                        }
                        when = newWhen;
                    }
                    DRCTemplate.DRCRuleType type = DRCTemplateDRCRuleTypes.get(DRCTemplate_ruleType.get(rule));
                    if (type == null)
                        continue;
                    double maxWidth = (Double)DRCTemplate_maxWidth.get(rule);
                    double minLength = (Double)DRCTemplate_minLength.get(rule);
                    String name1 = (String)DRCTemplate_name1.get(rule);
                    String name2 = (String)DRCTemplate_name2.get(rule);
                    double[] values = null;
                    if (DRCTemplate_values != null) {
                        values = (double[])DRCTemplate_values.get(rule);
                    } else if (DRCTemplate_value1 != null & DRCTemplate_value2 != null) {
                        values = new double[2];
                        values[0] = (Double)DRCTemplate_value1.get(rule);
                        values[1] = (Double)DRCTemplate_value2.get(rule);
                    }
                    values = values.clone();
                    String nodeName = (String)DRCTemplate_nodeName.get(rule);
                    int multiCuts = (Integer)DRCTemplate_multiCuts.get(rule);
                    DRCTemplate r = null;
                    if (nodeName != null)
                        r = new DRCTemplate(ruleName, when, type, name1, name2, values, nodeName, null);
                    else
                        r = new DRCTemplate(ruleName, when, type, maxWidth, minLength, name1, name2, values, multiCuts);
                    f.rules.add(r);
                }
                t.foundries.add(f);
            }
        }
        
    }
    
    private Xml.NodeLayer makeNodeLayerDetails(Xml.Technology t, Object nodeLayer, boolean isSerp, EPoint correction, boolean inLayers, boolean inElectricalLayers)
    throws IllegalAccessException, InvocationTargetException {
        Xml.NodeLayer nld = new Xml.NodeLayer();
        Object layer = TechnologyNodeLayer_getLayer.invoke(nodeLayer);
        layer = Layer_getNonPseudoLayer.invoke(layer);
        nld.layer = (String)Layer_getName.invoke(layer);
        nld.style = PolyTypes.get(TechnologyNodeLayer_getStyle.invoke(nodeLayer));
        nld.portNum = (Integer)TechnologyNodeLayer_getPortNum.invoke(nodeLayer);
        nld.inLayers = inLayers;
        nld.inElectricalLayers = inElectricalLayers;
        nld.representation = (Integer)TechnologyNodeLayer_getRepresentation.invoke(nodeLayer);
        Object[] points = (Object[])TechnologyNodeLayer_getPoints.invoke(nodeLayer);
        if (points != null) {
            if ((nld.representation == Technology.NodeLayer.BOX || nld.representation == Technology.NodeLayer.MULTICUTBOX)) {
                Object lx = TechnologyTechPoint_getX.invoke(points[0]);
                Object hx = TechnologyTechPoint_getX.invoke(points[1]);
                Object ly = TechnologyTechPoint_getY.invoke(points[0]);
                Object hy = TechnologyTechPoint_getY.invoke(points[1]);
                nld.lx.k = (Double)EdgeH_getMultiplier.invoke(lx)*2;
                nld.lx.addLambda(round((Double)EdgeH_getAdder.invoke(lx) + correction.getLambdaX()*nld.lx.k));
                nld.hx.k = (Double)EdgeH_getMultiplier.invoke(hx)*2;
                nld.hx.addLambda(round((Double)EdgeH_getAdder.invoke(hx) + correction.getLambdaX()*nld.hx.k));
                nld.ly.k = (Double)EdgeV_getMultiplier.invoke(ly)*2;
                nld.ly.addLambda(round((Double)EdgeV_getAdder.invoke(ly) + correction.getLambdaY()*nld.ly.k));
                nld.hy.k = (Double)EdgeV_getMultiplier.invoke(hy)*2;
                nld.hy.addLambda(round((Double)EdgeV_getAdder.invoke(hy) + correction.getLambdaY()*nld.hy.k));
            } else {
                for (Object p: points)
                    nld.techPoints.add(correction(p, correction));
            }
        }
        if (TechnologyNodeLayer_getMulticutSizeX != null) {
            nld.sizex = round((Double)TechnologyNodeLayer_getMulticutSizeX.invoke(nodeLayer));
            nld.sizey = round((Double)TechnologyNodeLayer_getMulticutSizeY.invoke(nodeLayer));
            nld.sep1d = round((Double)TechnologyNodeLayer_getMulticutSep1D.invoke(nodeLayer));
            nld.sep2d = round((Double)TechnologyNodeLayer_getMulticutSep2D.invoke(nodeLayer));
        }
        if (isSerp) {
            nld.lWidth = round((Double)TechnologyNodeLayer_getSerpentineLWidth.invoke(nodeLayer));
            nld.rWidth = round((Double)TechnologyNodeLayer_getSerpentineRWidth.invoke(nodeLayer));
            nld.tExtent = round((Double)TechnologyNodeLayer_getSerpentineExtentT.invoke(nodeLayer));
            nld.bExtent = round((Double)TechnologyNodeLayer_getSerpentineExtentB.invoke(nodeLayer));
        }
        return nld;
    }

    private Technology.TechPoint correction(Object p, EPoint correction) throws IllegalAccessException, InvocationTargetException {
        Object oh = TechnologyTechPoint_getX.invoke(p);
        double mx = (Double)EdgeH_getMultiplier.invoke(oh);
        EdgeH h = new EdgeH(mx, (Double)EdgeH_getAdder.invoke(oh) + correction.getLambdaX()*mx*2);
        Object ov = TechnologyTechPoint_getY.invoke(p);
        double my = (Double)EdgeV_getMultiplier.invoke(ov);
        EdgeV v = new EdgeV(my, (Double)EdgeV_getAdder.invoke(ov) + correction.getLambdaY()*my*2);
        return new Technology.TechPoint(h, v);
    }

    private static void addSpiceHeader(Xml.Technology t, int level, String[] spiceLines) {
        if (spiceLines == null) return;
        Xml.SpiceHeader spiceHeader = new Xml.SpiceHeader();
        spiceHeader.level = level;
        for (String spiceLine: spiceLines)
            spiceHeader.spiceLines.add(spiceLine);
        t.spiceHeaders.add(spiceHeader);
    }

    private Object makeMenuEntry(Xml.Technology t, Object entry) throws IllegalAccessException, InvocationTargetException {
        if (classArcProto.isInstance(entry))
            return t.findArc((String)ArcProto_getName.invoke(entry));
        if (classPrimitiveNode.isInstance(entry)) {
            PrimitiveNode.Function fun = PrimitiveNodeFunctions.get(PrimitiveNode_getFunction.invoke(entry));
            String name = (String)PrimitiveNode_getName.invoke(entry);
//            if (fun == PrimitiveNode.Function.PIN) {
//                Xml.MenuNodeInst n = new Xml.MenuNodeInst();
//                n.protoName = name;
//                n.function = PrimitiveNode.Function.PIN;
//                return n;
//            }
            return t.findNode(name);
        }
        if (classNodeInst.isInstance(entry)) {
            Xml.MenuNodeInst n = new Xml.MenuNodeInst();
            n.protoName = (String)PrimitiveNode_getName.invoke(NodeInst_getProto.invoke(entry));
            n.function = PrimitiveNodeFunctions.get(NodeInst_getFunction.invoke(entry));
            n.rotation = (Integer)NodeInst_getAngle.invoke(entry);
            for (Iterator<?> it = (Iterator)ElectricObject_getVariables.invoke(entry); it.hasNext(); ) {
                Object var = it.next();
                Object value = Variable_getObject.invoke(var);
                if (!(value instanceof String)) continue;
                n.text = (String)Variable_getObject.invoke(var);
                Object td = Variable_getTextDescriptor.invoke(var);
                n.fontSize = (Double)TextDescriptorSize_getSize.invoke(TextDescriptor_getSize.invoke(td));
            }
            return n;
        }
        if (entry.getClass().getName().equals("javax.swing.JPopupMenu$Separator"))
            return "SEPARATOR";
        assert entry instanceof String;
        return entry;
    }

    private void makePortArcs(List<String> portArcs, Object tech, Object pp, Object excludeAp) throws IllegalAccessException, InvocationTargetException  {
        Object[] connections = (Object[])PrimitivePort_getConnections.invoke(pp);
        for (Object ap: connections) {
            if (ap == null || ap == excludeAp) continue;
            String arcName = (String)ArcProto_getName.invoke(ap);
            if (Technology_findArcProto.invoke(tech, arcName) != ap) continue;
            portArcs.add(arcName);
        }
    }

    private boolean isPseudoLayer(Object layer) throws IllegalAccessException, InvocationTargetException {
        int extraFun = (Integer)Layer_getFunctionExtras.invoke(layer);
        final int PSEUDO =       010000;
        return (extraFun & PSEUDO) != 0 || Layer_isPseudoLayer != null && (Boolean)Layer_isPseudoLayer.invoke(layer);
    }

    private static double round(double v) {
        v = DBMath.round(v);
        return v;
    }
    
//    public Xml.Technology makeXml(String techName) throws IllegalAccessException, InvocationTargetException {
//        Object tech = Technology_findTechnology.invoke(null, techName);
//
//        Xml.Technology t = new Xml.Technology();
//        t.techName = techName;
//        t.className = tech.getClass().getName();
//        if (t.className.equals("com.sun.electric.technology.Technology"))
//            t.className = null;
//        t.shortTechName = (String)Technology_getTechShortName.invoke(tech);
//        t.description = (String)Technology_getTechDesc.invoke(tech);
//        t.scaleValue = (Double)Technology_getScale.invoke(tech);
//        t.scaleRelevant = (Boolean)Technology_isScaleRelevant.invoke(tech);
//        t.defaultFoundry = "NONE";
//        if (Technology_getPrefFoundry != null)
//            t.defaultFoundry = Technology_getPrefFoundry.invoke(tech).toString();
//        t.minResistance = (Double)Technology_getMinResistance.invoke(tech);
//        t.minCapacitance = (Double)Technology_getMinCapacitance.invoke(tech);
//        int numTransparentLayers = (Integer)Technology_getNumTransparentLayers.invoke(tech);
//        if (numTransparentLayers > 0) {
//            Color[] colorMap = (Color[])Technology_getColorMap.invoke(tech);
//            for (int i = 0; i < numTransparentLayers; i++) {
//                Color transparentColor = colorMap[1 << i];
//                t.transparentLayers.add(transparentColor);
//            }
//        }
//        makeFoundries(t, tech);
//
//        int maxMetal = 0;
//        for (Iterator<?> it = (Iterator)Technology_getLayers.invoke(tech); it.hasNext(); ) {
//            Object layer = it.next();
//            if (isPseudoLayer(layer)) continue;
//            String layerName = (String)Layer_getName.invoke(layer);
//
//            Xml.Layer l = new Xml.Layer();
//            l.name = layerName;
//            Object fun = Layer_getFunction.invoke(layer);
//            l.function = fun != null ? LayerFunctions.get(fun) : Layer.Function.UNKNOWN;
//            if (l.function.isMetal())
//                maxMetal = Math.max(maxMetal, l.function.getLevel());
//            l.extraFunction = (Integer)Layer_getFunctionExtras.invoke(layer);
//            Object desc = Layer_getGraphics.invoke(layer);
//            boolean displayPatterned = (Boolean)EGraphics_isPatternedOnDisplay.invoke(desc);
//            boolean printPatterned = (Boolean)EGraphics_isPatternedOnPrinter.invoke(desc);
//            EGraphics.Outline outlineWhenPatterned = EGraphics.Outline.NOPAT;
//            if (EGraphics_getOutlined != null) {
//                Object outline = EGraphics_getOutlined.invoke(desc);
//                if (outline != null)
//                    outlineWhenPatterned = EGraphicsOutlines.get(outline);
//            } else {
//                if (EGraphics_isOutlinedOnDisplay != null && (Boolean)EGraphics_isOutlinedOnDisplay.invoke(desc))
//                    outlineWhenPatterned = EGraphics.Outline.PAT_S;
//                if (EGraphics_isOutlinedOnPrinter != null && (Boolean)EGraphics_isOutlinedOnPrinter.invoke(desc))
//                    outlineWhenPatterned = EGraphics.Outline.PAT_S;
//            }
//            int transparentLayer = (Integer)EGraphics_getTransparentLayer.invoke(desc);
//            Color color = (Color)EGraphics_getColor.invoke(desc);
//            double opacity = (Double)EGraphics_getOpacity.invoke(desc);
//            boolean foreground = (Boolean)EGraphics_getForeground.invoke(desc);
//            int[] pattern = (int[])EGraphics_getPattern.invoke(desc);
//            l.desc = new EGraphics(displayPatterned, printPatterned, outlineWhenPatterned,
//                    transparentLayer, color.getRed(), color.getGreen(), color.getBlue(), opacity, foreground, pattern);
//            l.thick3D = (Double)Layer_getThickness.invoke(layer);
//            if (Layer_getDistance != null)
//                l.height3D = (Double)Layer_getDistance.invoke(layer);
//            else if (Layer_getHeight != null)
//                l.height3D = (Double)Layer_getHeight.invoke(layer);
//            if (Layer_getTransparencyMode != null)
//                l.mode3D = (String)Layer_getTransparencyMode.invoke(layer);
//            if (Layer_getTransparencyFactor != null)
//                l.factor3D = (Double)Layer_getTransparencyFactor.invoke(layer);
//            l.cif = (String)Layer_getCIFLayer.invoke(layer);
//            l.skill = (String)Layer_getSkillLayer.invoke(layer);