Quelle  MessageFile.java   Sprache: JAVA

/*
 * Copyright (c) 2010, 2013, Oracle and/or its affiliates. All rights reserved.
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
 *
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 only, as
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
 * version 2 for more details (a copy is included in the LICENSE file that
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
 * 2 along with this work; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

import java.io.*;
import java.util.*;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * Class to facilitate manipulating compiler.properties.
 */
class MessageFile {
    static final Pattern emptyOrCommentPattern = Pattern.compile("( *#.*)?");
    static final Pattern typePattern = Pattern.compile("[-\\\\'A-Z\\.a-z ]+( \\([A-Za-z 0-9]+\\))?");
    static final Pattern infoPattern = Pattern.compile(String.format("# ([0-9]+: %s, )*[0-9]+: %s",
            typePattern.pattern(), typePattern.pattern()));

    /**
     * A line of text within the message file.
     * The lines form a doubly linked list for simple navigation.
     */
    class Line {
        String text;
        Line prev;
        Line next;

        Line(String text) {
            this.text = text;
        }

        boolean isEmptyOrComment() {
            return emptyOrCommentPattern.matcher(text).matches();
        }

        boolean isInfo() {
            return infoPattern.matcher(text).matches();
        }

        boolean hasContinuation() {
            return (next != null) && text.endsWith("\\");
        }

        Line insertAfter(String text) {
            Line l = new Line(text);
            insertAfter(l);
            return l;
        }

        void insertAfter(Line l) {
            assert l.prev == null && l.next == null;
            l.prev = this;
            l.next = next;
            if (next == null)
                lastLine = l;
            else
                next.prev = l;
            next = l;
        }

        Line insertBefore(String text) {
            Line l = new Line(text);
            insertBefore(l);
            return l;
        }

        void insertBefore(Line l) {
            assert l.prev == null && l.next == null;
            l.prev = prev;
            l.next = this;
            if (prev == null)
                firstLine = l;
            else
                prev.next = l;
            prev = l;
        }

        void remove() {
            if (prev == null)
                firstLine = next;
            else
                prev.next = next;
            if (next == null)
                lastLine = prev;
            else
                next.prev = prev;
            prev = null;
            next = null;
        }
    }

    /**
     * A message within the message file.
     * A message is a series of lines containing a "name=value" property,
     * optionally preceded by a comment describing the use of placeholders
     * such as {0}, {1}, etc within the property value.
     */
    static final class Message {
        final Line firstLine;
        private Info info;

        Message(Line l) {
            firstLine = l;
        }

        boolean needInfo() {
            Line l = firstLine;
            while (true) {
                if (l.text.matches(".*\\{[0-9]+\\}.*"))
                    return true;
                if (!l.hasContinuation())
                    return false;
                l = l.next;
            }
        }

        Set<Integer> getPlaceholders() {
            Pattern p = Pattern.compile("\\{([0-9]+)\\}");
            Set<Integer> results = new TreeSet<Integer>();
            Line l = firstLine;
            while (true) {
                Matcher m = p.matcher(l.text);
                while (m.find())
                    results.add(Integer.parseInt(m.group(1)));
                if (!l.hasContinuation())
                    return results;
                l = l.next;
            }
        }

        /**
         * Get the Info object for this message. It may be empty if there
         * if no comment preceding the property specification.
         */
        Info getInfo() {
            if (info == null) {
                Line l = firstLine.prev;
                if (l != null && l.isInfo())
                    info = new Info(l.text);
                else
                    info = new Info();
            }
            return info;
        }

        /**
         * Set the Info for this message.
         * If there was an info comment preceding the property specification,
         * it will be updated; otherwise, one will be inserted.
         */
        void setInfo(Info info) {
            this.info = info;
            Line l = firstLine.prev;
            if (l != null && l.isInfo())
                l.text = info.toComment();
            else
                firstLine.insertBefore(info.toComment());
        }

        /**
         * Get all the lines pertaining to this message.
         */
        List<Line> getLines(boolean includeAllPrecedingComments) {
            List<Line> lines = new ArrayList<Line>();
            Line l = firstLine;
            if (includeAllPrecedingComments) {
                // scan back to find end of prev message
                while (l.prev != null && l.prev.isEmptyOrComment())
                    l = l.prev;
                // skip leading blank lines
                while (l.text.isEmpty())
                    l = l.next;
            } else {
                if (l.prev != null && l.prev.isInfo())
                    l = l.prev;
            }

            // include any preceding lines
            for ( ; l != firstLine; l = l.next)
                lines.add(l);

            // include message lines
            for (l = firstLine; l != null && l.hasContinuation(); l = l.next)
                lines.add(l);
            lines.add(l);

            // include trailing blank line if present
            l = l.next;
            if (l != null && l.text.isEmpty())
                lines.add(l);

            return lines;
        }
    }

    /**
     * An object to represent the comment that may precede the property
     * specification in a Message.
     * The comment is modelled as a list of fields, where the fields correspond
     * to the placeholder values (e.g. {0}, {1}, etc) within the message value.
     */
    static final class Info {
        /**
         * An ordered set of descriptions for a placeholder value in a
         * message.
         */
        static class Field {
            boolean unused;
            Set<String> values;
            boolean listOfAny = false;
            boolean setOfAny = false;
            Field(String s) {
                s = s.substring(s.indexOf(": ") + 2);
                values = new LinkedHashSet<String>(Arrays.asList(s.split(" or ")));
                for (String v: values) {
                    if (v.startsWith("list of"))
                        listOfAny = true;
                    if (v.startsWith("set of"))
                        setOfAny = true;
                }
            }

