drctemplate.java

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

            case UCONSPA2D:
            case CONSPA:
            case SPACING:
            case SPACINGE:
            case EXTENSION:
            case EXTENSIONGATE:
                if (rule.condition != null)
                    condition = " condition=\"" + rule.condition + "\"";

                String noName = (rule.nodeName != null) ? (" nodeName=\"" + rule.nodeName + "\"") : "";
                String wideValues = (rule.maxWidth > 0) ? (" maxW=\"" + rule.maxWidth + "\""
                        + " minLen=\"" + rule.minLength + "\"") : "";
                out.println("        <LayersRule ruleName=\"" + rule.ruleName + "\""
                        + " layerNames=\"{" + rule.name1 + "," + rule.name2 + "}\""
                        + " type=\""+rule.ruleType+"\""
                        + " when=\"" + whenName + "\""
                        + " value=\"" + rule.getValue(0) + "\""
                        + wideValues
                        + noName
                        + condition
                        + "/>");
                break;
            case SURROUND: // if nodeName==null -> LayersRule
            case ASURROUND:
                String ruleType = "NodeLayersRule";
                String value = " value=\"" + rule.getValue(0) + "\"";
                String layersName = " layerNames=\"{" + rule.name1 + "," + rule.name2 + "}\"";
                if (rule.getValue(0) != rule.getValue(1)) // x and y values
                {
                    value = " valueX=\"" + rule.getValue(0) + "\"" + " valueY=\"" + rule.getValue(1) + "\"";
                }
                noName = " nodeName=\"" + rule.nodeName + "\"";
                if (rule.name2 == null) // conditional surround
                {
                    noName = "";
                    ruleType = "LayerRule";
                    layersName = " layerName=\"" + rule.name1 + "\" condition=\"" + rule.condition + "\"";
                }
                else if (rule.nodeName == null)  // LayersRule
                {
                    noName = "";
                    ruleType = "LayersRule";
                }
                out.println("        <" + ruleType + " ruleName=\"" + rule.ruleName + "\""
                        + layersName
                        + " type=\""+rule.ruleType+"\""
                        + " when=\"" + whenName + "\""
                        + value
                        + noName
                        + "/>");
                break;
            case NODSIZ:
                value = " value=\"" + rule.getValue(0) + "\"";

                if (rule.getValue(0) != rule.getValue(1)) // x and y values
                {
                    value = " valueX=\"" + rule.getValue(0) + "\"" + " valueY=\"" + rule.getValue(1) + "\"";
                }
                out.println("        <NodeRule ruleName=\"" + rule.ruleName + "\""
                        + " type=\""+rule.ruleType+"\""
                        + " when=\"" + whenName + "\""
                        + value
                        + " nodeName=\"" + rule.nodeName + "\""
                        + "/>");
                break;
            case FORBIDDEN:
                if (rule.nodeName != null) {
                    out.println("        <NodeRule ruleName=\"" + rule.ruleName + "\""
                            + " type=\""+rule.ruleType+"\""
                            + " when=\"" + whenName + "\""
                            + " nodeName=\"" + rule.nodeName + "\""
                            + "/>");
                } else {
                    out.println("        <LayersRule ruleName=\"" + rule.ruleName + "\""
                            + " layerNames=\"{" + rule.name1 + "," + rule.name2 + "}\""
                            + " type=\""+rule.ruleType+"\""
                            + " when=\"" + whenName + "\""
                            + "/>");
                }
                break;
            case CUTSURX:
            case CUTSURY:
            case SLOTSIZE:
            default:
                assert false;
                System.out.println("Case not implemented " + rule.ruleType);
        }
    }

    /** Method to build combined name in special spacing rules
     * @param layer
     * @param geo
     * @return combined name in special spacing rules
     */
    public static String getSpacingCombinedName(Layer layer, Geometric geo)
    {
        String n1 = layer.getName() + "-";

        if (geo != null)
        {
            if (geo instanceof NodeInst)
                n1 += ((NodeInst)geo).getProto().getName();
            else
                n1 += ((ArcInst)geo).getProto().getName();
        }
        return n1;
    }


    public static void parseXmlElement(List<DRCTemplate> drcRules, String qName, Attributes attributes)
    {
        boolean layerRule = qName.equals("LayerRule");
        boolean layersRule = qName.equals("LayersRule");
        boolean nodeLayersRule = qName.equals("NodeLayersRule");
        boolean nodeRule = qName.equals("NodeRule");

        if (!layerRule && !layersRule && !nodeLayersRule && !nodeRule) return;

        String ruleName = "", layerNames = "", nodeNames = null, condition = null;
        int when = DRCTemplate.DRCMode.ALL.mode();
        DRCTemplate.DRCRuleType type = DRCTemplate.DRCRuleType.NONE;
        double[] values = new double[2];
        Double maxW = null, minLen = null;

        for (int i = 0; i < attributes.getLength(); i++)
        {
            if (attributes.getQName(i).equals("ruleName"))
                ruleName = attributes.getValue(i);
            else if (attributes.getQName(i).startsWith("layerName"))
                layerNames = attributes.getValue(i);
            else if (attributes.getQName(i).startsWith("nodeName"))
                nodeNames = attributes.getValue(i);
            else if (attributes.getQName(i).startsWith("condition"))
                condition = attributes.getValue(i);
            else if (attributes.getQName(i).equals("type"))
                type = DRCTemplate.DRCRuleType.valueOf(attributes.getValue(i));
            else if (attributes.getQName(i).equals("when"))
            {
                String[] modes = TextUtils.parseString(attributes.getValue(i), "|");
                for (String mode : modes)
                {
                    DRCTemplate.DRCMode m = DRCTemplate.DRCMode.valueOf(mode);
                    when |= m.mode();
                }
            }
            else if (attributes.getQName(i).equals("value"))
            {
                if (attributes.getValue(i).toLowerCase().equals("double.max_value"))
                {
                    values[0] = values[1] = Double.MAX_VALUE;
                }
                else
                {
                    values[0] = values[1] = Double.parseDouble(attributes.getValue(i));
                }
            }
            else if (attributes.getQName(i).equals("valueX"))
                values[0] = Double.parseDouble(attributes.getValue(i));
            else if (attributes.getQName(i).equals("valueY"))
                values[1] = Double.parseDouble(attributes.getValue(i));
            else if (attributes.getQName(i).equals("maxW"))
                maxW = new Double(Double.parseDouble(attributes.getValue(i)));
            else if (attributes.getQName(i).equals("minLen"))
                minLen = new Double(Double.parseDouble(attributes.getValue(i)));
            else
                new Error("Invalid attribute in DRCXMLParser");
        }

        // They could be several layer names or pairs of names for the same rule
        if (layerRule)
        {
            String[] layers = TextUtils.parseString(layerNames, ",");
            for (String layer : layers)
            {
                if (nodeNames == null)
                {
                    DRCTemplate tmp = new DRCTemplate(ruleName, when, type, layer,
                            null, values, null, condition);
                    drcRules.add(tmp);
                }
                else
                {
                    String[] names = TextUtils.parseString(nodeNames, ",");
                    for (String name : names)
                    {
                        DRCTemplate tmp = new DRCTemplate(ruleName, when, type, layer,
                                null, values, name, null);
                        drcRules.add(tmp);
                    }
                }
            }
        }
        else if (nodeRule)
        {
            if (nodeNames == null)
            {
                DRCTemplate tmp = new DRCTemplate(ruleName, when, type, null, null, values, null, null);
                drcRules.add(tmp);
            }
            else
            {
                String[] names = TextUtils.parseString(nodeNames, ",");
                for (String name : names)
                {
                    DRCTemplate tmp = new DRCTemplate(ruleName, when, type,
                            null, null, values, name, null);
                    drcRules.add(tmp);
                }
            }
        }
        else if (layersRule || nodeLayersRule)
        {
            String[] layerPairs = TextUtils.parseString(layerNames, "{}");
            for (String layerPair : layerPairs)
            {
                String[] pair = TextUtils.parseString(layerPair, ",");
                if (pair.length != 2) continue;
                if (nodeNames == null)
                {
                    DRCTemplate tmp;

                    if (maxW == null)
                        tmp = new DRCTemplate(ruleName, when, type, pair[0], pair[1], values, null, condition);
                    else
                        tmp = new DRCTemplate(ruleName, when, type, maxW.doubleValue(), minLen.doubleValue(), pair[0], pair[1], values, -1);

                    if (type == DRCTemplate.DRCRuleType.UCONSPA2D)
                    {
                        tmp.multiCuts = 1;
                        DRCTemplate tmp1 = new DRCTemplate(tmp);
                        tmp1.ruleType = DRCTemplate.DRCRuleType.UCONSPA;
                        drcRules.add(tmp1); // duplicate but with UCONSPA
                        DRCTemplate tmp2 = new DRCTemplate(tmp);
                        tmp1.ruleType = DRCTemplate.DRCRuleType.CONSPA;
                        drcRules.add(tmp2); // duplicate but with CONSPA
                    }
                    
                    drcRules.add(tmp);
                }
                else
                {
                    String[] names = TextUtils.parseString(nodeNames, ",");
                    for (String name : names)
                    {
                        DRCTemplate tmp = null;
                        if (maxW == null)
                            tmp = new DRCTemplate(ruleName, when, type,
                                    pair[0], pair[1], values, name, null);
                        else
                            System.out.println("When do I have this case?");
                        drcRules.add(tmp);
                    }
                }
            }
        }
        else
        {
            assert false;
        }
    }

    /** Class used to store read rules and foundry associated to them */
    public static class DRCXMLBucket implements Serializable
    {
        public List<DRCTemplate> drcRules = new ArrayList<DRCTemplate>();
        public String foundry = Foundry.Type.NONE.getName();
    }

    /** Public XML Parser for DRC decks **/
    public static class DRCXMLParser
    {
        private List<DRCXMLBucket> rulesList = new ArrayList<DRCXMLBucket>();
        private DRCXMLBucket current = null;
        private boolean fullLoaded = true;
        private String fileName;

        public List<DRCXMLBucket> getRules() { return rulesList; }
        public boolean isParseOK() { return fullLoaded; }

        /**
         * Method to parse XML file containing the DRC deck
         * @param fileURL
         * @param verbose
         * @return true if file was loaded without problems
         */
        protected boolean process(URL fileURL, boolean verbose)
        {
            fileName = TextUtils.getFileNameWithoutExtension(fileURL);
            try
            {
                // Factory call
                SAXParserFactory factory = SAXParserFactory.newInstance();
                factory.setNamespaceAware(true);
                factory.setValidating(true);
                // create the parser
                SAXParser parser = factory.newSAXParser();
                URLConnection urlCon = fileURL.openConnection();
                InputStream inputStream = urlCon.getInputStream();

                if (verbose) System.out.println("Parsing XML file \"" + fileURL + "\"");

                DRCXMLHandler handler = new DRCXMLHandler();
                parser.parse(inputStream, handler);
                fullLoaded = handler.passed;

                if (verbose) System.out.println("End Parsing XML file ...");
            }
            catch (Exception e)
            {
                if (verbose) e.printStackTrace();
                fullLoaded = false;
            }
            return fullLoaded;
        }

        private class DRCXMLHandler extends DefaultHandler
        {
            boolean passed;

            DRCXMLHandler()
            {
                passed = true; // by default there is no error in file
            }

            public InputSource resolveEntity (String publicId, String systemId) throws IOException, SAXException
            {
                URL fileURL = this.getClass().getResource("DRC.dtd");
                URLConnection urlCon = fileURL.openConnection();
                InputStream inputStream = urlCon.getInputStream();
                return new InputSource(inputStream);
            }

            public void startElement (String uri, String localName, String qName, Attributes attributes)
            {
                if (qName.equals("DRCRules"))
                    return;
                if (qName.equals("Foundry"))
                {
                    current = new DRCXMLBucket();
                    rulesList.add(current);
                    current.foundry = attributes.getValue(0);
                    return;
                }
                parseXmlElement(current.drcRules, qName, attributes);
            }

            public void fatalError(SAXParseException e)
            {
                System.out.println("Parser Fatal Error: '" + e.getMessage() + "' in line " + e.getLineNumber() + " in '" + fileName + "'.");
                passed = false;
            }

            public void warning(SAXParseException e)
            {
                System.out.println("Parser Warning: '" + e.getMessage() + "' in line " + e.getLineNumber() + " in '" + fileName + "'.");
            }

            public void error(SAXParseException e)
            {
                System.out.println("Parser Error: " + e.getMessage() + "' in line " + e.getLineNumber() + " in '" + fileName + "'.");
                passed = false;
            }
        }
    }
}