jdk8-mips64-public/langtools: test/tools/javac/diags/MessageFile.java@959103a6100f (annotated)

test/tools/javac/diags/MessageFile.java@959103a6100f (annotated)

test/tools/javac/diags/MessageFile.java

Wed, 27 Apr 2016 01:34:52 +0800

author: aoqi
date: Wed, 27 Apr 2016 01:34:52 +0800
changeset 0: 959103a6100f
child 2525: 2eb010b6cb22
permissions: -rw-r--r--

Initial load
http://hg.openjdk.java.net/jdk8u/jdk8u/langtools/
changeset: 2573:53ca196be1ae
tag: jdk8u25-b17

 /*
  * 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 infoPattern = Pattern.compile("# ([0-9]+: [-A-Za-z ]+, )*[0-9]+: [-A-Za-z ]+");
     /**
      * 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();
     }
 }

Mercurial > jdk8-mips64-public > langtools / annotate

test/tools/javac/diags/MessageFile.java@959103a6100f (annotated)

test/tools/javac/diags/MessageFile.java