I wrote the following parser in Scala using the parser combinators:
import scala.util.parsing.combinator._
import scala.collection.Map
import scala.io.StdIn
object Keywords {
val Define = "define"
val True = "true"
val False = "false"
val If = "if"
val Then = "then"
val Else = "else"
val Return = "return"
val Pass = "pass"
val Conj = ";"
val OpenParen = "("
val CloseParen = ")"
val OpenBrack = "{"
val CloseBrack = "}"
val Comma = ","
val Plus = "+"
val Minus = "-"
val Times = "*"
val Divide = "/"
val Pow = "**"
val And = "&&"
val Or = "||"
val Xor = "^^"
val Not = "!"
val Equals = "=="
val NotEquals = "!="
val Assignment = "="
}
//---------------------------------------------------------------------------------
sealed abstract class Op
case object Plus extends Op
case object Minus extends Op
case object Times extends Op
case object Divide extends Op
case object Pow extends Op
case object And extends Op
case object Or extends Op
case object Xor extends Op
case object Not extends Op
case object Equals extends Op
case object NotEquals extends Op
case object Assignment extends Op
//---------------------------------------------------------------------------------
sealed abstract class Term
case object TrueTerm extends Term
case object FalseTerm extends Term
case class FloatTerm(value : Float) extends Term
case class StringTerm(value : String) extends Term
case class Identifier(name : String) extends Term
//---------------------------------------------------------------------------------
sealed abstract class Expression
case class TermExp(term : Term) extends Expression
case class UnaryOp(op : Op, exp : Expression) extends Expression
case class BinaryOp(op : Op, left : Expression, right : Expression) extends Expression
case class FuncApp(funcName : Term, args : List[Expression]) extends Expression
//---------------------------------------------------------------------------------
sealed abstract class Statement
case class ExpressionStatement(exp : Expression) extends Statement
case class Pass() extends Statement
case class Return(value : Expression) extends Statement
case class AssignmentVar(variable : Term, exp : Expression) extends Statement
case class IfThenElse(testBody : Expression, thenBody : Statement, elseBody : Statement) extends Statement
case class Conjunction(left : Statement, right : Statement) extends Statement
case class AssignmentFunc(functionName : Term, args : List[Term], body : Statement) extends Statement
//---------------------------------------------------------------------------------
class myParser extends JavaTokenParsers {
val keywordMap : Map[String, Op] = Map(
Keywords.Plus -> Plus,
Keywords.Minus -> Minus,
Keywords.Times -> Times,
Keywords.Divide -> Divide,
Keywords.Pow -> Pow,
Keywords.And -> And,
Keywords.Or -> Or,
Keywords.Xor -> Xor,
Keywords.Not -> Not,
Keywords.Equals -> Equals,
Keywords.NotEquals -> NotEquals,
Keywords.Assignment -> Assignment
)
def floatTerm : Parser[Term] = decimalNumber ^^ {
case x => FloatTerm( x.toFloat )
}
def stringTerm : Parser[Term] = stringLiteral ^^ {
case str => StringTerm(str)
}
def identifier : Parser[Term] = ident ^^ {
case value => Identifier(value)
}
def boolTerm : Parser[Term] = (Keywords.True | Keywords.False) ^^ {
case Keywords.True => TrueTerm
case Keywords.False => FalseTerm
}
def simpleTerm : Parser[Expression] = (boolTerm | floatTerm | stringTerm) ^^ {
case term => TermExp(term)
}
def argument = expression
def arguments_aux : Parser[List[Expression]] = (argument <~ Keywords.Comma) ~ arguments ^^ {
case arg ~ argList => arg :: argList
}
def arguments = arguments_aux | { argument ^^ { case arg => List(arg) } }
def funcAppArgs : Parser[List[Expression]] = funcEmptyArgs | ( Keywords.OpenParen ~> arguments <~ Keywords.CloseParen ^^ {
case args => args.foldRight(List[Expression]()) ( (a,b) => a :: b )
} )
def funcApp = identifier ~ funcAppArgs ^^ {
case funcName ~ argList => FuncApp(funcName, argList)
}
def variableTerm : Parser[Expression] = identifier ^^ {
case name => TermExp(name)
}
def atomic_expression = simpleTerm | funcApp | variableTerm
def paren_expression : Parser[Expression] = Keywords.OpenParen ~> expression <~ Keywords.CloseParen
def unary_operation : Parser[String] = Keywords.Not
def unary_expression : Parser[Expression] = operation(0) ~ expression(0) ^^ {
case op ~ exp => UnaryOp(keywordMap(op), exp)
}
def operation(precedence : Int) : Parser[String] = precedence match {
case 0 => Keywords.Not
case 1 => Keywords.Pow
case 2 => Keywords.Times | Keywords.Divide | Keywords.And
case 3 => Keywords.Plus | Keywords.Minus | Keywords.Or | Keywords.Xor
case 4 => Keywords.Equals | Keywords.NotEquals
case _ => throw new Exception("No operations with this precedence.")
}
def binary_expression(precedence : Int) : Parser[Expression] = precedence match {
case 0 => throw new Exception("No operation with zero precedence.")
case n => (expression (n-1)) ~ operation(n) ~ (expression (n)) ^^ {
case left ~ op ~ right => BinaryOp(keywordMap(op), left, right)
}
}
def expression(precedence : Int) : Parser[Expression] = precedence match {
case 0 => unary_expression | paren_expression | atomic_expression
case n => binary_expression(n) | expression(n-1)
}
def expression : Parser[Expression] = expression(4)
def expressionStmt : Parser[Statement] = expression ^^ { case exp => ExpressionStatement(exp) }
def assignment : Parser[Statement] = (identifier <~ Keywords.Assignment) ~ expression ^^ {
case varName ~ exp => AssignmentVar(varName, exp)
}
def ifthen : Parser[Statement] = ((Keywords.If ~ Keywords.OpenParen) ~> expression <~ Keywords.CloseParen) ~
((Keywords.Then ~ Keywords.OpenBrack) ~> statements <~ Keywords.CloseBrack) ^^ {
case ifBody ~ thenBody => IfThenElse(ifBody, thenBody, Pass())
}
def ifthenelse : Parser[Statement] = ((Keywords.If ~ Keywords.OpenParen) ~> expression <~ Keywords.CloseParen) ~
((Keywords.Then ~ Keywords.OpenBrack) ~> statements <~ Keywords.CloseBrack) ~
((Keywords.Else ~ Keywords.OpenBrack) ~> statements <~ Keywords.CloseBrack) ^^ {
case ifBody ~ thenBody ~ elseBody => IfThenElse(ifBody, thenBody, elseBody)
}
def pass : Parser[Statement] = Keywords.Pass ^^^ { Pass() }
def returnStmt : Parser[Statement] = Keywords.Return ~> expression ^^ {
case exp => Return(exp)
}
def statement : Parser[Statement] = ((pass | returnStmt | assignment | expressionStmt) <~ Keywords.Conj) | ifthenelse | ifthen
def statements_aux : Parser[Statement] = statement ~ statements ^^ { case st ~ sts => Conjunction(st, sts) }
def statements : Parser[Statement] = statements_aux | statement
def funcDefBody : Parser[Statement] = Keywords.OpenBrack ~> statements <~ Keywords.CloseBrack
def funcEmptyArgs = Keywords.OpenParen ~ Keywords.CloseParen ^^^ { List() }
def funcDefArgs : Parser[List[Term]] = funcEmptyArgs | Keywords.OpenParen ~> repsep(identifier, Keywords.Comma) <~ Keywords.CloseParen ^^ {
case args => args.foldRight(List[Term]()) ( (a,b) => a :: b )
}
def funcDef : Parser[Statement] = (Keywords.Define ~> identifier) ~ funcDefArgs ~ funcDefBody ^^ {
case funcName ~ funcArgs ~ body => AssignmentFunc(funcName, funcArgs, body)
}
def funcDefAndStatement : Parser[Statement] = funcDef | statement
def funcDefAndStatements_aux : Parser[Statement] = funcDefAndStatement ~ funcDefAndStatements ^^ {
case stmt ~ stmts => Conjunction(stmt, stmts)
}
def funcDefAndStatements : Parser[Statement] = funcDefAndStatements_aux | funcDefAndStatement
def parseProgram : Parser[Statement] = funcDefAndStatements
def eval(input : String) = {
parseAll(parseProgram, input) match {
case Success(result, _) => result
case Failure(m, _) => println(m)
case _ => println("")
}
}
}
object Parser {
def main(args : Array[String]) {
val x : myParser = new myParser()
println(args(0))
val lines = scala.io.Source.fromFile(args(0)).mkString
println(x.eval(lines))
}
}
The problem is, when I run the parser on the following example it works fine:
define foo(a) {
if (!h(IM) && a) then {
return 0;
}
if (a() && !h()) then {
return 0;
}
}
But when I add threes characters in the first if statement, it runs out of memory. This is absolutely blowing my mind. Can anyone help? (I suspect it has to do with repsep, but I am not sure.)
define foo(a) {
if (!h(IM) && a(1)) then {
return 0;
}
if (a() && !h()) then {
return 0;
}
}
EDIT: Any constructive comments about my Scala style is also appreciated.
