_____________________________________________________________________________
Immediately
- - The repeat API's in Sequence are ugly
- - segregate the sequence static-constructors?
-
- - Sequence shouldn't be an Element -> make Union.add(Element)
- - Should Tree<T> really be type-parameterized?
+ - Sequence extends Element (?) -> then add Union.add(element)
+ - Parameterize Sequence/Union/Atom <Tok,Result>
+ - Make sure we never use raw types
- do Forest/Tree still need a Region?
- - reconsider the degree of genericization
+ - More topology untangling
+
+ - tib: use the lexer only for indentation increases/decreases
- grammar highlighting?
- - comment indentation vs block indentation?
- - { and } in <pre>
- - recursive { { foo } }
- - More topology untangling
+ - copyright notices
+
+ - tutorial
+
+______________________________________________________________________________
+v1.1
+
- Forest needs a "manual access" API
- the unwrap bit in Forest makes it really hard to expose an API for forests
- evil problems with (x y? z /ws)
- - ParseFailed, GSS, Walk, Parser, Sequence, Forest
- - copyright notices
- - documentation
______________________________________________________________________________
public static Sequence create(Element e) { return create(new Element[] { e }, 0); }
/** create a sequence which drops the result of all but one of its element */
- public static Sequence create(Element[] e, int idx) { return new Singleton(e, idx); }
-
- /** after matching the sequence, insert a constant into the output tree */
- public static Sequence newConstantSequence(Element[] e, Object o) { return new Constant(e, o); }
+ public static Sequence create(Element[] e, int which) { return new Singleton(e, which); }
+ /** create a sequence which always evaluates to a constant result */
+ public static Sequence create(Element[] e, Object result) { return new Constant(e, result); }
/**
- * after matching the sequence, create the specified output tree
- * @param tag the tag for the output tree
+ * create a sequence (general form)
+ * @param head the head of the output tree
* @param e the elements to match
- * @param drops only elements of <tt>e</tt> whose corresponding <tt>boolean</tt> in <tt>drops</tt>
+ * @param drop only elements of <tt>e</tt> whose corresponding <tt>boolean</tt> in <tt>drops</tt>
* is <i>false</i> will be included in the output tree
- * @param unwrap if true, all children of the last child (ie
- * grandchildren) are promoted to children of this node; this is very useful for matching repetitions
+ * @param foster if true, all children of the last child (ie
+ * grandchildren) are promoted to children of this
+ * node; this is very useful for matching repetitions
**/
- public static Sequence create(Object tag, Element[] e, boolean[] drops, boolean unwrap) {
- return unwrap
- ? new Unwrap(e, tag, drops)
- : new RewritingSequence(tag, e, drops);
+ public static Sequence create(Object head, Element[] e, boolean[] drop, boolean foster) {
+ return foster
+ ? new Unwrap(e, head, drop)
+ : new RewritingSequence(head, e, drop);
}
////////////////////////////////////////////////////////////////////////////////
for(int i=0; i<els.length; i++)
if (!drops[i])
if (idx==-1) idx = i;
- else throw new Error("multiple non-dropped elements in sequence: " + Sequence.newConstantSequence(els, null));
+ else throw new Error("multiple non-dropped elements in sequence: " + Sequence.create(els, null));
if (idx != -1) ret = Sequence.create(els, idx);
- else ret = Sequence.newConstantSequence(els, null);
+ else ret = Sequence.create(els, null);
}
if (this.follow != null)
ret = ret.followedBy(this.follow.toAtom(cx));