feat: initial parser implementation

src/main/wacc/Main.scala

@@ -1,5 +1,6 @@
 package wacc
 
+import parsley.{Failure, Success}
 import scopt.OParser
 import java.io.File
 
@@ -28,6 +29,13 @@ val cliParser = {
   )
 }
 
+def compile(contents: String): Int = {
+  parser.parse(contents) match {
+    case Success(x)   => 0
+    case Failure(msg) => 100
+  }
+}
+
 def main(args: Array[String]): Unit =
   OParser.parse(cliParser, args, CliConfig()) match {
     case Some(config) =>

src/main/wacc/parser.scala

@@ -1,8 +1,123 @@
 package wacc
 
 import parsley.Result
+import parsley.Parsley
+import parsley.Parsley.{atomic, many, pure}
+import parsley.combinator.{countSome, sepBy, sepBy1}
+import parsley.expr.{precedence, SOps, InfixL, InfixN, InfixR, Prefix, Atoms}
 
 object parser {
-  def parse(input: String): Result[String, BigInt] = parser.parse(input)
-  private val parser = lexer.fully(???)
+  import lexer.implicits.implicitSymbol
+  import lexer.{ident, integer, charLit, stringLit}
+  import ast._
+
+  def parse(input: String): Result[String, Program] = parser.parse(input)
+  private val parser = lexer.fully(`<program>`)
+
+  // Expressions
+  private lazy val `<expr>`: Parsley[Expr] = precedence {
+    SOps(InfixR)(Or from "||") +:
+      SOps(InfixR)(And from "&&") +:
+      SOps(InfixN)(Eq from "==", Neq from "!=") +:
+      SOps(InfixN)(
+        Less from "<",
+        LessEq from "<=",
+        Greater from ">",
+        GreaterEq from ">="
+      ) +:
+      SOps(InfixL)(Add from "+", Sub from "-") +:
+      SOps(InfixL)(Mul from "*", Div from "/", Mod from "%") +:
+      SOps(Prefix)(
+        Not from "!",
+        Negate from "-",
+        Len from "len",
+        Ord from "ord",
+        Chr from "chr"
+      ) +:
+      `<atom>`
+  }
+
+  // Atoms
+  private lazy val `<atom>`: Atoms[Expr6] = Atoms(
+    IntLiter(integer),
+    BoolLiter(("true" as true) | ("false" as false)),
+    CharLiter(charLit),
+    StrLiter(stringLit),
+    PairLiter from "null",
+    `<ident>`,
+    `<array-elem>`,
+    Parens("(" ~> `<expr>` <~ ")")
+  )
+  private val `<ident>` = Ident(ident)
+  private lazy val `<array-elem>` =
+    ArrayElem(`<ident>` <~ "[", sepBy1(`<expr>`, "]" ~> "[") <~ "]")
+
+  // Types
+  private lazy val `<type>`: Parsley[Type] =
+    (`<base-type>` | (`<pair-type>` ~> `<pair-elems-type>`)) <**> (`<array-type>` </> identity)
+  private val `<base-type>` =
+    (IntType from "int") | (BoolType from "bool") | (CharType from "char") | (StringType from "string")
+  private lazy val `<array-type>` =
+    countSome("[" ~> "]") map { cnt => ArrayType((_: Type), cnt) }
+  private val `<pair-type>` = "pair"
+  private val `<pair-elems-type>`: Parsley[PairType] = PairType(
+    "(" ~> `<pair-elem-type>` <~ ",",
+    `<pair-elem-type>` <~ ")"
+  )
+  private lazy val `<pair-elem-type>` =
+    (`<base-type>` <**> (`<array-type>` </> identity)) |
+      `<pair-type>` ~> ((`<pair-elems-type>` <**> `<array-type>`) </> UntypedPairType)
+
+  // Statements
+  private lazy val `<program>` = Program(
+    "begin" ~> many(atomic(`<func>`)),
+    `<stmt>` <~ "end"
+  )
+  private lazy val `<func>` = FuncDecl(
+    `<type>`,
+    `<ident>` <~ "(",
+    sepBy(`<param>`, ",") <~ ")" <~ "is",
+    `<stmt>` <~ "end"
+  )
+  private lazy val `<param>` = Param(`<type>`, `<ident>`)
+  private lazy val `<stmt>`: Parsley[List[Stmt]] = sepBy1(`<basic-stmt>`, ";")
+  private lazy val `<basic-stmt>` =
+    (Skip from atomic("skip"))
+      | Read(atomic("read") ~> `<lvalue>`)
+      | Free(atomic("free") ~> `<expr>`)
+      | Return(atomic("return") ~> `<expr>`)
+      | Exit(atomic("exit") ~> `<expr>`)
+      | Print(atomic("print") ~> `<expr>`, pure(false))
+      | Print(atomic("println") ~> `<expr>`, pure(true))
+      | If(
+        atomic("if") ~> `<expr>` <~ "then",
+        `<stmt>` <~ "else",
+        `<stmt>` <~ "fi"
+      )
+      | While(atomic("while") ~> `<expr>` <~ "do", `<stmt>` <~ "done")
+      | Block(atomic("begin") ~> `<stmt>` <~ "end")
+      | VarDecl(atomic(`<type>`), `<ident>` <~ "=", `<rvalue>`)
+      | Assign(`<ident>` <~ "=", `<rvalue>`)
+  private lazy val `<lvalue>`: Parsley[LValue] =
+    atomic(`<pair-elem>`) | atomic(`<array-elem>`) | `<ident>`
+  private lazy val `<rvalue>`: Parsley[RValue] =
+    atomic(`<array-liter>`) |
+      atomic(
+        NewPair(
+          "newpair" ~> "(" ~> `<expr>` <~ ",",
+          `<expr>` <~ ")"
+        )
+      ) |
+      atomic(`<pair-elem>`) |
+      atomic(
+        Call(
+          "call" ~> `<ident>` <~ "(",
+          sepBy(`<expr>`, ",") <~ ")"
+        )
+      ) | `<expr>`
+  private lazy val `<pair-elem>` =
+    Fst("fst" ~> `<lvalue>`) | Snd("snd" ~> `<lvalue>`)
+  private lazy val `<array-liter>` = ArrayLiter(
+    "[" ~> sepBy(`<expr>`, ",") <~ "]"
+  )
 }