Working on Layout in Trees

Author: afroozeh

src/main/scala/org/meerkat/sppf/SPPFVisitor.scala

@@ -108,19 +108,19 @@ class SemanticActionExecutor(amb: (Set[Any], Int, Int) => Any,
 
   def visit(node: SPPFNode): Any = node match {
 
-     case t: TerminalNode     => if (t.leftExtent == t.rightExtent) () 
-                                 else tn(t.leftExtent, t.rightExtent)
+     case t: TerminalNode        => if (t.leftExtent == t.rightExtent) () 
+                                    else tn(t.leftExtent, t.rightExtent)
 
-     case t: LayoutTerminalNode  => if (t.leftExtent == t.rightExtent) () 
-                                    else tn(t.leftExtent, t.rightExtent)                            
-    
-     case n: NonterminalNode  => if (n isAmbiguous) ambiguity(n) 
-                                 else nonterminal(n.first, n.leftExtent, n.rightExtent)
+     case l: LayoutTerminalNode  => if (l.leftExtent == l.rightExtent) ()
+                                    else tn(l.leftExtent, l.rightExtent)
+                                 
+     case n: NonterminalNode     => if (n isAmbiguous) ambiguity(n) 
+                                    else nonterminal(n.first, n.leftExtent, n.rightExtent)
 
-     case i: IntermediateNode => if (i isAmbiguous) ambiguity(i) 
-                                 else intermediate(i.first, visit(i.first.leftChild), visit(i.first.rightChild))
+     case i: IntermediateNode    => if (i isAmbiguous) ambiguity(i) 
+                                    else intermediate(i.first, visit(i.first.leftChild), visit(i.first.rightChild))
 
-     case p: PackedNode       => throw new RuntimeException("Should not traverse a packed node!")
+     case p: PackedNode          => throw new RuntimeException("Should not traverse a packed node!")
   }
 
 }
@@ -185,9 +185,17 @@ object TreeBuilder {
 
   def t(input: Input)(l: Int, r: Int): Tree = org.meerkat.tree.TerminalNode(input.substring(l, r))
 
+  def l(input: Input)(l:Int, r: Int): Tree = LayoutNode(t(input)(l, r))
+  
   def int(input: Input)(t: Rule, v: Any) = v
 
-  def nt(input: Input)(t: Rule, v: Any, l: Int, r: Int) = RuleNode(Rule(t.head, flatten(t.body)), flatten(v).asInstanceOf[Seq[Tree]])
+  def nt(input: Input)(t: Rule, v: Any, l: Int, r: Int) = {
+    val node = RuleNode(Rule(t.head, flatten(t.body)), flatten(v).asInstanceOf[Seq[Tree]])
+    t.head match {
+      case Layout(_) => LayoutNode(node)
+      case _         => node
+    }
+  } 
 
   def build(node: NonPackedNode, memoized: Boolean = true)(implicit input: Input): Tree = {
     val executer = if (memoized) new SemanticActionExecutor(amb(input), t(input), int(input), nt(input)) with Memoization

src/main/scala/org/meerkat/tree/Rule.scala

@@ -91,7 +91,7 @@ case class Sequence(ss: Symbol*) extends NonterminalSymbol {
 }
 
 object Sequence {
-  def unapply(s: Sequence): Option[Seq[Symbol]] = Some(s.ss filter { case Layout(_) => true; case _ => false } )
+  def unapply(s: Sequence): Option[Seq[Symbol]] = Some(s.ss filter { case Layout(_) => false; case _ => true } )
 }
 
 case class Group(s: Symbol) extends NonterminalSymbol {

src/main/scala/org/meerkat/tree/Tree.scala

@@ -41,15 +41,20 @@ object Tree {
   def isEpsilon(t: Tree): Boolean = t == epsilon  
 }
 
-class RuleNode(val r: Rule, val ts: Seq[Tree]) extends Tree
+trait RuleNode extends Tree {
+  def r: Rule
+  def ts: Seq[Tree]
+}
+
+case class RuleNodeImpl(val r: Rule, val ts: Seq[Tree]) extends RuleNode
 
-//object RuleNodeL {
-//  def unapply(r: RuleNode)
-//}
+object RuleNodeL {
+  def unapply(n: RuleNode): Option[(Rule, Seq[Tree])] = Some((n.r, n.ts))
+}
 
 object RuleNode {
-  def apply(r: Rule, ts: Seq[Tree])= new RuleNode(r, ts)
-  def unapply(n: RuleNode): Option[(Rule, Seq[Tree])] = Some((n.r, n.ts)) // TODO: ???
+  def apply(r: Rule, ts: Seq[Tree])= new RuleNodeImpl(r, ts)
+  def unapply(n: RuleNode): Option[(Rule, Seq[Tree])] = Some((n.r, n.ts filter { case l: LayoutNode => false; case _ => true }))
 }
 
 case class AmbNode(ts: Set[Tree]) extends Tree