--- a/progs/compile_arr.scala Thu Nov 29 02:38:24 2018 +0000
+++ b/progs/compile_arr.scala Tue Dec 04 00:33:26 2018 +0000
@@ -45,7 +45,8 @@
.limit stack 2
getstatic java/lang/System/out Ljava/io/PrintStream;
iload 0
- invokevirtual java/io/PrintStream/println(I)V
+ i2c
+ invokevirtual java/io/PrintStream/print(C)V
return
.end method
@@ -88,6 +89,8 @@
compile_aexp(a1, env) ++ compile_aexp(a2, env) ++ List("isub\n")
case Aop("*", a1, a2) =>
compile_aexp(a1, env) ++ compile_aexp(a2, env) ++ List("imul\n")
+ case Ref(s, a1) =>
+ List("aload " + env(s) + "\n") ++ compile_aexp(a1, env) ++ List("iaload \n")
}
// boolean expression compilation
@@ -149,13 +152,10 @@
case AssignA(s, a1, a2) => {
val index = if (env.isDefinedAt(s)) env(s) else
throw new Exception("Array not yet defined")
- (List("aload " + index) ++
+ (List("aload " + index + "\n") ++
compile_aexp(a1, env) ++
compile_aexp(a2, env) ++
- List("iastore"), env)
-
- compile_aexp(a, env) ++
- List("istore " + index + "\n"), env + (x -> index))
+ List("iastore \n"), env)
}
}
@@ -238,22 +238,236 @@
compile_run(fib_test, "fib")
-val arr_test =
- List(Assign("x", Num(0)),
- Array("a", 10))
-
-compile_block(arr_test, Map())._1.mkString
-compile_run(arr_test, "arr")
-
val arr_test =
- List(Array("a", 10),
- Array("b", 2),
- AssignA("a", Num(0), Num(10)),
- Assign("x", Ref("a", Num(0))),
- Write("x"),
- AssignA("b", Num(1), Num(5)),
- Assign("x", Ref("b", Num(1))),
- Write("x"))
+ List(Array("a", 10), // a[10]
+ Array("b", 2), // b[2]
+ AssignA("a", Num(0), Num(10)), // a[0] := 10
+ Assign("x", Ref("a", Num(0))), // x := a[0]
+ Write("x"), // write x
+ AssignA("b", Num(1), Num(5)), // b[1] := 5
+ Assign("x", Ref("b", Num(1))), // x := b[1]
+ Write("x")) // write x
+
+compile_run(arr_test, "a")
+
+
+//====================
+// Parser Combinators
+//====================
+
+import scala.language.implicitConversions
+import scala.language.reflectiveCalls
+
+
+abstract class Parser[I <% Seq[_], T] {
+ def parse(ts: I): Set[(T, I)]
+
+ def parse_all(ts: I) : Set[T] =
+ for ((head, tail) <- parse(ts); if (tail.isEmpty)) yield head
+}
+
+class SeqParser[I <% Seq[_], T, S](p: => Parser[I, T], q: => Parser[I, S]) extends Parser[I, (T, S)] {
+ def parse(sb: I) =
+ for ((head1, tail1) <- p.parse(sb);
+ (head2, tail2) <- q.parse(tail1)) yield ((head1, head2), tail2)
+}
+
+class AltParser[I <% Seq[_], T](p: => Parser[I, T], q: => Parser[I, T]) extends Parser[I, T] {
+ def parse(sb: I) = p.parse(sb) ++ q.parse(sb)
+}
+
+class FunParser[I <% Seq[_], T, S](p: => Parser[I, T], f: T => S) extends Parser[I, S] {
+ def parse(sb: I) =
+ for ((head, tail) <- p.parse(sb)) yield (f(head), tail)
+}
+
+
+import scala.util.matching.Regex
+case class RegexParser(reg: Regex) extends Parser[String, String] {
+ def parse(sb: String) = reg.findPrefixMatchOf(sb) match {
+ case None => Set()
+ case Some(m) => Set((m.matched, m.after.toString))
+ }
+}
+
+def StringParser(s: String) = RegexParser(Regex.quote(s).r)
+
+
+implicit def string2parser(s : String) = StringParser(s)
+
+implicit def ParserOps[I<% Seq[_], T](p: Parser[I, T]) = new {
+ def | (q : => Parser[I, T]) = new AltParser[I, T](p, q)
+ def ==>[S] (f: => T => S) = new FunParser[I, T, S](p, f)
+ def ~[S] (q : => Parser[I, S]) = new SeqParser[I, T, S](p, q)
+}
+
+implicit def StringOps(s: String) = new {
+ def | (q : => Parser[String, String]) = new AltParser[String, String](s, q)
+ def | (r: String) = new AltParser[String, String](s, r)
+ def ==>[S] (f: => String => S) = new FunParser[String, String, S](s, f)
+ def ~[S](q : => Parser[String, S]) =
+ new SeqParser[String, String, S](s, q)
+ def ~ (r: String) =
+ new SeqParser[String, String, String](s, r)
+}
+
+
+val NumParser = RegexParser("[0-9]+".r) ==> (s => s.toInt : Int)
+val IdParser = RegexParser("[a-z][a-z,0-9]*".r)
+
+
+
+// Grammar Rules
+
+lazy val AExp: Parser[String, AExp] =
+ (Te ~ "+" ~ AExp) ==> { case ((x, _), z) => Aop("+", x, z):AExp } |
+ (Te ~ "-" ~ AExp) ==> { case ((x, _), z) => Aop("-", x, z):AExp } | Te
+lazy val Te: Parser[String, AExp] =
+ (Fa ~ "*" ~ Te) ==> { case ((x, _), z) => Aop("*", x, z):AExp } | Fa
+lazy val Fa: Parser[String, AExp] =
+ ("(" ~ AExp ~ ")") ==> { case ((_, y), _) => y } |
+ (IdParser ~ "[" ~ AExp ~ "]") ==> { case (((x, _), y), _) => Ref(x, y) } |
+ IdParser ==> Var |
+ NumParser ==> Num
+
+// boolean expressions
+lazy val BExp: Parser[String, BExp] =
+ (AExp ~ "=" ~ AExp) ==> { case ((x, y), z) => Bop("=", x, z):BExp } |
+ (AExp ~ "!=" ~ AExp) ==> { case ((x, y), z) => Bop("!=", x, z):BExp } |
+ (AExp ~ "<" ~ AExp) ==> { case ((x, y), z) => Bop("<", x, z):BExp } |
+ (AExp ~ ">" ~ AExp) ==> { case ((x, y), z) => Bop("<", z, x):BExp } |
+ ("true" ==> ((_) => True:BExp )) |
+ ("false" ==> ((_) => False:BExp )) |
+ ("(" ~ BExp ~ ")") ==> { case ((x, y), z) => y}
+
+lazy val Stmt: Parser[String, Stmt] =
+ ("skip" ==> (_ => Skip: Stmt)) |
+ (IdParser ~ ":=" ~ AExp) ==> { case ((x, y), z) => Assign(x, z): Stmt } |
+ (IdParser ~ "[" ~ AExp ~ "]" ~ ":=" ~ AExp) ==> {
+ case (((((x, y), z), v), w), u) => AssignA(x, z, u): Stmt } |
+ ("if" ~ BExp ~ "then" ~ Block ~ "else" ~ Block) ==>
+ { case (((((x,y),z),u),v),w) => If(y, u, w): Stmt } |
+ ("while" ~ BExp ~ "do" ~ Block) ==> { case (((x, y), z), w) => While(y, w) } |
+ ("new" ~ IdParser ~ "[" ~ NumParser ~ "]") ==> { case ((((x, y), z), u), v) => Array(y, u) } |
+ ("write" ~ IdParser) ==> { case (_, y) => Write(y) }
+
+lazy val Stmts: Parser[String, Block] =
+ (Stmt ~ ";" ~ Stmts) ==> { case ((x, y), z) => x :: z : Block } |
+ (Stmt ==> ((s) => List(s) : Block))
-//compile_run(arr_test, "a")
\ No newline at end of file
+
+lazy val Block: Parser[String, Block] =
+ ("{" ~ Stmts ~ "}") ==> { case ((x, y), z) => y} |
+ (Stmt ==> (s => List(s)))
+
+Stmts.parse_all("x2:=5+a")
+Stmts.parse_all("x2:=5+a[3+a]")
+Stmts.parse_all("a[x2+3]:=5+a[3+a]")
+Block.parse_all("{x:=5;y:=8}")
+Block.parse_all("if(false)then{x:=5}else{x:=10}")
+
+
+
+val fib = """
+ n := 10;
+ minus1 := 0;
+ minus2 := 1;
+ temp:=0;
+ while (n > 0) do {
+ temp := minus2;
+ minus2 := minus1 + minus2;
+ minus1 := temp;
+ n := n - 1};
+ result := minus2;
+ write result
+ """.replaceAll("\\s+", "")
+
+val fib_prog = Stmts.parse_all(fib).toList
+//compile_run(fib_prog.head, "fib")
+
+
+// BF
+
+// simple instructions
+def instr(c: Char) : String = c match {
+ case '>' => "ptr := ptr + 1;"
+ case '<' => "ptr := ptr - 1;"
+ case '+' => "field[ptr] := field[ptr] + 1;"
+ case '-' => "field[ptr] := field[ptr] - 1;"
+ case '.' => "x := field[ptr]; write x;"
+ //case ',' => "XXX" // "ptr = getchar();\n"
+ case '[' => "while (field[ptr] != 0) do {"
+ case ']' => "skip};"
+ case _ => ""
+}
+
+def instrs(prog: String) : String =
+ prog.toList.map(instr).mkString
+
+
+def splice(cs: List[Char], acc: List[(Char, Int)]) : List[(Char, Int)] = (cs, acc) match {
+ case (Nil, acc) => acc
+ case (c :: cs, Nil) => splice(cs, List((c, 1)))
+ case (c :: cs, (d, n) :: acc) =>
+ if (c == d) splice(cs, (c, n + 1) :: acc)
+ else splice(cs, (c, 1) :: (d, n) :: acc)
+}
+
+def spl(s: String) = splice(s.toList, Nil).reverse
+
+def instr2(c: Char, n: Int) : String = c match {
+ case '>' => "ptr := ptr + " + n.toString + ";"
+ case '<' => "ptr := ptr - " + n.toString + ";"
+ case '+' => "field[ptr] := field[ptr] + " + n.toString + ";"
+ case '-' => "field[ptr] := field[ptr] - " + n.toString + ";"
+ case '.' => "x := field[ptr]; write x;" //* n
+ //case ',' => "*ptr = getchar();\n" * n
+ case '[' => "while (field[ptr] != 0) do {" * n
+ case ']' => "skip};" * n
+ case _ => ""
+}
+
+def instrs2(prog: String) : String =
+ spl(prog).map{ case (c, n) => instr2(c, n) }.mkString
+
+
+def bf_str(prog: String) : String = {
+ "\n" ++
+ //"new field[30000];\n" ++
+ "ptr := 15000;" ++
+ instrs2(prog) ++
+ "skip"
+}
+
+def bf_run(prog: String, name: String) = {
+ println("BF processing start")
+ val bf_string = bf_str(prog).replaceAll("\\s", "")
+ println(s"BF parsing start (string length ${bf_string.length})")
+ val bf_prog = Stmts.parse_all(bf_string).toList.head
+ println("BF Compile start")
+ compile_run(Array("field", 30000) :: bf_prog, name)
+}
+
+
+
+val bf1 = """++++++++[>+>++++<<-]>++>>+<[-[>>+<<-]+>>]>+[-<<<[
+ ->[+[-]+>++>>>-<<]<[<]>>++++++[<<+++++>>-]+<<++.[-]<<
+ ]>.>+[>>]>+]"""
+
+bf_run(bf1, "sier")
+
+bf_run("""++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++
+ ..+++.>>.<-.<.+++.------.--------.>>+.>++.""", "hello")
+
+bf_run("""+++++++++++
+ >+>>>>++++++++++++++++++++++++++++++++++++++++++++
+ >++++++++++++++++++++++++++++++++<<<<<<[>[>>>>>>+>
+ +<<<<<<<-]>>>>>>>[<<<<<<<+>>>>>>>-]<[>++++++++++[-
+ <-[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]>[<<[>>>+<<<
+ -]>>[-]]<<]>>>[>>+>+<<<-]>>>[<<<+>>>-]+<[>[-]<[-]]
+ >[<<+>>[-]]<<<<<<<]>>>>>[+++++++++++++++++++++++++
+ +++++++++++++++++++++++.[-]]++++++++++<[->-<]>++++
+ ++++++++++++++++++++++++++++++++++++++++++++.[-]<<
+ <<<<<<<<<<[>>>+>+<<<<-]>>>>[<<<<+>>>>-]<-[>>.>.<<<
+ [-]]<<[>>+>+<<<-]>>>[<<<+>>>-]<<[<+>-]>[<+>-]<<<-]""", "fibs")