            /**
             * Return true if this field logically contains all the values of
             * another field.
             */
            boolean contains(Field other) {
                if (unused != other.unused)
                    return false;

                for (String v: other.values) {
                    if (values.contains(v))
                        continue;
                    if (v.equals("null") || v.equals("string"))
                        continue;
                    if (v.equals("list") && listOfAny)
                        continue;
                    if (v.equals("set") && setOfAny)
                        continue;
                    return false;
                }
                return true;
            }

            /**
             * Merge the values of another field into this field.
             */
            void merge(Field other) {
                unused |= other.unused;
                values.addAll(other.values);

                // cleanup unnecessary entries

                if (values.contains("null") && values.size() > 1) {
                    // "null" is superceded by anything else
                    values.remove("null");
                }

                if (values.contains("string") && values.size() > 1) {
                    // "string" is superceded by anything else
                    values.remove("string");
                }

                if (values.contains("list")) {
                    // list is superceded by "list of ..."
                    for (String s: values) {
                        if (s.startsWith("list of ")) {
                            values.remove("list");
                            break;
                        }
                    }
                }

                if (values.contains("set")) {
                    // set is superceded by "set of ..."
                    for (String s: values) {
                        if (s.startsWith("set of ")) {
                            values.remove("set");
                            break;
                        }
                    }
                }

                if (other.values.contains("unused")) {
                    values.clear();
                    values.add("unused");
                }
            }

            void markUnused() {
                values = new LinkedHashSet<String>();
                values.add("unused");
                listOfAny = false;
                setOfAny = false;
            }

            @Override
            public String toString() {
                return values.toString();
            }
        }

        /** The fields of the Info object. */
        List<Field> fields = new ArrayList<Field>();

        Info() { }

        Info(String text) throws IllegalArgumentException {
            if (!text.startsWith("# "))
                throw new IllegalArgumentException();
            String[] segs = text.substring(2).split(", ");
            fields = new ArrayList<Field>();
            for (String seg: segs) {
                fields.add(new Field(seg));
            }
        }

        Info(Set<String> infos) throws IllegalArgumentException {
            for (String s: infos)
                merge(new Info(s));
        }

        boolean isEmpty() {
            return fields.isEmpty();
        }

        boolean contains(Info other) {
            if (other.isEmpty())
                return true;

            if (fields.size() != other.fields.size())
                return false;

            Iterator<Field> oIter = other.fields.iterator();
            for (Field values: fields) {
                if (!values.contains(oIter.next()))
                    return false;
            }

            return true;
        }

        void merge(Info other) {
            if (fields.isEmpty()) {
                fields.addAll(other.fields);
                return;
            }

            if (other.fields.size() != fields.size())
                throw new IllegalArgumentException();

            Iterator<Field> oIter = other.fields.iterator();
            for (Field d: fields) {
                d.merge(oIter.next());
            }
        }

        void markUnused(Set<Integer> used) {
            for (int i = 0; i < fields.size(); i++) {
                if (!used.contains(i))
                    fields.get(i).markUnused();
            }
        }

        @Override
        public String toString() {
            return fields.toString();
        }

        String toComment() {
            StringBuilder sb = new StringBuilder();
            sb.append("# ");
            String sep = "";
            int i = 0;
            for (Field f: fields) {
                sb.append(sep);
                sb.append(i++);
                sb.append(": ");
                sep = "";
                for (String s: f.values) {
                    sb.append(sep);
                    sb.append(s);
                    sep = " or ";
                }
                sep = ", ";
            }
            return sb.toString();
        }
    }

    Line firstLine;
    Line lastLine;
    Map<String, Message> messages = new TreeMap<String, Message>();

    MessageFile(File file) throws IOException {
        Reader in = new FileReader(file);
        try {
            read(in);
        } finally {
            in.close();
        }
    }

    MessageFile(Reader in) throws IOException {
        read(in);
    }

    final void read(Reader in) throws IOException {
        BufferedReader br = (in instanceof BufferedReader)
                ? (BufferedReader) in
                : new BufferedReader(in);
        String line;
        while ((line = br.readLine()) != null) {
            Line l;
            if (firstLine == null)
                l = firstLine = lastLine = new Line(line);
            else
                l = lastLine.insertAfter(line);
            if (line.startsWith("compiler.")) {
                int eq = line.indexOf("=");
                if (eq > 0)
                    messages.put(line.substring(0, eq), new Message(l));
            }
        }
    }

    void write(File file) throws IOException {
        Writer out = new FileWriter(file);
        try {
            write(out);
        } finally {
            out.close();
        }
    }

    void write(Writer out) throws IOException {
        BufferedWriter bw = (out instanceof BufferedWriter)
                ? (BufferedWriter) out
                : new BufferedWriter(out);
        for (Line l = firstLine; l != null; l = l.next) {
            bw.write(l.text);
            bw.write("\n"); // always use Unix line endings
        }
        bw.flush();
    }
}