466 lines
14 KiB
Java
466 lines
14 KiB
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();
|
|
}
|
|
}
|