diff -r e722f4ba54de -r 24bbe4e4b37b progs/compile_arr.scala
--- 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")