cst_tests: comparison lex_blex_Frankensteined.scala

equal deleted inserted replaced

-:b51d34113d47
+:73f990bc6843
-package RexpRelated
+import Element.elem
 import scala.language.implicitConversions
 import scala.language.reflectiveCalls
 import scala.annotation.tailrec
 import scala.util.Try
+package RexpRelated
+{
 abstract class Bit
 case object Z extends Bit
 case object S extends Bit
 //case class C(c: Char) extends Bit
 type Mon = (Char, Rexp)
 type Lin = Set[Mon]
 def ALT(r1: Rexp, r2: Rexp) = ALTS(List(r1, r2))
 def PLUS(r: Rexp) = SEQ(r, STAR(r))
 def AALT(bs: Bits, r1: ARexp, r2: ARexp) = AALTS(bs, List(r1, r2))
 def distinctBy[B, C](xs: List[B], f: B => C, acc: List[C] = Nil): List[B] = xs match {
 case Nil => Nil
 case (x::xs) => {
 case ((AONE(bs2), v1s) , (r2s, v2s)) => (vtails => Sequ(v1, vunsimp(r2, v2)(vtails)))  //(fuse(bs1 ++ bs2, r2s), v2s )//v2 tells how to retrieve bits in r2s, which is enough as the bits of the first part of the sequence has already been integrated to the top level of the second regx.
 case ((r1s, v1s), (r2s, v2s)) => (vsmall => vsmall match {
 case Sequ(v1small, v2small) => Sequ(vunsimp(r1, v1)(v1small), vunsimp(r2, v2)(v2small))
 case _ => {
 println(vsmall) ;
+println(aregex_simple_print(r1))
+println(v1)
+println(aregex_simple_print( r2))
+println(v2)
 throw new Exception("bad arguments sequ")
 }
 //(ASEQ(bs1, r1s, r2s),  Sequ(v1s, v2s))
 })
 }
 def unify(rs: List[ARexp], v: Val): Val = {
 Position( pos_i(rs, v), pos_v(rs, v) )
 }
 def deunify(rs_length: Int, v: Val): Val = v match{
 case Position(i, v0) => {
-if(i <0) {println(rs_length, v); throw new Exception("deunify minus")}
+if(i <0) {throw new Exception("deunify minus")}
-else if(rs_length == 1) {println(v); v}
+else if(rs_length == 1) { v0}
-else if(rs_length - 1 == i) coat(v0, i)
+else if(rs_length - 1 == i) {coat(v0, i)}
-else coat(Left(v0), i)
+else {coat(Left(v0), i)}
 }
 case _ => throw new Exception("deunify error")
 }
 def flats2(front: List[ARexp], i: Int, rs: List[ARexp], v: Val): (List[ARexp], Val) = v match {
 case Position(j, v0) => {
 if (i < 0) (front ::: flats(rs), Position(j, v0) )
 }
 }
 }
 case _ => throw new Exception("flats2 error")
 }
