this._cl = c;
this._inner = inner;
}
- private boolean match(Method m, String s) { return match(m.getAnnotation(tag.class), null, s); }
- private boolean match(tag t, Class c, String s) {
+ private boolean match(Method m, String s) { return match(m.getAnnotation(bind.as.class), null, s); }
+ private boolean match(bind.as t, Class c, String s) {
if (t==null) return false;
if (t.value().equals(s)) return true;
if (c != null && t.equals("") && c.getSimpleName().equals(s)) return true;
}
*/
private boolean match(Class c, String s, String nonTerminalName) {
- if (match((tag)c.getAnnotation(tag.class), c, s)) return true;
- //if (match((nonterminal)c.getAnnotation(tag.class), c, nonTerminalName)) return true;
+ if (match((bind.as)c.getAnnotation(bind.as.class), c, s)) return true;
+ //if (match((nonterminal)c.getAnnotation(bind.as.class), c, nonTerminalName)) return true;
return false;
}
public boolean match(Constructor con, String s, String nonTerminalName) {
Class c = con.getDeclaringClass();
- if (match((tag)con.getAnnotation(tag.class), null, s)) return true;
- //if (match((nonterminal)con.getAnnotation(tag.class), c, s)) return true;
+ if (match((bind.as)con.getAnnotation(bind.as.class), null, s)) return true;
+ //if (match((nonterminal)con.getAnnotation(bind.as.class), c, s)) return true;
return false;
}
public Object repeatTag() {
}
- /**
- * Constructors, classes, and methods with this attribute will
- * match every production of the nonterminal called "value()"
- * that is arg-compatible. If value() is undefined, then the
- * class/constructor/method name is used.
- */
- /*
- @Retention(RetentionPolicy.RUNTIME) public static @interface nonterminal { String value() default ""; }
- */
-
- @Retention(RetentionPolicy.RUNTIME) public static @interface raw { }
-
- /**
- * Constructors, classes, and methods with this attribute will
- * match every tree tagged with "value()" that is arg-compatible.
- * If value() is undefined, then the class/constructor/method
- * name is used.
- */
- @Retention(RetentionPolicy.RUNTIME) public static @interface tag { String value() default ""; }
-
- /**
- * If any parameter to a method or field in a class has a named
- * arg-tag, that parameter/field matches the child of the tree
- * which either has that label or else is a reference to a
- * nonterminal with the corresponding name.
- *
- * The remaining non-named arg-tags match the remaining children
- * of the tree in sequential order.
- *
- * If any arg-tagged parameters/fields remain, the match fails.
- * If there were no arg-tagged parameters-fields, it is as if all
- * of them were non-named and arg-tagged.
- *
- * A method/constructor is arg-compatible if all of its arguments
- * are arg-compatible.
- *
- * A class is arg-compatible if all of its fields are
- * arg-compatible, or if one of its constructors is arg-compatible.
- *
- */
- @Retention(RetentionPolicy.RUNTIME) public static @interface arg { String value() default ""; }
+ public static class bind {
+ /**
+ * Constructors, classes, and methods with this attribute will
+ * match every production of the nonterminal called "value()"
+ * that is arg-compatible. If value() is undefined, then the
+ * class/constructor/method name is used.
+ */
+ /*
+ @Retention(RetentionPolicy.RUNTIME) public static @interface nonterminal { String value() default ""; }
+ */
+
+ @Retention(RetentionPolicy.RUNTIME) public static @interface raw { }
+
+ /**
+ * Constructors, classes, and methods with this attribute will
+ * match every tree tagged with "value()" that is arg-compatible.
+ * If value() is undefined, then the class/constructor/method
+ * name is used.
+ */
+
+ @Retention(RetentionPolicy.RUNTIME) public static @interface as { String value() default ""; }
+
+
+ /**
+ * If any parameter to a method or field in a class has a named
+ * arg-tag, that parameter/field matches the child of the tree
+ * which either has that label or else is a reference to a
+ * nonterminal with the corresponding name.
+ *
+ * The remaining non-named arg-tags match the remaining children
+ * of the tree in sequential order.
+ *
+ * If any arg-tagged parameters/fields remain, the match fails.
+ * If there were no arg-tagged parameters-fields, it is as if all
+ * of them were non-named and arg-tagged.
+ *
+ * A method/constructor is arg-compatible if all of its arguments
+ * are arg-compatible.
+ *
+ * A class is arg-compatible if all of its fields are
+ * arg-compatible, or if one of its constructors is arg-compatible.
+ *
+ */
+ @Retention(RetentionPolicy.RUNTIME) public static @interface arg { String value() default ""; }
+ }
public static class Production {
public String tag;
public Target(Reflection.Bindable b) { this._bindable = b; }
public String getName() { return _bindable.getSimpleName(); }
- public tag getTag() { return (tag)_bindable.getAnnotation(tag.class); }
- //public nonterminal getNonTerminal() { return (nonterminal)_bindable.getAnnotation(tag.class); }
+ public bind.as getBindAs() { return (bind.as)_bindable.getAnnotation(bind.as.class); }
+ //public nonterminal getNonTerminal() { return (nonterminal)_bindable.getAnnotation(bind.as.class); }
public String toString() { return _bindable.getSimpleName(); }
public Object plant(Object[] fields) { return _bindable.impose(fields); }
- public boolean isRaw() { return _bindable.isAnnotationPresent(raw.class); }
+ public boolean isRaw() { return _bindable.isAnnotationPresent(bind.raw.class); }
public Object invokeRaw(Iterable<Tree<Object>> t) { return _bindable.impose(new Object[] { t }); }
public boolean isCompatible(Production p) {
- tag t = getTag();
+ bind.as t = getBindAs();
if (t != null &&
(t.value().equals(p.tag) ||
(t.value().equals("") && getName().equals(p.tag))))
return buildSequence(p)!=null;
- tag n = getTag();
+ bind.as n = getBindAs();
if (n != null &&
(n.value().equals(p.nonTerminal) ||
(n.value().equals("") && getName().equals(p.nonTerminal))))
return false;
}
- public int[] buildSequence(Production p, String[] names, arg[] argtags) {
+ public int[] buildSequence(Production p, String[] names, bind.arg[] argtags) {
int argTagged = 0;
for(int i=0; i<argtags.length; i++)
if (argtags[i] != null)
public int[] buildSequence(Production p) {
Field[] f = _class.getDeclaredFields();
String[] names = new String[f.length];
- arg[] argtags = new arg[f.length];
+ bind.arg[] argtags = new bind.arg[f.length];
for(int i=0; i<f.length; i++) {
names[i] = f[i].getName();
- argtags[i] = f[i].getAnnotation(arg.class);
+ argtags[i] = f[i].getAnnotation(bind.arg.class);
}
int[] ret = buildSequence(p, names, argtags);
if (ret!=null) return ret;
}
*/
String[] names = new String[len];
- arg[] argtags = new arg[len];
+ bind.arg[] argtags = new bind.arg[len];
for(int i=0; i<names.length; i++)
for(Annotation a : annotations[i+ofs])
- if (a instanceof arg)
- argtags[i+ofs] = (arg)a;
+ if (a instanceof bind.arg)
+ argtags[i+ofs] = (bind.arg)a;
return buildSequence(p, names, argtags);
}
}
public int[] buildSequence(Production p) {
Annotation[][] annotations = _method.getParameterAnnotations();
String[] names = new String[annotations.length];
- arg[] argtags = new arg[annotations.length];
+ bind.arg[] argtags = new bind.arg[annotations.length];
for(int i=0; i<names.length; i++)
for(Annotation a : annotations[i])
- if (a instanceof arg)
- argtags[i] = (arg)a;
+ if (a instanceof bind.arg)
+ argtags[i] = (bind.arg)a;
int[] ret = buildSequence(p, names, argtags);
return ret;
}
}
public static class MG {
- public static @tag("grammar") class Grammar {
+ public static @bind.as("grammar") class Grammar {
public NonTerminal get(String s) {
for(NonTerminal nt : nonterminals)
if (nt.name.equals(s))
return nt;
return null;
}
- public @arg("NonTerminal") NonTerminal[] nonterminals;
+ public @bind.arg("NonTerminal") NonTerminal[] nonterminals;
public String toString() {
String ret = "[ ";
for(NonTerminal nt : nonterminals) ret += nt + ", ";
}
public static class NonTerminal extends Un {
public String name = null;
- public @tag("=") NonTerminal(@arg("Word") String name,
- @arg("RHS") Seq[][] sequences) {
+ public @bind.as("=") NonTerminal(@bind.arg("Word") String name,
+ @bind.arg("RHS") Seq[][] sequences) {
this.name = name;
this.sequences = sequences;
}
}
public static class AnonUn extends Un {
- public @tag("(") AnonUn(Seq[][] sequences) {
+ public @bind.as("(") AnonUn(Seq[][] sequences) {
this.sequences = sequences;
}
public Element build(Context cx) {
}
}
- //public static @tag void range(char c) { }
+ //public static @bind.as void range(char c) { }
public static class Range {
- public @tag("range") Range(char only) { first = only; last = only; }
- public @tag("-") Range(char first, char last) { this.first = first; this.last = last; }
+ public @bind.as("range") Range(char only) { first = only; last = only; }
+ public @bind.as("-") Range(char first, char last) { this.first = first; this.last = last; }
public char first;
public char last;
}
return ret;
}
}
- public static @tag("&") Seq and(Seq s, El[] elements) { return s.and(seq(elements)); }
- public static @tag("&~") Seq andnot(Seq s, El[] elements) { return s.andnot(seq(elements)); }
- public static @tag("->") Seq arrow(Seq s, El e) { return s.follow(e); }
- public static @tag("::") Seq tag(String tagname, Seq s) { return s.tag(tagname); }
- public static @tag("/") Seq slash(Seq s, El e) { return s.separate(e); }
+ public static @bind.as("&") Seq and(Seq s, El[] elements) { return s.and(seq(elements)); }
+ public static @bind.as("&~") Seq andnot(Seq s, El[] elements) { return s.andnot(seq(elements)); }
+ public static @bind.as("->") Seq arrow(Seq s, El e) { return s.follow(e); }
+ public static @bind.as("::") Seq tag(String tagname, Seq s) { return s.tag(tagname); }
+ public static @bind.as("/") Seq slash(Seq s, El e) { return s.separate(e); }
- public static @tag("ps") Seq seq(El[] elements) { return new Seq(elements); }
- public static @tag Seq psx(Seq s) { return s; }
- public static @tag(":") El colon(String s, El e) { return new Label(s, e); }
- public static @tag(")") void close(String foo) { throw new Error("not supported"); }
- public static @tag("()") El epsilon() { return new Constant(Union.epsilon); }
+ public static @bind.as("ps") Seq seq(El[] elements) { return new Seq(elements); }
+ public static @bind.as Seq psx(Seq s) { return s; }
+ public static @bind.as(":") El colon(String s, El e) { return new Label(s, e); }
+ public static @bind.as(")") void close(String foo) { throw new Error("not supported"); }
+ public static @bind.as("()") El epsilon() { return new Constant(Union.epsilon); }
- public static @tag("nonTerminal") class NonTerminalReference extends El {
- public @arg String nonTerminal;
+ public static @bind.as("nonTerminal") class NonTerminalReference extends El {
+ public @bind.arg String nonTerminal;
public Element build(Context cx) {
return cx.get(nonTerminal);
}
}
public static class StringLiteral extends Constant {
- public @tag("literal") StringLiteral(String string) { super(CharRange.string(string)); }
+ public @bind.as("literal") StringLiteral(String string) { super(CharRange.string(string)); }
public boolean drop() { return true; }
}
public static class CharClass extends El {
Range[] ranges;
- public @tag("[") CharClass(Range[] ranges) { this.ranges = ranges; }
+ public @bind.as("[") CharClass(Range[] ranges) { this.ranges = ranges; }
public Element build(Context cx) {
edu.berkeley.sbp.util.Range.Set set = new edu.berkeley.sbp.util.Range.Set();
for(Range r : ranges)
}
}
- public static @tag("{") class XTree extends El {
- public @arg Seq body;
+ public static @bind.as("{") class XTree extends El {
+ public @bind.arg Seq body;
public Element build(Context cx) {
throw new Error();
}
}
// FIXME: it would be nice if we could hoist this into "Rep"
- public static @tag("++") El plusmax(final El e) { return new Rep(e, null, false, true, true); }
- public static @tag("+") El plus(final El e) { return new Rep(e, null, false, true, false); }
- public static @tag("++/") El plusmaxfollow(final El e, final El sep) { return new Rep(e, sep, false, true, true); }
- public static @tag("+/") El plusfollow(final El e, final El sep) { return new Rep(e, sep, false, true, false); }
- public static @tag("**") El starmax(final El e) { return new Rep(e, null, true, true, true); }
- public static @tag("*") El star(final El e) { return new Rep(e, null, true, true, false); }
- public static @tag("**/") El starmaxfollow(final El e, final El sep) { return new Rep(e, sep, true, true, true); }
- public static @tag("*/") El starfollow(final El e, final El sep) { return new Rep(e, sep, true, true, false); }
- public static @tag("?") El question(final El e) { return new Rep(e, null, true, true, false); }
-
- public static @tag("!") El bang(final El e) { return new Drop(e); }
-
- public static @tag("^") El caret(final String s) {
+ public static @bind.as("++") El plusmax(final El e) { return new Rep(e, null, false, true, true); }
+ public static @bind.as("+") El plus(final El e) { return new Rep(e, null, false, true, false); }
+ public static @bind.as("++/") El plusmaxfollow(final El e, final El sep) { return new Rep(e, sep, false, true, true); }
+ public static @bind.as("+/") El plusfollow(final El e, final El sep) { return new Rep(e, sep, false, true, false); }
+ public static @bind.as("**") El starmax(final El e) { return new Rep(e, null, true, true, true); }
+ public static @bind.as("*") El star(final El e) { return new Rep(e, null, true, true, false); }
+ public static @bind.as("**/") El starmaxfollow(final El e, final El sep) { return new Rep(e, sep, true, true, true); }
+ public static @bind.as("*/") El starfollow(final El e, final El sep) { return new Rep(e, sep, true, true, false); }
+ public static @bind.as("?") El question(final El e) { return new Rep(e, null, true, true, false); }
+
+ public static @bind.as("!") El bang(final El e) { return new Drop(e); }
+
+ public static @bind.as("^") El caret(final String s) {
return new Drop(new Constant(CharRange.string(s)) {
public String getOwnerTag() { return s; }
});
}
- public static @tag("~") El tilde(final El e) {
+ public static @bind.as("~") El tilde(final El e) {
return new PostProcess(e) {
public Element postProcess(Element e) {
return MetaGrammar.infer((Topology<Character>)Atom.toAtom(e).complement());
} }; }
- public static @tag("^^") void doublecaret(final El e) { throw new Error("not implemented"); }
+ public static @bind.as("^^") void doublecaret(final El e) { throw new Error("not implemented"); }
- //public static @tag("(") El subexpression(Seq[][] rhs) { return new NonTerminal(rhs); }
+ //public static @bind.as("(") El subexpression(Seq[][] rhs) { return new NonTerminal(rhs); }
- public static @tag("Word") String word(String s) { return s; }
- public static @tag("Quoted") String quoted(String s) { return s; }
- public static @tag("escaped") String c(char c) { return c+""; }
- public static @tag("\"\"") String emptystring() { return ""; }
- public static @tag("\n") String retur() { return "\n"; }
- public static @tag("\r") String lf() { return "\r"; }
+ public static @bind.as("Word") String word(String s) { return s; }
+ public static @bind.as("Quoted") String quoted(String s) { return s; }
+ public static @bind.as("escaped") String c(char c) { return c+""; }
+ public static @bind.as("\"\"") String emptystring() { return ""; }
+ public static @bind.as("\n") String retur() { return "\n"; }
+ public static @bind.as("\r") String lf() { return "\r"; }
}
public static class Context {