projsettings.java

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

                prIndent("<"+entry+" key=\""+key+"\"\t double=\""+value.toString()+"\" />");
            } else if (value instanceof Long) {
                prIndent("<"+entry+" key=\""+key+"\"\t long=\""+value.toString()+"\" />");
            } else if (value instanceof Boolean) {
                prIndent("<"+entry+" key=\""+key+"\"\t boolean=\""+value.toString()+"\" />");
            } else if (value instanceof String) {
                String str = (String)value;
                prIndent("<"+entry+" key=\""+key+"\"\t string=\""+replaceSpecialChars(str)+"\" />");
            } else {
                prIndent("<"+entry+" key=\""+key+"\"\t string=\""+value+"\" />");
            }
        }

        private void close() {
            if (file != null) out.close();
        }
    }

    private static String replaceSpecialChars(String str) {
        str = str.replace("&", "&amp;");
        str = str.replace("=", "&eq;");
        str = str.replace(">", "&gt;");
        str = str.replace("<", "&lt;");
        str = str.replace("'", "&apos;");
        str = str.replace("\"", "&quot;");
        str = str.replace("\n", "&#xA;");
        return str;
    }

    // ------------------------- ProjSettings Reader ----------------------------

    private enum ReadResult { OK, CONFLICTS, ERROR };

    private static class Reader extends DefaultHandler {
        private URL url;
        private Stack<ProjSettingsNode> context;
        private Locator locator;
        private boolean allowOverride;
        private boolean differencesFound;
        private HashMap<Setting,Object> settings = new HashMap<Setting,Object>();

        private static final boolean DEBUG = false;

        private Reader(URL url) {
            this.url = url;
            this.context = new Stack<ProjSettingsNode>();
            this.locator = null;
            allowOverride = true;
            differencesFound = false;
        }

        private ReadResult read(boolean allowOverride) {
            this.allowOverride = allowOverride;
            try {
                SAXParserFactory factory = SAXParserFactory.newInstance();
                factory.setValidating(true);
                factory.setNamespaceAware(true);
                URLConnection conn = url.openConnection();
                InputStream is = conn.getInputStream();
                factory.newSAXParser().parse(is, this);
                if (READER_RESETS_DEFAULTS)
                    commit(ProjSettings.getSettings());
                else
                    commit0();
                if (differencesFound) return ReadResult.CONFLICTS;
                return ReadResult.OK;
            } catch (IOException e) {
                System.out.println("Error reading file "+url.toString()+": "+e.getMessage());
            } catch (SAXParseException e) {
                System.out.println("Error parsing file "+url.toString()+" on line "+e.getLineNumber()+
                        ", column "+e.getColumnNumber()+": "+e.getMessage());
            } catch (ParserConfigurationException e) {
                System.out.println("Configuration error reading file "+url.toString()+": "+e.getMessage());
            } catch (SAXException e) {
                System.out.println("Exception reading file "+url.toString()+": "+e.getMessage());
            }
            return ReadResult.ERROR;
        }

        public void startElement(String uri, String localName, String qName, Attributes attributes)
            throws SAXException {

            // get the name of the key
            String key = attributes.getValue("key");
            if (key == null) {
                throw parseException("Entry "+qName+" is missing \"key\" attribute");
            }

            // see if this is a project settings node
            if (qName.equals("node")) {
                if (context.isEmpty()) {
                    // first node is root node
                    context.push(ProjSettings.getSettings());
                } else {
                    ProjSettingsNode node = context.peek().getNode(key);
                    if (node == null)
                        System.out.println("Error: No Project Settings Node named "+key+" in Electric");
                    else
                        context.push(node);
                }
            } else if (qName.equals(entry)) {

                // must be a key-value pair
                if (context.isEmpty()) {
                    throw parseException("No node for key-value pair "+qName);
                }
                ProjSettingsNode currentNode = context.peek();
                String valueStr = null;
                Object value = null;
                Setting setting = currentNode.getValue(key);
                try {
                    if ((valueStr = attributes.getValue("string")) != null)
                        value = valueStr;
                    else if ((valueStr = attributes.getValue("int")) != null)
                        value = Integer.valueOf(valueStr);
                    else if ((valueStr = attributes.getValue("double")) != null)
                        value = Double.valueOf(valueStr);
                    else if ((valueStr = attributes.getValue("boolean")) != null)
                        value = Boolean.valueOf(valueStr);
                    else if ((valueStr = attributes.getValue("long")) != null)
                        value = Long.valueOf(valueStr);
                    else
                        System.out.println("Error: Unsupported value for key "+key+", at line "+locator.getLineNumber()+": must be string, int, double, boolean, or long");
                } catch (NumberFormatException e) {
                    System.out.println("Error converting "+valueStr+" to a number at line "+locator.getLineNumber()+": "+e.getMessage());
                }
                if (value != null) {
                    if (setting != null) {
                        settings.put(setting, value);
                    } else if (allowOverride)
                        currentNode.put(key, new ProjSettingsNode.UninitializedPref(value));
                }
            }

            if (DEBUG) {
                System.out.print("Read "+qName+", Attributes: ");
                for (int i=0; i<attributes.getLength(); i++) {
                    System.out.print("["+attributes.getQName(i)+"="+attributes.getValue(i)+"], ");
                }
                System.out.println();
            }
        }

        private void commit(ProjSettingsNode node) {
            for (Object v: node.data.values()) {
                if (v instanceof Setting) {
                    Setting setting = (Setting)v;
                    Object value = settings.get(setting);
                    if (value == null)
                        value = setting.getFactoryValue();
                    prDiff(setting, setting.getValue(), value, allowOverride);
                    if (allowOverride) setting.set(value);
                } else if (v instanceof ProjSettingsNode) {
                    commit((ProjSettingsNode)v);
                }
            }
        }

        private boolean commit0() {
            for (Map.Entry<Setting,Object> e: settings.entrySet()) {
                Setting setting = e.getKey();
                Object value = e.getValue();
                prDiff(setting, setting.getValue(), value, allowOverride);
                if (allowOverride) setting.set(value);
            }
            return differencesFound;

        }

        private void prDiff(Setting setting, Object prefVal, Object xmlVal, boolean allowOverride) {
            if (!ProjSettingsNode.equal(xmlVal, setting)) {
                differencesFound = true;
                if (allowOverride)
                    System.out.println("Warning: Setting \""+setting.getPrefName()+"\" set to "+xmlVal+", overrides current val of "+prefVal);
                else
                    System.out.println("Warning: Setting \""+setting.getPrefName()+"\" retains current val of "+prefVal+", while ignoring projectsettings.xml value of "+xmlVal);
            }
        }

        public void endElement(String uri, String localName, String qName) throws SAXException {
            if (qName.equals("node")) {
                // pop node context
                if (context.isEmpty()) {
                    throw parseException("Empty context, too many closing </> brackets");
                }
                context.pop();
            }
            if (DEBUG) {
                System.out.println("End "+qName);
            }
        }

        public void setDocumentLocator(Locator locator) {
            this.locator = locator;
        }
        private SAXParseException parseException(String msg) {
            return new SAXParseException(msg, locator);
        }
    }

    public static String describeContext(Stack<String> context) {
        StringBuffer buf = new StringBuffer();
        boolean first = true;
        for (String name : context) {
            if (first)
                first = false;
            else
                buf.append(".");
            buf.append(name);
        }
        if (buf.length() == 0) return "RootContext";
        return buf.toString();
    }

    // ------------------------------ Testing -------------------------------

    public static void main(String args[]) {
        test();
    }

    public static void test() {
        write("/tmp/projsettings.xml", getSettings());
        read("/tmp/projsettings.xml", false);
    }

/*
    public static void test2() {
        ProjSettingsNode node = new ProjSettingsNode();
        node.putInteger("an int", 1);
        node.putString("a string", "this is a string");
        ProjSettingsNode node2 = new ProjSettingsNode();
        node.putNode("node2", node2);
        node2.putDouble("a double", 43.56);
        node2.putBoolean("a boolean", true);
        ProjSettingsNode node3 = new TestExtendNode();
        node2.putNode("extended node", node3);
        node3.putLong("a long", 302030049);
        node3.putString("a string", "some string");

        write("/tmp/projsettings.xml", node);
        ProjSettingsNode readNode = read("/tmp/projsettings.xml");
        if (node.printDifferences(readNode)) {
            System.out.println("Node read does not match node written");
        } else {
            System.out.println("Node read matches node written");
        }
    }
*/

    protected static class TestExtendNode extends ProjSettingsNode {

    }
}