-def distinctBy2[B, C](v: Val, xs: List[B], f: B => C, acc: List[C] = Nil, res: List[B] = Nil): (List[B], Val) = xs match {
+def distinctBy2[B, C](j: Int, v: Val, xs: List[B], f: B => C, acc: List[C] = Nil, res: List[B] = Nil): (List[B], Val) = xs match {
 case Nil => (res, v)
 case (x::xs) => {
 val re = f(x)
 if (acc.contains(re)) v match {
-case Position(i, v0) => distinctBy2(Position(i - 1, v0), xs, f, acc, res)
+case Position(i, v0) => if(j > 0) distinctBy2(j - 1, Position(i - 1, v0), xs, f, acc, res)
+else if(j < 0)distinctBy2(j - 1, Position(i, v0), xs, f, acc, res) else throw new Exception("Value not POSIX")
 case _ => throw new Exception("dB2")
 }
-else distinctBy2(v, xs, f, re::acc, x::res)
+else distinctBy2(j - 1, v, xs, f, re::acc, x::res)
 }
 }
 def bsimp2(r: ARexp, v: Val): (ARexp, Val) = (r,v) match{
 case (ASEQ(bs1, r1, r2), Sequ(v1, v2)) => (bsimp2(r1, v1), bsimp2(r2, v2)) match {
 case ((AZERO, _), (_, _) )=> (AZERO, undefined)
 case ((_, _), (AZERO, _)) => (AZERO, undefined)
 case ((AONE(bs2), v1s) , (r2s, v2s)) => (fuse(bs1 ++ bs2, r2s), v2s )//v2 tells how to retrieve bits in r2s, which is enough as the bits of the first part of the sequence has already been integrated to the top level of the second regx.
 case ((r1s, v1s), (r2s, v2s)) => (ASEQ(bs1, r1s, r2s),  Sequ(v1s, v2s))
 }
 case (AALTS(bs1, rs), v) => {
+println("Entry into AALTS")
+rs.map(println(aregex_simple_print()))
 val vlist = unify(rs, v)
 vlist match {
 case Position(i, v0) => {
 val v_simp = bsimp2(rs(i), v0)._2
+println("map on bsimp")
 val rs_simp = rs.map(bsimp)
 val flat_res = flats2( Nil, i, rs_simp, Position(i, v_simp) )
-val dist_res = distinctBy2(flat_res._2, flat_res._1, erase)
+println("list after flats2")
+flat_res._1.map(println(aregex_simple_print(_)))
+val dist_res = distinctBy2(i, flat_res._2, flat_res._1, erase)
+println("list after distinctBy2")
 val rs_new = dist_res._1
+rs_new.map(println(aregex_simple_print(_)))
 val v_new = deunify(rs_new.length, dist_res._2)
 rs_new match {
 case Nil => (AZERO, undefined)
 case s :: Nil => (fuse(bs1, s), v_new)
 case rs => (AALTS(bs1, rs), v_new)
 }
 */
 //--------------------------------------------------------------------------------------------------------END OF NON-BITCODE PART (TESTING)
+def bstostick(bs: List[Bit]): Element = bs match {
+//case b::Nil => elem(b.toString)
+case b::bs1 => elem(b.toString) beside bstostick(bs1)
+case Nil => elem(' ', 1, 1)
+}
+def aregex_simple_print(r: ARexp): Element = r match {
+case AALTS(bs,rs) => {
+val bitstick = bstostick(bs)
+rs match {
+case r::rs1 =>
+rs1.foldLeft(
+((elem("(") left_align bitstick) beside
+aregex_simple_print(r))  )( (acc, r2) => acc beside ((elem(" + ") above elem("   ")) beside aregex_simple_print(r2) )) beside
+elem(")")
+case Nil => elem(' ', 1, 1)
+}
+}
+case ASEQ(bs, r1, r2) => {
+((elem("[") left_align bstostick(bs)) beside  aregex_simple_print(r1) beside elem("~") beside aregex_simple_print(r2) beside (elem("]") above elem(" ")))
+}
+case ASTAR(bs, r) => {
+r match {
+case AONE(_) | AZERO | ACHAR(_, _) => {
+(elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*"))
+}
+case _ => {
+(elem("{") left_align bstostick(bs)) beside (aregex_simple_print(r) beside elem("}*"))
+}
+}
+}
+case AONE(bs) => {
+elem("1") left_align bstostick(bs)
+}
+case ACHAR(bs, c) => {
+elem(c, 1, 1) left_align bstostick(bs)
+}
+case AZERO =>
+{
+elem ("0") above elem(" ")
+}
+}
 def clear() = {
 print("")
 //print("\33[H\33[2J")
 //single_expression_explorer(internalise(("c"~("a"+"b"))%) , Set('a','b','c'))
 }
 import Rexp.Bits
 abstract class ARexp
 case object AZERO extends ARexp
 case class AONE(bs: Bits) extends ARexp
 case class Rec(x: String, v: Val) extends Val
 case class Position(i: Int, v: Val) extends Val
 case object undefined extends Val
 //case class Pos(i: Int, v: Val) extends Val
 case object Prd extends Val
+}

changeset 151	73f990bc6843
parent 150	b51d34113d47