| author | Chengsong |
| Fri, 10 Jan 2020 17:02:16 +0000 | |
| changeset 99 | 596bcdd7aaf9 |
| parent 93 | d486c12deeab |
| child 107 | b1e365afa29c |
| permissions | -rw-r--r-- |
| 0 | 1 |
package RexpRelated |
2 |
import scala.language.implicitConversions |
|
3 |
import scala.language.reflectiveCalls |
|
4 |
import scala.annotation.tailrec |
|
5 |
import scala.util.Try |
|
6 |
||
7 |
abstract class Bit |
|
8 |
case object Z extends Bit |
|
9 |
case object S extends Bit |
|
|
12
768b833d6230
removed C(c) The retrieve and code in the previous version is still not correct and will crash. no prob now.
Chengsong
parents:
11
diff
changeset
|
10 |
//case class C(c: Char) extends Bit |
| 0 | 11 |
|
12 |
||
13 |
abstract class Rexp |
|
14 |
case object ZERO extends Rexp |
|
15 |
case object ONE extends Rexp |
|
16 |
case class CHAR(c: Char) extends Rexp |
|
17 |
case class ALTS(rs: List[Rexp]) extends Rexp |
|
18 |
case class SEQ(r1: Rexp, r2: Rexp) extends Rexp |
|
19 |
case class STAR(r: Rexp) extends Rexp |
|
20 |
case class RECD(x: String, r: Rexp) extends Rexp |
|
21 |
||
22 |
||
23 |
||
24 |
object Rexp{
|
|
25 |
type Bits = List[Bit] |
|
26 |
// abbreviations |
|
27 |
type Mon = (Char, Rexp) |
|
28 |
type Lin = Set[Mon] |
|
29 |
def ALT(r1: Rexp, r2: Rexp) = ALTS(List(r1, r2)) |
|
30 |
def PLUS(r: Rexp) = SEQ(r, STAR(r)) |
|
31 |
def AALT(bs: Bits, r1: ARexp, r2: ARexp) = AALTS(bs, List(r1, r2)) |
|
32 |
||
33 |
||
34 |
def distinctBy[B, C](xs: List[B], f: B => C, acc: List[C] = Nil): List[B] = xs match {
|
|
35 |
case Nil => Nil |
|
36 |
case (x::xs) => {
|
|
37 |
val res = f(x) |
|
38 |
if (acc.contains(res)) distinctBy(xs, f, acc) |
|
39 |
else x::distinctBy(xs, f, res::acc) |
|
40 |
} |
|
41 |
} |
|
42 |
// some convenience for typing in regular expressions |
|
43 |
def charlist2rexp(s : List[Char]): Rexp = s match {
|
|
44 |
case Nil => ONE |
|
45 |
case c::Nil => CHAR(c) |
|
46 |
case c::s => SEQ(CHAR(c), charlist2rexp(s)) |
|
47 |
} |
|
48 |
implicit def string2rexp(s : String) : Rexp = charlist2rexp(s.toList) |
|
49 |
||
50 |
implicit def RexpOps(r: Rexp) = new {
|
|
51 |
def | (s: Rexp) = ALT(r, s) |
|
52 |
def % = STAR(r) |
|
53 |
def ~ (s: Rexp) = SEQ(r, s) |
|
54 |
} |
|
55 |
||
56 |
implicit def stringOps(s: String) = new {
|
|
57 |
def | (r: Rexp) = ALT(s, r) |
|
58 |
def | (r: String) = ALT(s, r) |
|
59 |
def % = STAR(s) |
|
60 |
def ~ (r: Rexp) = SEQ(s, r) |
|
61 |
def ~ (r: String) = SEQ(s, r) |
|
62 |
def $ (r: Rexp) = RECD(s, r) |
|
63 |
} |
|
64 |
||
65 |
// translation into ARexps |
|
66 |
def fuse(bs: Bits, r: ARexp) : ARexp = r match {
|
|
67 |
case AZERO => AZERO |
|
68 |
case AONE(cs) => AONE(bs ++ cs) |
|
69 |
case ACHAR(cs, f) => ACHAR(bs ++ cs, f) |
|
70 |
case AALTS(cs, rs) => AALTS(bs ++ cs, rs) |
|
71 |
case ASEQ(cs, r1, r2) => ASEQ(bs ++ cs, r1, r2) |
|
72 |
case ASTAR(cs, r) => ASTAR(bs ++ cs, r) |
|
73 |
} |
|
74 |
||
75 |
def internalise(r: Rexp) : ARexp = r match {
|
|
76 |
case ZERO => AZERO |
|
77 |
case ONE => AONE(Nil) |
|
78 |
case CHAR(c) => ACHAR(Nil, c) |
|
79 |
case ALTS(List(r1, r2)) => |
|
80 |
AALTS(Nil, List(fuse(List(Z), internalise(r1)), fuse(List(S), internalise(r2)))) |
|
81 |
case ALTS(r1::rs) => {
|
|
82 |
val AALTS(Nil, rs2) = internalise(ALTS(rs)) |
|
83 |
AALTS(Nil, fuse(List(Z), internalise(r1)) :: rs2.map(fuse(List(S), _))) |
|
84 |
} |
|
85 |
case SEQ(r1, r2) => ASEQ(Nil, internalise(r1), internalise(r2)) |
|
86 |
case STAR(r) => ASTAR(Nil, internalise(r)) |
|
87 |
case RECD(x, r) => internalise(r) |
|
88 |
} |
|
89 |
||
90 |
internalise(("a" | "ab") ~ ("b" | ""))
|
|
| 5 | 91 |
|
| 0 | 92 |
def decode_aux(r: Rexp, bs: Bits) : (Val, Bits) = (r, bs) match {
|
93 |
case (ONE, bs) => (Empty, bs) |
|
|
12
768b833d6230
removed C(c) The retrieve and code in the previous version is still not correct and will crash. no prob now.
Chengsong
parents:
11
diff
changeset
|
94 |
case (CHAR(f), bs) => (Chr(f), bs) |
|
768b833d6230
removed C(c) The retrieve and code in the previous version is still not correct and will crash. no prob now.
Chengsong
parents:
11
diff
changeset
|
95 |
case (ALTS(r::Nil), bs) => decode_aux(r, bs)//this case seems only used when we simp a regex before derivatives and it contains things like alt("a")
|
| 0 | 96 |
case (ALTS(rs), bs) => bs match {
|
97 |
case Z::bs1 => {
|
|
98 |
val (v, bs2) = decode_aux(rs.head, bs1) |
|
99 |
(Left(v), bs2) |
|
100 |
} |
|
101 |
case S::bs1 => {
|
|
102 |
val (v, bs2) = decode_aux(ALTS(rs.tail), bs1) |
|
103 |
(Right(v), bs2) |
|
104 |
} |
|
105 |
} |
|
106 |
case (SEQ(r1, r2), bs) => {
|
|
107 |
val (v1, bs1) = decode_aux(r1, bs) |
|
108 |
val (v2, bs2) = decode_aux(r2, bs1) |
|
109 |
(Sequ(v1, v2), bs2) |
|
110 |
} |
|
111 |
case (STAR(r1), S::bs) => {
|
|
112 |
val (v, bs1) = decode_aux(r1, bs) |
|
113 |
//println(v) |
|
114 |
val (Stars(vs), bs2) = decode_aux(STAR(r1), bs1) |
|
115 |
(Stars(v::vs), bs2) |
|
116 |
} |
|
117 |
case (STAR(_), Z::bs) => (Stars(Nil), bs) |
|
118 |
case (RECD(x, r1), bs) => {
|
|
119 |
val (v, bs1) = decode_aux(r1, bs) |
|
120 |
(Rec(x, v), bs1) |
|
121 |
} |
|
122 |
} |
|
123 |
||
124 |
def decode(r: Rexp, bs: Bits) = decode_aux(r, bs) match {
|
|
125 |
case (v, Nil) => v |
|
126 |
case _ => throw new Exception("Not decodable")
|
|
127 |
} |
|
| 5 | 128 |
|
|
11
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
129 |
def code(v: Val): Bits = v match {
|
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
130 |
case Empty => Nil |
|
12
768b833d6230
removed C(c) The retrieve and code in the previous version is still not correct and will crash. no prob now.
Chengsong
parents:
11
diff
changeset
|
131 |
case Chr(a) => Nil |
|
11
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
132 |
case Left(v) => Z :: code(v) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
133 |
case Right(v) => S :: code(v) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
134 |
case Sequ(v1, v2) => code(v1) ::: code(v2) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
135 |
case Stars(Nil) => Z::Nil |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
136 |
case Stars(v::vs) => S::code(v) ::: code(Stars(vs)) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
137 |
} |
| 0 | 138 |
|
|
11
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
139 |
|
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
140 |
def retrieve(r: ARexp, v: Val): Bits = (r,v) match {
|
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
141 |
case (AONE(bs), Empty) => bs |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
142 |
case (ACHAR(bs, c), Chr(d)) => bs |
| 14 | 143 |
case (AALTS(bs, a::Nil), v) => bs ++ retrieve(a, v) |
|
11
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
144 |
case (AALTS(bs, as), Left(v)) => bs ++ retrieve(as.head,v) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
145 |
case (AALTS(bs, as), Right(v)) => bs ++ retrieve(AALTS(Nil,as.tail),v) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
146 |
case (ASEQ(bs, a1, a2), Sequ(v1, v2)) => bs ++ retrieve(a1, v1) ++ retrieve(a2, v2) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
147 |
case (ASTAR(bs, a), Stars(Nil)) => bs ++ List(Z) |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
148 |
case (ASTAR(bs, a), Stars(v::vs)) => bs ++ List(S) ++ retrieve(a, v) ++ retrieve(ASTAR(Nil, a), Stars(vs)) |
| 59 | 149 |
}//bug here last clause should not add list(S) |
| 0 | 150 |
//erase function: extracts the regx from Aregex |
151 |
def erase(r:ARexp): Rexp = r match{
|
|
152 |
case AZERO => ZERO |
|
153 |
case AONE(_) => ONE |
|
154 |
case ACHAR(bs, f) => CHAR(f) |
|
155 |
case AALTS(bs, rs) => ALTS(rs.map(erase(_))) |
|
156 |
case ASEQ(bs, r1, r2) => SEQ (erase(r1), erase(r2)) |
|
157 |
case ASTAR(cs, r)=> STAR(erase(r)) |
|
158 |
} |
|
159 |
||
160 |
//--------------------------------------------------------------------------------------------------------START OF NON-BITCODE PART |
|
161 |
// nullable function: tests whether the regular |
|
162 |
// expression can recognise the empty string |
|
163 |
def nullable (r: Rexp) : Boolean = r match {
|
|
164 |
case ZERO => false |
|
165 |
case ONE => true |
|
166 |
case CHAR(_) => false |
|
167 |
case ALTS(rs) => rs.exists(nullable) |
|
168 |
case SEQ(r1, r2) => nullable(r1) && nullable(r2) |
|
169 |
case STAR(_) => true |
|
170 |
case RECD(_, r) => nullable(r) |
|
171 |
//case PLUS(r) => nullable(r) |
|
172 |
} |
|
173 |
||
174 |
// derivative of a regular expression w.r.t. a character |
|
175 |
def der (c: Char, r: Rexp) : Rexp = r match {
|
|
176 |
case ZERO => ZERO |
|
177 |
case ONE => ZERO |
|
178 |
case CHAR(f) => if (c == f) ONE else ZERO |
|
179 |
case ALTS(List(r1, r2)) => ALTS(List(der(c, r1), der(c, r2))) |
|
180 |
case SEQ(r1, r2) => |
|
181 |
if (nullable(r1)) ALTS(List(SEQ(der(c, r1), r2), der(c, r2))) |
|
182 |
else SEQ(der(c, r1), r2) |
|
183 |
case STAR(r) => SEQ(der(c, r), STAR(r)) |
|
184 |
case RECD(_, r1) => der(c, r1) |
|
185 |
//case PLUS(r) => SEQ(der(c, r), STAR(r)) |
|
186 |
} |
|
187 |
||
| 92 | 188 |
def ders (s: List[Char], r: Rexp) : Rexp = s match {
|
189 |
case Nil => r |
|
190 |
case c::s => ders(s, der(c, r)) |
|
191 |
} |
|
192 |
||
193 |
def der_seqo(r:Rexp, s: List[Char],acc: List[Rexp]) : List[Rexp] = s match{
|
|
194 |
case Nil => acc ::: List(r) |
|
195 |
case c::cs => der_seqo(der(c, r), cs, acc ::: List(r)) |
|
196 |
} |
|
197 |
def der_seq_revo(r:Rexp, s: List[Char], acc: List[Rexp]): List[Rexp] = s match{
|
|
198 |
case Nil => r::acc |
|
199 |
case c::cs =>der_seq_revo(r, cs, ders(s, r) :: acc ) |
|
200 |
} |
|
201 |
def re_closeo(l1: List[Rexp], l2: List[Rexp], re_init: Rexp): Rexp = l1 match {
|
|
202 |
case Nil => re_init |
|
203 |
case c::cs => if(nullable(c)) re_closeo(cs, l2.tail, ALT(re_init, l2.head) ) |
|
204 |
else re_closeo(cs, l2.tail, re_init) |
|
205 |
} |
|
| 93 | 206 |
|
| 92 | 207 |
//HERE |
208 |
def closed_string_dero(r1: Rexp, r2: Rexp, s: List[Char]): Rexp = {
|
|
209 |
val l1 = der_seqo(r1, s, Nil) |
|
210 |
val l2 = der_seq_revo(r2, s, Nil) |
|
211 |
val Re = re_closeo((l1.reverse).tail, l2.tail, SEQ(l1.last, l2.head)) |
|
212 |
Re |
|
213 |
} |
|
214 |
//derivative w.r.t string |
|
215 |
def ders2(s: List[Char], r: Rexp) : Rexp = (s, r) match {
|
|
216 |
case (Nil, r) => r |
|
217 |
case (s, ZERO) => ZERO |
|
218 |
case (s, ONE) => if (s == Nil) ONE else ZERO |
|
219 |
case (s, CHAR(c)) => if (s == List(c)) ONE else |
|
220 |
if (s == Nil) CHAR(c) else ZERO |
|
221 |
case (s, ALTS(List(r1, r2))) => ALT(ders2(s, r1), ders2(s, r2)) |
|
222 |
case (s, SEQ(r1, r2)) => closed_string_dero(r1, r2, s) |
|
223 |
case (c::cs, STAR(r)) => closed_string_dero(der(c, r), STAR(r), cs) |
|
224 |
} |
|
225 |
||
| 0 | 226 |
def flatten(v: Val) : String = v match {
|
227 |
case Empty => "" |
|
228 |
case Chr(c) => c.toString |
|
229 |
case Left(v) => flatten(v) |
|
230 |
case Right(v) => flatten(v) |
|
231 |
case Sequ(v1, v2) => flatten(v1) + flatten(v2) |
|
232 |
case Stars(vs) => vs.map(flatten).mkString |
|
233 |
case Rec(_, v) => flatten(v) |
|
234 |
} |
|
235 |
||
236 |
// extracts an environment from a value |
|
237 |
def env(v: Val) : List[(String, String)] = v match {
|
|
238 |
case Empty => Nil |
|
239 |
case Chr(c) => Nil |
|
240 |
case Left(v) => env(v) |
|
241 |
case Right(v) => env(v) |
|
242 |
case Sequ(v1, v2) => env(v1) ::: env(v2) |
|
243 |
case Stars(vs) => vs.flatMap(env) |
|
244 |
case Rec(x, v) => (x, flatten(v))::env(v) |
|
245 |
} |
|
246 |
||
247 |
||
248 |
// injection part |
|
249 |
def mkeps(r: Rexp) : Val = r match {
|
|
250 |
case ONE => Empty |
|
251 |
case ALTS(List(r1, r2)) => |
|
252 |
if (nullable(r1)) Left(mkeps(r1)) else Right(mkeps(r2)) |
|
253 |
case SEQ(r1, r2) => Sequ(mkeps(r1), mkeps(r2)) |
|
254 |
case STAR(r) => Stars(Nil) |
|
255 |
case RECD(x, r) => Rec(x, mkeps(r)) |
|
256 |
//case PLUS(r) => Stars(List(mkeps(r))) |
|
257 |
} |
|
258 |
||
259 |
def inj(r: Rexp, c: Char, v: Val) : Val = (r, v) match {
|
|
260 |
case (STAR(r), Sequ(v1, Stars(vs))) => Stars(inj(r, c, v1)::vs) |
|
261 |
case (SEQ(r1, r2), Sequ(v1, v2)) => Sequ(inj(r1, c, v1), v2) |
|
262 |
case (SEQ(r1, r2), Left(Sequ(v1, v2))) => Sequ(inj(r1, c, v1), v2) |
|
263 |
case (SEQ(r1, r2), Right(v2)) => Sequ(mkeps(r1), inj(r2, c, v2)) |
|
264 |
case (ALTS(List(r1, r2)), Left(v1)) => Left(inj(r1, c, v1)) |
|
265 |
case (ALTS(List(r1, r2)), Right(v2)) => Right(inj(r2, c, v2)) |
|
266 |
case (CHAR(_), Empty) => Chr(c) |
|
267 |
case (RECD(x, r1), _) => Rec(x, inj(r1, c, v)) |
|
268 |
//case (PLUS(r), Sequ(v1, Stars(vs))) => Stars(inj(r, c, v1)::vs) |
|
269 |
} |
|
270 |
def lex(r: Rexp, s: List[Char]) : Val = s match {
|
|
271 |
case Nil => if (nullable(r)) mkeps(r) else throw new Exception("Not matched")
|
|
272 |
case c::cs => inj(r, c, lex(der(c, r), cs)) |
|
273 |
} |
|
274 |
||
275 |
def lexing(r: Rexp, s: String) : Val = lex(r, s.toList) |
|
276 |
||
277 |
// some "rectification" functions for simplification |
|
278 |
def F_ID(v: Val): Val = v |
|
279 |
def F_RIGHT(f: Val => Val) = (v:Val) => Right(f(v)) |
|
280 |
def F_LEFT(f: Val => Val) = (v:Val) => Left(f(v)) |
|
281 |
def F_ALT(f1: Val => Val, f2: Val => Val) = (v:Val) => v match {
|
|
282 |
case Right(v) => Right(f2(v)) |
|
283 |
case Left(v) => Left(f1(v)) |
|
284 |
} |
|
285 |
def F_SEQ(f1: Val => Val, f2: Val => Val) = (v:Val) => v match {
|
|
286 |
case Sequ(v1, v2) => Sequ(f1(v1), f2(v2)) |
|
287 |
} |
|
288 |
def F_SEQ_Empty1(f1: Val => Val, f2: Val => Val) = |
|
289 |
(v:Val) => Sequ(f1(Empty), f2(v)) |
|
290 |
def F_SEQ_Empty2(f1: Val => Val, f2: Val => Val) = |
|
291 |
(v:Val) => Sequ(f1(v), f2(Empty)) |
|
292 |
def F_RECD(f: Val => Val) = (v:Val) => v match {
|
|
293 |
case Rec(x, v) => Rec(x, f(v)) |
|
294 |
} |
|
295 |
def F_ERROR(v: Val): Val = throw new Exception("error")
|
|
296 |
||
297 |
// simplification of regular expressions returning also an |
|
298 |
// rectification function; no simplification under STAR |
|
299 |
def simp(r: Rexp): (Rexp, Val => Val) = r match {
|
|
300 |
case ALTS(List(r1, r2)) => {
|
|
301 |
val (r1s, f1s) = simp(r1) |
|
302 |
val (r2s, f2s) = simp(r2) |
|
303 |
(r1s, r2s) match {
|
|
304 |
case (ZERO, _) => (r2s, F_RIGHT(f2s)) |
|
305 |
case (_, ZERO) => (r1s, F_LEFT(f1s)) |
|
306 |
case _ => if (r1s == r2s) (r1s, F_LEFT(f1s)) |
|
307 |
else (ALTS(List(r1s, r2s)), F_ALT(f1s, f2s)) |
|
308 |
} |
|
309 |
} |
|
310 |
case SEQ(r1, r2) => {
|
|
311 |
val (r1s, f1s) = simp(r1) |
|
312 |
val (r2s, f2s) = simp(r2) |
|
313 |
(r1s, r2s) match {
|
|
314 |
case (ZERO, _) => (ZERO, F_ERROR) |
|
315 |
case (_, ZERO) => (ZERO, F_ERROR) |
|
316 |
case (ONE, _) => (r2s, F_SEQ_Empty1(f1s, f2s)) |
|
317 |
case (_, ONE) => (r1s, F_SEQ_Empty2(f1s, f2s)) |
|
318 |
case _ => (SEQ(r1s,r2s), F_SEQ(f1s, f2s)) |
|
319 |
} |
|
320 |
} |
|
321 |
case RECD(x, r1) => {
|
|
322 |
val (r1s, f1s) = simp(r1) |
|
323 |
(RECD(x, r1s), F_RECD(f1s)) |
|
324 |
} |
|
325 |
case r => (r, F_ID) |
|
326 |
} |
|
327 |
/* |
|
328 |
val each_simp_time = scala.collection.mutable.ArrayBuffer.empty[Long] |
|
329 |
val each_simp_timeb = scala.collection.mutable.ArrayBuffer.empty[Long] |
|
330 |
*/ |
|
331 |
def lex_simp(r: Rexp, s: List[Char]) : Val = s match {
|
|
332 |
case Nil => {
|
|
333 |
if (nullable(r)) {
|
|
334 |
mkeps(r) |
|
335 |
} |
|
336 |
else throw new Exception("Not matched")
|
|
337 |
} |
|
338 |
case c::cs => {
|
|
339 |
val (r_simp, f_simp) = simp(der(c, r)) |
|
340 |
inj(r, c, f_simp(lex_simp(r_simp, cs))) |
|
341 |
} |
|
342 |
} |
|
343 |
||
344 |
def lexing_simp(r: Rexp, s: String) : Val = lex_simp(r, s.toList) |
|
345 |
||
346 |
//println(lexing_simp(("a" | "ab") ~ ("b" | ""), "ab"))
|
|
347 |
||
348 |
// filters out all white spaces |
|
349 |
def tokenise(r: Rexp, s: String) = |
|
350 |
env(lexing_simp(r, s)).filterNot { _._1 == "w"}
|
|
351 |
||
352 |
||
353 |
//reads the string from a file |
|
354 |
def fromFile(name: String) : String = |
|
355 |
io.Source.fromFile(name).mkString |
|
356 |
||
357 |
def tokenise_file(r: Rexp, name: String) = |
|
358 |
tokenise(r, fromFile(name)) |
|
359 |
||
360 |
// Testing |
|
361 |
//============ |
|
362 |
||
363 |
def time[T](code: => T) = {
|
|
364 |
val start = System.nanoTime() |
|
365 |
val result = code |
|
366 |
val end = System.nanoTime() |
|
367 |
println((end - start)/1.0e9) |
|
368 |
result |
|
369 |
} |
|
370 |
||
371 |
//--------------------------------------------------------------------------------------------------------END OF NON-BITCODE PART |
|
372 |
||
373 |
// bnullable function: tests whether the aregular |
|
374 |
// expression can recognise the empty string |
|
375 |
def bnullable (r: ARexp) : Boolean = r match {
|
|
376 |
case AZERO => false |
|
377 |
case AONE(_) => true |
|
378 |
case ACHAR(_,_) => false |
|
379 |
case AALTS(_, rs) => rs.exists(bnullable) |
|
380 |
case ASEQ(_, r1, r2) => bnullable(r1) && bnullable(r2) |
|
381 |
case ASTAR(_, _) => true |
|
382 |
} |
|
383 |
||
384 |
def mkepsBC(r: ARexp) : Bits = r match {
|
|
385 |
case AONE(bs) => bs |
|
386 |
case AALTS(bs, rs) => {
|
|
387 |
val n = rs.indexWhere(bnullable) |
|
388 |
bs ++ mkepsBC(rs(n)) |
|
389 |
} |
|
390 |
case ASEQ(bs, r1, r2) => bs ++ mkepsBC(r1) ++ mkepsBC(r2) |
|
391 |
case ASTAR(bs, r) => bs ++ List(Z) |
|
392 |
} |
|
393 |
||
394 |
// derivative of a regular expression w.r.t. a character |
|
395 |
def bder(c: Char, r: ARexp) : ARexp = r match {
|
|
396 |
case AZERO => AZERO |
|
397 |
case AONE(_) => AZERO |
|
|
12
768b833d6230
removed C(c) The retrieve and code in the previous version is still not correct and will crash. no prob now.
Chengsong
parents:
11
diff
changeset
|
398 |
case ACHAR(bs, f) => if (c == f) AONE(bs) else AZERO |
| 0 | 399 |
case AALTS(bs, rs) => AALTS(bs, rs.map(bder(c, _))) |
400 |
case ASEQ(bs, r1, r2) => |
|
401 |
if (bnullable(r1)) AALT(bs, ASEQ(Nil, bder(c, r1), r2), fuse(mkepsBC(r1), bder(c, r2))) |
|
402 |
else ASEQ(bs, bder(c, r1), r2) |
|
403 |
case ASTAR(bs, r) => ASEQ(bs, fuse(List(S), bder(c, r)), ASTAR(Nil, r)) |
|
404 |
} |
|
405 |
||
406 |
// derivative w.r.t. a string (iterates bder) |
|
407 |
@tailrec |
|
408 |
def bders (s: List[Char], r: ARexp) : ARexp = s match {
|
|
409 |
case Nil => r |
|
410 |
case c::s => bders(s, bder(c, r)) |
|
411 |
} |
|
412 |
||
413 |
def flats(rs: List[ARexp]): List[ARexp] = rs match {
|
|
414 |
case Nil => Nil |
|
415 |
case AZERO :: rs1 => flats(rs1) |
|
416 |
case AALTS(bs, rs1) :: rs2 => rs1.map(fuse(bs, _)) ::: flats(rs2) |
|
417 |
case r1 :: rs2 => r1 :: flats(rs2) |
|
| 15 | 418 |
} |
| 17 | 419 |
/* |
| 15 | 420 |
def remove(v: Val): Val = v match{
|
421 |
case Right(v1) => v1 |
|
422 |
case Left(v1) => v1 |
|
423 |
case _ => throw new Exception("Not removable")
|
|
| 17 | 424 |
}*/ |
| 15 | 425 |
def augment(v: Val, i: Int): Val = if(i > 1) augment(Right(v), i - 1) else Right(v) |
426 |
//an overly complex version |
|
427 |
/* |
|
428 |
if(rel_dist >0){//the regex we are dealing with is not what v points at
|
|
429 |
rs match{
|
|
430 |
case Nil => throw new Exception("Trying to simplify a non-existent value")
|
|
431 |
case AZERO :: rs1 => flats_vsimp(rs1, rel_dist - 1, remove(v)) |
|
432 |
case AALTS(bs, rs1) :: rs2 => flats_vsimp(rs2, rel_dist - 1, augment(v, rs1.length - 1))//rs1 is guaranteed to have a len geq 2 |
|
433 |
case r1 :: rs2 => flats_vsimp(rs2, rel_dist - 1, v) |
|
434 |
} |
|
| 0 | 435 |
} |
| 15 | 436 |
else if(rel_dist == 0){//we are dealing with regex v is pointing to -- "v->r itself"
|
437 |
rs match{//r1 cannot be zero
|
|
438 |
AALTS(bs, rs1) :: rs2 => flats_vsimp( ) |
|
439 |
AZERO::rs2 => throw new Exception("Value corresponds to zero")
|
|
440 |
r1::rs2 => flats_vsimp(rs2, rel_dist - 1, v) |
|
441 |
} |
|
442 |
||
443 |
} |
|
444 |
else{
|
|
445 |
||
446 |
} |
|
447 |
*/ |
|
448 |
def flats_vsimp(rs: List[ARexp], position: Int): Int = (rs, position) match {
|
|
449 |
case (_, 0) => 0 |
|
450 |
case (Nil, _) => 0 |
|
| 16 | 451 |
case (AZERO :: rs1, _) => flats_vsimp(rs1, position - 1) - 1 |
| 15 | 452 |
case (AALTS(bs, rs1) :: rs2, _) => rs1.length - 1 + flats_vsimp(rs2, position - 1) |
453 |
case (r1 :: rs2, _) => flats_vsimp(rs2, position - 1) |
|
454 |
} |
|
| 0 | 455 |
def rflats(rs: List[Rexp]): List[Rexp] = rs match {
|
456 |
case Nil => Nil |
|
457 |
case ZERO :: rs1 => rflats(rs1) |
|
458 |
case ALTS(rs1) :: rs2 => rs1 ::: rflats(rs2) |
|
459 |
case r1 :: rs2 => r1 :: rflats(rs2) |
|
460 |
} |
|
461 |
var flats_time = 0L |
|
462 |
var dist_time = 0L |
|
463 |
||
464 |
def bsimp(r: ARexp): ARexp = r match {
|
|
465 |
case ASEQ(bs1, r1, r2) => (bsimp(r1), bsimp(r2)) match {
|
|
466 |
case (AZERO, _) => AZERO |
|
467 |
case (_, AZERO) => AZERO |
|
468 |
case (AONE(bs2), r2s) => fuse(bs1 ++ bs2, r2s) |
|
469 |
case (r1s, r2s) => ASEQ(bs1, r1s, r2s) |
|
470 |
} |
|
471 |
case AALTS(bs1, rs) => {
|
|
472 |
val rs_simp = rs.map(bsimp) |
|
473 |
val flat_res = flats(rs_simp) |
|
474 |
val dist_res = distinctBy(flat_res, erase) |
|
475 |
dist_res match {
|
|
476 |
case Nil => AZERO |
|
| 93 | 477 |
case r :: Nil => fuse(bs1, r) |
| 0 | 478 |
case rs => AALTS(bs1, rs) |
479 |
} |
|
480 |
} |
|
| 5 | 481 |
//case ASTAR(bs, r) => ASTAR(bs, bsimp(r)) |
| 0 | 482 |
case r => r |
483 |
} |
|
| 93 | 484 |
//only print at the top level |
485 |
||
| 17 | 486 |
def find_pos(v: Val, rs: List[ARexp]): Int = (v, rs) match{
|
487 |
case (v, r::Nil) => 0 |
|
| 15 | 488 |
case (Right(v), r::rs) => find_pos(v, rs) + 1 |
| 17 | 489 |
case (Left(v), r::rs) => 0 |
490 |
//case (v, _) => 0 |
|
491 |
} |
|
492 |
def find_pos_aux(v: Val, r: ARexp): Int = r match {
|
|
493 |
case AALTS(bs, rs) => find_pos(v, rs) |
|
494 |
case r => 0 |
|
| 15 | 495 |
} |
| 17 | 496 |
def remove(v: Val, rs: List[ARexp]) : Val = (v,rs) match {//remove the outmost layer of ALTS's Left and Right
|
497 |
//we have to use r to detect the bound of nested L/Rs |
|
498 |
case (v, r::Nil) => v |
|
499 |
case (Right(v), r::rs) => remove(v, rs) |
|
| 15 | 500 |
case (Left(v), r::rs) => v |
| 17 | 501 |
//case (v, r::Nil) => v |
| 15 | 502 |
} |
| 16 | 503 |
def simple_end(v: Val): Boolean = v match {
|
| 15 | 504 |
case Left(v) => return false |
505 |
case Right(v) => return simple_end(v) |
|
506 |
case v => return true |
|
507 |
} |
|
| 17 | 508 |
def isend(v: Val, rs: List[ARexp], position: Int): Boolean = {//TODO: here the slice api i am not familiar with so this call might be incorrect and crash the bsimp2
|
509 |
val rsbh = rs.slice(position + 1, rs.length) |
|
| 15 | 510 |
val out_end = if(flats(rsbh) == Nil) true else false |
511 |
val inner_end = simple_end(v) |
|
512 |
inner_end && out_end |
|
513 |
} |
|
| 16 | 514 |
def get_coat(v: Val, rs: List[Rexp], vs: Val): Val = (v, rs) match{//the dual operation of remove(so-called by myself)
|
| 15 | 515 |
case (Right(v), r::Nil) => Right(vs) |
516 |
case (Left(v), r::rs) => Left(vs) |
|
517 |
case (Right(v), r::rs) => Right(get_coat(v, rs, vs)) |
|
518 |
} |
|
519 |
def coat(v: Val, i: Int) : Val = i match {
|
|
520 |
case 0 => v |
|
521 |
case i => coat(Right(v), i - 1) |
|
522 |
} |
|
| 17 | 523 |
//This version takes a regex and a value, return a simplified regex and its corresponding simplified value |
524 |
def bsimp2(r: ARexp, v: Val): (ARexp, Val) = (r,v) match{
|
|
525 |
case (ASEQ(bs1, r1, r2), Sequ(v1, v2)) => (bsimp2(r1, v1), bsimp2(r2, v2)) match {
|
|
526 |
case ((AZERO, _), (_, _) )=> (AZERO, undefined) |
|
527 |
case ((_, _), (AZERO, _)) => (AZERO, undefined) |
|
528 |
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. |
|
529 |
case ((r1s, v1s), (r2s, v2s)) => (ASEQ(bs1, r1s, r2s), Sequ(v1s, v2s)) |
|
530 |
} |
|
531 |
case (AALTS(bs1, rs), v) => {
|
|
532 |
//phase 1 transformation so that aalts(bs1, rs) => aalts(bs1, rsf) and v => vf |
|
533 |
val init_ind = find_pos(v, rs) |
|
534 |
val vs = bsimp2(rs(init_ind), remove(v, rs))//remove all the outer layers of left and right in v to match the regx rs[i] |
|
535 |
//println(vs) |
|
536 |
val rs_simp = rs.map(bsimp) |
|
537 |
val vs_kernel = rs_simp(init_ind) match {
|
|
538 |
case AALTS(bs2, rs2) => remove(vs._2, rs2)//remove the secondary layer of left and right |
|
539 |
case r => vs._2 |
|
540 |
} |
|
541 |
val flat_res = flats(rs_simp) |
|
542 |
val vs_for_coating = if(isend(vs._2, rs_simp, init_ind)||flat_res.length == 1) vs_kernel else Left(vs_kernel) |
|
543 |
val r_s = rs_simp(init_ind)//or vs._1 |
|
544 |
val shift = flats_vsimp(rs_simp, init_ind) + find_pos_aux(vs._2, rs_simp(init_ind)) |
|
545 |
val new_ind = init_ind + shift |
|
546 |
val vf = coat(vs_for_coating, new_ind) |
|
547 |
//flats2 returns a list of regex and a single v |
|
548 |
//now |- vf: ALTS(bs1, flat_res) |
|
549 |
//phase 2 transformation so that aalts(bs1, rsf) => aalts(bs, rsdb) and vf => vdb |
|
550 |
val dist_res = distinctBy(flat_res, erase) |
|
551 |
val front_part = distinctBy(flat_res.slice(0, new_ind + 1), erase) |
|
552 |
//val size_reduction = new_ind + 1 - front_part.length |
|
553 |
val vdb = if(dist_res.length == front_part.length )//that means the regex we are interested in is at the end of the list |
|
554 |
{
|
|
555 |
coat(vs_kernel, front_part.length - 1) |
|
556 |
} |
|
557 |
else{
|
|
558 |
coat(Left(vs_kernel), front_part.length - 1) |
|
559 |
} |
|
560 |
//println(vdb) |
|
561 |
//we don't need to transform vdb as this phase will not make enough changes to the regex to affect value. |
|
562 |
//the above statement needs verification. but can be left as is now. |
|
563 |
dist_res match {
|
|
564 |
case Nil => (AZERO, undefined) |
|
565 |
case s :: Nil => (fuse(bs1, s), vdb) |
|
566 |
case rs => (AALTS(bs1, rs), vdb) |
|
567 |
} |
|
568 |
} |
|
569 |
//case ASTAR(bs, r) => ASTAR(bs, bsimp(r)) |
|
570 |
case (r, v) => (r, v) |
|
571 |
} |
|
572 |
def vsimp(r: ARexp, v: Val): Val = bsimp2(r, v)._2 |
|
573 |
/*This version was first intended for returning a function however a value would be simpler. |
|
| 15 | 574 |
def bsimp2(r: ARexp, v: Val): (ARexp, Val => Val) = (r,v) match{
|
575 |
case (ASEQ(bs1, r1, r2), v) => (bsimp2(r1), bsimp2(r2)) match {
|
|
576 |
case ((AZERO, _), (_, _) )=> (AZERO, undefined) |
|
577 |
case ((_, _), (AZERO, _)) => (AZERO, undefined) |
|
578 |
case ((AONE(bs2), f1) , (r2s, f2)) => (fuse(bs1 ++ bs2, r2s), lambda v => v match { case Sequ(_, v) => f2(v) } )
|
|
579 |
case ((r1s, f1), (r2s, f2)) => (ASEQ(bs1, r1s, r2s), lambda v => v match {case Sequ(v1, v2) => Sequ(f1(v1), f2(v2))}
|
|
580 |
} |
|
581 |
case AALTS(bs1, rs) => {
|
|
582 |
val init_ind = find_pos(v, rs) |
|
583 |
val vs = bsimp2(rs[init_ind], remove(v, rs))//remove all the outer layers of left and right in v to match the regx rs[i] |
|
584 |
val rs_simp = rs.map(bsimp) |
|
585 |
val vs_kernel = rs_simp[init_ind] match {
|
|
586 |
case AALTS(bs2, rs2) => remove(vs, rs_simp[init_ind])//remove the secondary layer of left and right |
|
587 |
case r => vs |
|
588 |
} |
|
589 |
val vs_for_coating = if(isend(vs, rs_simp, init_ind)) vs_kernel else Left(vs_kernel) |
|
590 |
||
591 |
val r_s = rs_simp[init_ind] |
|
592 |
val shift = flats_vsimp(vs, rs_simp, init_ind) + find_pos(vs, rs_simp[init_ind]) |
|
593 |
val vf = coat(vs_for_coating, shift + init_ind) |
|
594 |
||
595 |
val flat_res = flats(rs_simp)//flats2 returns a list of regex and a single v |
|
596 |
val dist_res = distinctBy(flat_res, erase) |
|
597 |
dist_res match {
|
|
598 |
case Nil => AZERO |
|
599 |
case s :: Nil => fuse(bs1, s) |
|
600 |
case rs => AALTS(bs1, rs) |
|
601 |
} |
|
602 |
} |
|
603 |
//case ASTAR(bs, r) => ASTAR(bs, bsimp(r)) |
|
604 |
case r => r |
|
| 16 | 605 |
}*/ |
| 5 | 606 |
def super_bsimp(r: ARexp): ARexp = r match {
|
607 |
case ASEQ(bs1, r1, r2) => (super_bsimp(r1), super_bsimp(r2)) match {
|
|
| 0 | 608 |
case (AZERO, _) => AZERO |
609 |
case (_, AZERO) => AZERO |
|
|
11
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
610 |
case (AONE(bs2), r2s) => fuse(bs1 ++ bs2, r2s)//万一是(r1, alts(rs))这种形式呢 |
|
9c1ca6d6e190
The C(Char) construct is incompatible with the code and retrieve in Fahad's thesis.
Chengsong
parents:
5
diff
changeset
|
611 |
case (AALTS(bs2, rs), r2) => AALTS(bs1 ++ bs2, rs.map(r => r match {case AONE(bs3) => fuse(bs3, r2) case r => ASEQ(Nil, r, r2)} ) )
|
| 0 | 612 |
case (r1s, r2s) => ASEQ(bs1, r1s, r2s) |
613 |
} |
|
614 |
case AALTS(bs1, rs) => {
|
|
| 5 | 615 |
val rs_simp = rs.map(super_bsimp) |
| 0 | 616 |
val flat_res = flats(rs_simp) |
617 |
val dist_res = distinctBy(flat_res, erase) |
|
618 |
dist_res match {
|
|
619 |
case Nil => AZERO |
|
620 |
case s :: Nil => fuse(bs1, s) |
|
621 |
case rs => AALTS(bs1, rs) |
|
622 |
} |
|
623 |
} |
|
| 5 | 624 |
//case ASTAR(bs, r) => ASTAR(bs, bsimp(r)) |
| 0 | 625 |
case r => r |
626 |
} |
|
627 |
||
| 5 | 628 |
|
| 0 | 629 |
def simp_weakened(r: Rexp): Rexp = r match {
|
630 |
case SEQ(r1, r2) => (simp_weakened(r1), r2) match {
|
|
631 |
case (ZERO, _) => ZERO |
|
632 |
case (_, ZERO) => ZERO |
|
633 |
case (ONE, r2s) => r2s |
|
634 |
case (r1s, r2s) => SEQ(r1s, r2s) |
|
635 |
} |
|
636 |
case ALTS(rs) => {
|
|
637 |
val rs_simp = rs.map(simp_weakened) |
|
638 |
val flat_res = rflats(rs_simp) |
|
639 |
val dist_res = rs_simp.distinct |
|
640 |
dist_res match {
|
|
641 |
case Nil => ZERO |
|
642 |
case s :: Nil => s |
|
643 |
case rs => ALTS(rs) |
|
644 |
} |
|
645 |
} |
|
646 |
case STAR(r) => STAR(simp_weakened(r)) |
|
647 |
case r => r |
|
648 |
} |
|
649 |
||
650 |
def bders_simp (s: List[Char], r: ARexp) : ARexp = s match {
|
|
651 |
case Nil => r |
|
652 |
case c::s => bders_simp(s, bsimp(bder(c, r))) |
|
653 |
} |
|
| 14 | 654 |
//----------------------------------------------------------------------------experiment bsimp |
655 |
/* |
|
656 |
||
| 0 | 657 |
*/ |
658 |
/* |
|
659 |
def time[T](code: => T) = {
|
|
660 |
val start = System.nanoTime() |
|
661 |
val result = code |
|
662 |
val end = System.nanoTime() |
|
663 |
println((end - start)/1.0e9) |
|
664 |
result |
|
665 |
} |
|
666 |
*/ |
|
667 |
// main unsimplified lexing function (produces a value) |
|
668 |
def blex(r: ARexp, s: List[Char]) : Bits = s match {
|
|
669 |
case Nil => if (bnullable(r)) mkepsBC(r) else throw new Exception("Not matched")
|
|
670 |
case c::cs => {
|
|
671 |
val der_res = bder(c,r) |
|
672 |
blex(der_res, cs) |
|
673 |
} |
|
674 |
} |
|
675 |
||
676 |
def bpre_lexing(r: Rexp, s: String) = blex(internalise(r), s.toList) |
|
| 14 | 677 |
def blexing(r: Rexp, s: String) : Val = decode(r, blex(internalise(r), s.toList)) |
| 0 | 678 |
|
679 |
var bder_time = 0L |
|
680 |
var bsimp_time = 0L |
|
681 |
var mkepsBC_time = 0L |
|
682 |
var small_de = 2 |
|
683 |
var big_de = 5 |
|
684 |
var usual_de = 3 |
|
685 |
||
686 |
def blex_simp(r: ARexp, s: List[Char]) : Bits = s match {
|
|
687 |
case Nil => {
|
|
688 |
if (bnullable(r)) {
|
|
689 |
//println(asize(r)) |
|
| 5 | 690 |
mkepsBC(r) |
| 0 | 691 |
} |
692 |
else throw new Exception("Not matched")
|
|
693 |
} |
|
694 |
case c::cs => {
|
|
695 |
val der_res = bder(c,r) |
|
696 |
val simp_res = bsimp(der_res) |
|
697 |
blex_simp(simp_res, cs) |
|
698 |
} |
|
699 |
} |
|
| 5 | 700 |
def super_blex_simp(r: ARexp, s: List[Char]): Bits = s match {
|
701 |
case Nil => {
|
|
702 |
if (bnullable(r)) {
|
|
703 |
mkepsBC(r) |
|
704 |
} |
|
705 |
else throw new Exception("Not matched")
|
|
706 |
} |
|
707 |
case c::cs => {
|
|
708 |
super_blex_simp(super_bsimp(bder(c,r)), cs) |
|
709 |
} |
|
710 |
} |
|
| 0 | 711 |
def blex_real_simp(r: ARexp, s: List[Char]): ARexp = s match{
|
712 |
case Nil => r |
|
713 |
case c::cs => blex_real_simp(bsimp(bder(c, r)), cs) |
|
714 |
} |
|
715 |
||
716 |
||
717 |
//size: of a Aregx for testing purposes |
|
718 |
def size(r: Rexp) : Int = r match {
|
|
719 |
case ZERO => 1 |
|
720 |
case ONE => 1 |
|
721 |
case CHAR(_) => 1 |
|
722 |
case SEQ(r1, r2) => 1 + size(r1) + size(r2) |
|
723 |
case ALTS(rs) => 1 + rs.map(size).sum |
|
724 |
case STAR(r) => 1 + size(r) |
|
725 |
} |
|
726 |
||
727 |
def asize(a: ARexp) = size(erase(a)) |
|
728 |
||
729 |
||
730 |
// decoding does not work yet |
|
731 |
def blexing_simp(r: Rexp, s: String) = {
|
|
732 |
val bit_code = blex_simp(internalise(r), s.toList) |
|
| 5 | 733 |
decode(r, bit_code) |
734 |
} |
|
735 |
def super_blexing_simp(r: Rexp, s: String) = {
|
|
736 |
decode(r, super_blex_simp(internalise(r), s.toList)) |
|
| 0 | 737 |
} |
738 |
||
739 |
||
740 |
||
741 |
||
742 |
||
743 |
// Lexing Rules for a Small While Language |
|
744 |
||
745 |
//symbols |
|
746 |
/* |
|
747 |
val SYM = PRED("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ".contains(_))
|
|
748 |
||
749 |
//digits |
|
750 |
val DIGIT = PRED("0123456789".contains(_))
|
|
751 |
//identifiers |
|
752 |
val ID = SYM ~ (SYM | DIGIT).% |
|
753 |
//numbers |
|
754 |
val NUM = STAR(DIGIT) |
|
755 |
//keywords |
|
756 |
val KEYWORD : Rexp = "skip" | "while" | "do" | "if" | "then" | "else" | "read" | "write" | "true" | "false" |
|
757 |
val AKEYWORD: Rexp = ALTS(List("skip" , "while" , "do" , "if" , "then" , "else" , "read" , "write" , "true" , "false"))
|
|
758 |
//semicolons |
|
759 |
val SEMI: Rexp = ";" |
|
760 |
//operators |
|
761 |
val OP: Rexp = ":=" | "==" | "-" | "+" | "*" | "!=" | "<" | ">" | "<=" | ">=" | "%" | "/" |
|
762 |
val AOP: Rexp = ALTS(List(":=" , "==" , "-" , "+" , "*" , "!=" , "<" , ">" , "<=" , ">=" , "%" , "/"))
|
|
763 |
//whitespaces |
|
764 |
val WHITESPACE = PLUS(" " | "\n" | "\t")
|
|
765 |
//parentheses |
|
766 |
val RPAREN: Rexp = ")" |
|
767 |
val LPAREN: Rexp = "("
|
|
768 |
val BEGIN: Rexp = "{"
|
|
769 |
val END: Rexp = "}" |
|
770 |
//strings...but probably needs not |
|
771 |
val STRING: Rexp = "\"" ~ SYM.% ~ "\"" |
|
772 |
||
773 |
||
774 |
||
775 |
val WHILE_REGS = (("k" $ KEYWORD) |
|
|
776 |
("i" $ ID) |
|
|
777 |
("o" $ OP) |
|
|
778 |
("n" $ NUM) |
|
|
779 |
("s" $ SEMI) |
|
|
780 |
("str" $ STRING) |
|
|
781 |
("p" $ (LPAREN | RPAREN)) |
|
|
782 |
("b" $ (BEGIN | END)) |
|
|
783 |
("w" $ WHITESPACE)).%
|
|
784 |
||
785 |
val AWHILE_REGS = ( |
|
786 |
ALTS( |
|
787 |
List( |
|
788 |
("k" $ AKEYWORD),
|
|
789 |
("i" $ ID),
|
|
790 |
("o" $ AOP) ,
|
|
791 |
("n" $ NUM) ,
|
|
792 |
("s" $ SEMI) ,
|
|
793 |
("str" $ STRING),
|
|
794 |
("p" $ (LPAREN | RPAREN)),
|
|
795 |
("b" $ (BEGIN | END)),
|
|
796 |
("w" $ WHITESPACE)
|
|
797 |
) |
|
798 |
) |
|
799 |
).% |
|
800 |
||
801 |
*/ |
|
802 |
||
803 |
||
804 |
//--------------------------------------------------------------------------------------------------------START OF NON-BITCODE PART (TESTING) |
|
805 |
/* |
|
806 |
// Two Simple While programs |
|
807 |
//======================== |
|
808 |
println("prog0 test")
|
|
809 |
||
810 |
val prog0 = """read n""" |
|
811 |
println(env(lexing_simp(WHILE_REGS, prog0))) |
|
812 |
println(tokenise(WHILE_REGS, prog0)) |
|
813 |
||
814 |
println("prog1 test")
|
|
815 |
||
816 |
val prog1 = """read n; write (n)""" |
|
817 |
println(tokenise(WHILE_REGS, prog1)) |
|
818 |
||
819 |
*/ |
|
820 |
// Bigger Tests |
|
821 |
//============== |
|
822 |
||
823 |
def escape(raw: String): String = {
|
|
824 |
import scala.reflect.runtime.universe._ |
|
825 |
Literal(Constant(raw)).toString |
|
826 |
} |
|
827 |
||
828 |
val prog2 = """ |
|
829 |
write "Fib"; |
|
830 |
read n; |
|
831 |
minus1 := 0; |
|
832 |
minus2 := 1; |
|
833 |
while n > 0 do {
|
|
834 |
temp := minus2; |
|
835 |
minus2 := minus1 + minus2; |
|
836 |
minus1 := temp; |
|
837 |
n := n - 1 |
|
838 |
}; |
|
839 |
write "Result"; |
|
840 |
write minus2 |
|
841 |
""" |
|
842 |
||
843 |
val prog3 = """ |
|
844 |
start := 1000; |
|
845 |
x := start; |
|
846 |
y := start; |
|
847 |
z := start; |
|
848 |
while 0 < x do {
|
|
849 |
while 0 < y do {
|
|
850 |
while 0 < z do {
|
|
851 |
z := z - 1 |
|
852 |
}; |
|
853 |
z := start; |
|
854 |
y := y - 1 |
|
855 |
}; |
|
856 |
y := start; |
|
857 |
x := x - 1 |
|
858 |
} |
|
859 |
""" |
|
860 |
/* |
|
861 |
for(i <- 400 to 400 by 1){
|
|
862 |
println(i+":") |
|
863 |
blexing_simp(WHILE_REGS, prog2 * i) |
|
864 |
} */ |
|
865 |
||
866 |
/* |
|
867 |
for (i <- 2 to 5){
|
|
868 |
for(j <- 1 to 3){
|
|
869 |
println(i,j) |
|
870 |
small_de = i |
|
871 |
usual_de = i + j |
|
872 |
big_de = i + 2*j |
|
873 |
blexing_simp(AWHILE_REGS, prog2 * 100) |
|
874 |
} |
|
875 |
}*/ |
|
876 |
||
877 |
/* |
|
878 |
println("Tokens of prog2")
|
|
879 |
println(tokenise(WHILE_REGS, prog2).mkString("\n"))
|
|
880 |
||
881 |
val fib_tokens = tokenise(WHILE_REGS, prog2) |
|
882 |
fib_tokens.map{case (s1, s2) => (escape(s1), escape(s2))}.mkString(",\n")
|
|
883 |
||
884 |
||
885 |
val test_tokens = tokenise(WHILE_REGS, prog3) |
|
886 |
test_tokens.map{case (s1, s2) => (escape(s1), escape(s2))}.mkString(",\n")
|
|
887 |
*/ |
|
888 |
||
889 |
/* |
|
890 |
println("time test for blexing_simp")
|
|
891 |
for (i <- 1 to 1 by 1) {
|
|
892 |
lexing_simp(WHILE_REGS, prog2 * i) |
|
893 |
blexing_simp(WHILE_REGS, prog2 * i) |
|
894 |
for( j <- 0 to each_simp_timeb.length - 1){
|
|
895 |
if( each_simp_timeb(j)/each_simp_time(j) >= 10.0 ) |
|
896 |
println(j, each_simp_timeb(j), each_simp_time(j)) |
|
897 |
} |
|
898 |
} |
|
899 |
*/ |
|
900 |
||
901 |
||
902 |
//--------------------------------------------------------------------------------------------------------END OF NON-BITCODE PART (TESTING) |
|
903 |
||
904 |
||
905 |
||
906 |
def clear() = {
|
|
907 |
print("")
|
|
908 |
//print("\33[H\33[2J")
|
|
909 |
} |
|
910 |
||
911 |
//testing the two lexings produce the same value |
|
912 |
//enumerates strings of length n over alphabet cs |
|
913 |
def strs(n: Int, cs: String) : Set[String] = {
|
|
914 |
if (n == 0) Set("")
|
|
915 |
else {
|
|
916 |
val ss = strs(n - 1, cs) |
|
917 |
ss ++ |
|
918 |
(for (s <- ss; c <- cs.toList) yield c + s) |
|
919 |
} |
|
920 |
} |
|
921 |
def enum(n: Int, s: String) : Stream[Rexp] = n match {
|
|
922 |
case 0 => ZERO #:: ONE #:: s.toStream.map(CHAR) |
|
923 |
case n => {
|
|
924 |
val rs = enum(n - 1, s) |
|
925 |
rs #::: |
|
926 |
(for (r1 <- rs; r2 <- rs) yield ALT(r1, r2)) #::: |
|
927 |
(for (r1 <- rs; r2 <- rs) yield SEQ(r1, r2)) #::: |
|
928 |
(for (r1 <- rs) yield STAR(r1)) |
|
929 |
} |
|
930 |
} |
|
931 |
||
932 |
//tests blexing and lexing |
|
933 |
def tests_blexer_simp(ss: Set[String])(r: Rexp) = {
|
|
934 |
clear() |
|
935 |
//println(s"Testing ${r}")
|
|
936 |
for (s <- ss.par) yield {
|
|
937 |
val res1 = Try(Some(lexing_simp(r, s))).getOrElse(None) |
|
| 5 | 938 |
val res2 = Try(Some(super_blexing_simp(r, s))).getOrElse(None) |
| 0 | 939 |
if (res1 != res2) println(s"Disagree on ${r} and ${s}")
|
940 |
if (res1 != res2) println(s" ${res1} != ${res2}")
|
|
941 |
if (res1 != res2) Some((r, s)) else None |
|
942 |
} |
|
943 |
} |
|
944 |
||
945 |
||
946 |
||
| 5 | 947 |
|
| 0 | 948 |
/* |
949 |
def single_expression_explorer(ar: ARexp, ss: Set[String]): Unit = {
|
|
950 |
for (s <- ss){
|
|
951 |
||
952 |
val der_res = bder(c, ar) |
|
953 |
val simp_res = bsimp(der_res) |
|
954 |
println(asize(der_res)) |
|
955 |
println(asize(simp_res)) |
|
956 |
single_expression_explorer(simp_res, (sc - c)) |
|
957 |
} |
|
958 |
}*/ |
|
959 |
||
960 |
//single_expression_explorer(internalise(("c"~("a"+"b"))%) , Set('a','b','c'))
|
|
961 |
||
962 |
||
963 |
} |
|
964 |
||
965 |
import Rexp.Bits |
|
966 |
abstract class ARexp |
|
967 |
case object AZERO extends ARexp |
|
968 |
case class AONE(bs: Bits) extends ARexp |
|
969 |
case class ACHAR(bs: Bits, f: Char) extends ARexp |
|
970 |
case class AALTS(bs: Bits, rs: List[ARexp]) extends ARexp |
|
971 |
case class ASEQ(bs: Bits, r1: ARexp, r2: ARexp) extends ARexp |
|
972 |
case class ASTAR(bs: Bits, r: ARexp) extends ARexp |
|
973 |
||
974 |
||
975 |
||
976 |
abstract class Val |
|
977 |
case object Empty extends Val |
|
978 |
case class Chr(c: Char) extends Val |
|
979 |
case class Sequ(v1: Val, v2: Val) extends Val |
|
980 |
case class Left(v: Val) extends Val |
|
981 |
case class Right(v: Val) extends Val |
|
982 |
case class Stars(vs: List[Val]) extends Val |
|
983 |
case class Rec(x: String, v: Val) extends Val |
|
| 17 | 984 |
case object undefined extends Val |
| 0 | 985 |
//case class Pos(i: Int, v: Val) extends Val |
986 |
case object Prd extends Val |