Don't like ads? PRO users don't see any ads ;-)
Public Pastes
Guest

Untitled

By: a guest on May 4th, 2012  |  syntax: None  |  size: 8.13 KB  |  hits: 11  |  expires: Never
download  |  raw  |  embed  |  report abuse  |  print
Text below is selected. Please press Ctrl+C to copy to your clipboard. (⌘+C on Mac)
  1. //import scala.collection.mutable.HashMap
  2. //import scala.collection.mutable.Map
  3. import scala.collection.mutable.Stack
  4. import scala.util.parsing.combinator._
  5. import scala.util.parsing.combinator.syntactical._
  6. import scala.util.parsing.combinator.lexical._
  7.  
  8.  
  9. //-------------------------------------------------------------------
  10.  
  11.  
  12.  
  13. //----------------------------------------------------------------------------------------------
  14. abstract class Instraction
  15. case class POP[A]        extends Instraction
  16. case class PUSH          extends Instraction
  17. case class EXCH          extends Instraction
  18. case class ADD[A <: Int] extends Instraction
  19. case class VAR           extends Instraction
  20.  
  21. abstract class StackVal
  22. case class  StrVal[A <: String](v:A)      extends StackVal
  23. case class  CharVal[A <: Char](v:A)       extends StackVal
  24. case class  IntVal[A <: Int](v:A)         extends StackVal
  25. case class  BoolVal[A <: Boolean](v:A)    extends StackVal
  26. case class  RealVal[A <: Double](v:A)     extends StackVal
  27. case class  Name(v:String)                extends StackVal
  28. case class  Dict(m : Map[Name, StackVal])     extends StackVal
  29. case class  ArrayVal(v:List[StackVal])       extends StackVal
  30. case class  ExecArray[+Instr](v:List[Instr])   extends StackVal
  31. case object Mark                       extends StackVal
  32. case object Null                       extends StackVal
  33.  
  34. /*
  35. type __0[f[_], x] = x
  36. type __1[f[_], x] = f x
  37. type __2[f[_], x] = f f x
  38. */
  39.  
  40. // type DictStack[A,B] =
  41.  
  42. //type Dict  = Map[Name,StackVal]
  43. //type Stack = List[StackVal]
  44. //type Env   = (Stack,Dict)
  45.  
  46. class C {
  47.   val m = new Stack(): Stack[Dict]
  48.   def push(d:Dict) {
  49.     m.push(d)
  50.   }
  51.   val pop = ()=>{ m.pop }
  52. }
  53.  
  54.  
  55. class DictionaryStack {
  56.   val m = new Stack(): Stack[Dict]
  57.   def push(d:Dict) {
  58.     m.push(d)
  59.   }
  60.   val pop = ()=>{ m.pop }
  61.  
  62.   def lookup(n:Name){
  63.     val e = m.find( e => e.m.contains(n) )
  64.     e match {
  65.       case None => None
  66.       case Some(x) => Some(x.m.get(n))
  67.     }
  68.   }
  69. }
  70.  
  71.  
  72. class Enviroment {
  73.   val operand    = new Stack():  Stack[StackVal]
  74.   val execute    = new Stack():  Stack[StackVal]
  75.   val dictionary = new DictionaryStack():  DictionaryStack
  76.   //val curretnDictonary = new Stack() : Stack[Dict]
  77. }
  78. //-----------------------------------------------------------------------------
  79.  
  80. abstract  class Instr
  81. case object Pop                            extends Instr
  82. case class Push(v:StackVal)                extends Instr
  83. case object Exch                           extends Instr
  84. case object Dup                            extends Instr
  85. case class If(c:BoolVal[Boolean], p:ExecArray[Instr])                     extends Instr
  86. case class IfElse(c:BoolVal[Boolean], tp:ExecArray[Instr], fp:ExecArray[Instr])  extends Instr
  87. case class Exec(p:ExecArray[Instr])                                       extends Instr
  88. case class Load(n:Name)                                            extends Instr
  89. case class Stor(n:Name, v:StackVal)                                extends Instr
  90. case object Begin                                                  extends Instr
  91. case object End                                                    extends Instr
  92. case class Loop(p:ExecArray[Instr])                                extends Instr
  93. case object Exit                                                   extends Instr
  94. case class  Cvx(p:ExecArray[Instr])                                extends Instr
  95.  
  96.  
  97. case class Add(v1:IntVal[Int],v2:IntVal[Int])                         extends Instr
  98. case class Sub(v1:IntVal[Int],v2:IntVal[Int])                         extends Instr
  99.  
  100.  
  101.  
  102. //-----------------------------------------------------------------------------------
  103. object StackParser extends StandardTokenParsers  {
  104.   lexical.reserved += ("true","false","if","exit","loop","pop","push","mark" )
  105.   lexical.delimiters +=(" ","/", "{","}","[","]", "<<", ">>" )
  106.  
  107.   lazy val pop    : Parser [Instr]      =  ("pop") ^^^ Pop
  108.   lazy val bool   : Parser [StackVal]   =  ("true"|"false") ^^ { case "true" => BoolVal(true)
  109.                                                                  case "false" => BoolVal(false)
  110.                                                                }
  111.   lazy val int    : Parser[StackVal]    =  numericLit ^^ {case s => IntVal(s.toInt)}
  112.   lazy val value  : Parser[StackVal]    =  (bool |  int | str | mark | name | compval) //  
  113.   lazy val str    : Parser[StackVal]    =  stringLit ^^ {case s => StrVal(s.toString)}
  114.   lazy val push   : Parser[Instr]       =  "push" ~> value ^^ { case v =>  Push(v)}
  115.   lazy val compval : Parser[StackVal]   = (dict | array | execArray )
  116.   lazy val array  : Parser[StackVal]    =  ("[" ~> rep(value) <~ "]") ^^ {case s => ArrayVal(s)}
  117.   lazy val execArray : Parser[ExecArray[Instr]] = "{" ~> terms <~ "}" ^^ {case s => ExecArray (s)}
  118.   lazy val if_       : Parser[Instr]       =  (bool ~ execArray   <~ "if")  ^^ {case BoolVal(b) ~ e =>  If(BoolVal(b),e) }
  119.  
  120.   lazy val loop   : Parser[Instr]       = (execArray <~ "loop") ^^ {case e => Loop(e) }
  121.   lazy val exit   : Parser[Instr]       = ("exit") ^^^ {Exit}
  122.   lazy val mark   : Parser[StackVal]    = ("mark") ^^^ {Mark}
  123.   lazy val name   : Parser[Name]        = ("/" ~> ident) ^^ { case s => Name(s) }
  124.   lazy val pair   : Parser[(Name, StackVal)] = (name ~ value) ^^ {case n ~ v => (n,v) }
  125.   lazy val dict   : Parser[StackVal]    = ("<<" ~> rep1(pair) <~ ">>") ^^ { case (xs) => Dict(xs.toMap) }
  126.  
  127.   lazy val begin : Parser[Instr]  = "begin" ^^^ {Begin}
  128.   lazy val end    : Parser[Instr] = "end" ^^^ {End}
  129.  
  130.   lazy val sym : Parser[StackVal] = ident ^^ { case s => Name(s) }
  131.  
  132.   lazy val term   : Parser[Instr]         =  (exit | begin | end | push  | loop | if_)
  133.   lazy val compterm : Parser[Instr]       = (if_)
  134.   lazy val terms  : Parser[List[Instr]]   = rep1(term)
  135.  
  136.   def parse(text : String) : ParseResult[List[Instr]] = {
  137.      val scanner = new StackParser.lexical.Scanner(text)
  138.      val result  = StackParser.terms(scanner);
  139.    
  140.      result match {
  141.        case Success(result, x) => println("sucess : " ++ result.toString ++ " / "++ x.toString);
  142.        case Failure(msg, _)    => println("failure : " ++ msg)
  143.        case Error(msg, _)      => println("error : " ++ msg)
  144.  
  145.      }
  146.     return result;
  147.   }
  148.  
  149.    def parse2(text : String)(p : List[Instr]=>Unit) = {
  150.        val scanner = new StackParser.lexical.Scanner(text)
  151.        val result  = StackParser.terms(scanner);
  152.    
  153.        result match {
  154.          case Success(result, x) => println("sucess : " ++ result.toString ++ " / "++ x.toString);
  155.                                     p(result)
  156.          case Failure(msg, _)    => println("failure : " ++ msg)
  157.          case Error(msg, _)      => println("error : " ++ msg)
  158.        }
  159.    }
  160. }
  161.  
  162. def parse(str:String)  = {
  163.   StackParser.parse(str);
  164. }
  165.  
  166.  
  167.  
  168. //-------------------------------------------------------------------------
  169. object E {
  170. def eval(i:Instr, e:Enviroment): Enviroment = {
  171.     println(i)
  172.  
  173.     i match {      
  174.         case Pop     => e.operand.pop;      e;
  175.         case Push(v) => ;println("push");e.operand.push(v) ; e;
  176.         case Exch    => val v1 = e.operand.pop; val v2 = e.operand.pop;
  177.                         e.operand.push(v1); e.operand.push(v2); e;
  178.         case Dup                                 => val v1 = e.operand.pop; e.operand.push(v1); e;
  179.        
  180.         case If(BoolVal(c),p)                    => if (c) e.execute.push(p); e;
  181.         case IfElse(BoolVal(c),p1,p2)            => if (c) e.execute.push(p1) else e.execute.push(p2) ; e
  182.  
  183.         // for dictionar stack
  184.         case Begin            =>  e;e.operand.pop match {  
  185.                 case Dict(d)  =>  e.dictionary.push(Dict(d)) ; e;
  186.           }
  187.         case End              =>  e.dictionary.pop ;e;
  188.  
  189.          //  for execute stack
  190.         case Exec(p)    =>        e.execute.push(p); e;
  191.  
  192.         // loop proc
  193.         case Loop(p)    =>        p match { case ExecArray(a) => val e_ = run(a,e) ; e_;}
  194.         case Exit       =>        e.execute.pop;e.execute.pop; e;
  195.  
  196.         //
  197.         //case Add(v1:IntVal[Int], v2:IntVal[Int]) => val v3 = v1 + v2; e.operand(IntVal(v3));e;
  198.         //case Sub(v1:IntVal[Int],v2:IntVal[Int]) => val v3 = v1 - v2; e.operand(IntVal(v3));e;
  199.       }
  200. }
  201. def run(is:List[Instr], e:Enviroment):Enviroment = {
  202.   if (is.isEmpty != true) {
  203.     val i = is.head
  204.     val e_ = eval(i,e);
  205.      run(is.tail,e_);
  206.   }
  207.   else e
  208. }
  209.  
  210.  
  211.  
  212.  
  213. def cvx(ps:List[StackVal]):ExecArray[Instr] = {
  214.   return ExecArray(ps.map((x)=> Push(x)))
  215. }
  216.  
  217. }
  218.  
  219.  
  220. def parse2(str:String)  = {
  221.   val e = new Enviroment
  222.   StackParser.parse2(str)((x:List[Instr]) => {E.run(x,e);});
  223. }
create a new version of this paste RAW Paste Data