Add syntax highlighting to README

Author: romac

README.md

@@ -50,48 +50,58 @@ Setup
 The latest stable release for Scala 2.11 is available on Sonatype, simply add
 the following to your `build.sbt`:
 
-    libraryDependencies += "com.regblanc" %% "scala-smtlib" % "0.2.2"
+```scala
+libraryDependencies += "com.regblanc" %% "scala-smtlib" % "0.2.2"
+```
 
 Getting Started with Examples
 -----------------------------
 
 To construct a parser, you will need a java.io.Reader and a lexer:
 
-    val is = new java.io.FileReader("INPUT")
-    val lexer = new smtlib.lexer.Lexer(is)
-    val parser = new smtlib.parser.Parser(lexer)
+```scala
+val is = new java.io.FileReader("INPUT")
+val lexer = new smtlib.lexer.Lexer(is)
+val parser = new smtlib.parser.Parser(lexer)
+```
 
 The parser then provides a `parseCommand` functions that will consume the input
 until the end of command:
 
-    val script: List[Command] = {
-      var cmds = new ListBuffer[Command]
-      var cmd = parser.parseCommand
-      while(cmd != null)
-        cmds.append(cmd)
-      cmds.toList
-    }
+```scala
+val script: List[Command] = {
+  var cmds = new ListBuffer[Command]
+  var cmd = parser.parseCommand
+  while(cmd != null)
+    cmds.append(cmd)
+  cmds.toList
+}
+```
 
 `parseCommand` returns `null` when the end of file is reached.
 
 You can decompose a command using pattern matching:
 
-    import smtlib.parser.Commands._
-    cmd match {
-      case Assert(term) => ???
-      case CheckSat() => ???
-      case Pop(1) => ???
-    }
+```scala
+import smtlib.parser.Commands._
+cmd match {
+  case Assert(term) => ???
+  case CheckSat() => ???
+  case Pop(1) => ???
+}
+```
 
 If you want to generate a script to feed to a solver, you can build the AST
 explicitly, and use the pretty printers:
 
-    import smtlib.parser.Commands._
-    import smtlib.parser.theories.Ints._
-    val x = QualifiedIdentifier(SimpleIdentifier(SSymbol("x")))
-    val y = QualifiedIdentifier(SimpleIdentifier(SSymbol("y")))
-    val formula = Assert(LessThan(NumeralLit(0), Plus(x, y)))
-    smtlib.printer.RecursivePrinter.toString(formula) //(assert (< 0 (+ x y)))
+```scala
+import smtlib.parser.Commands._
+import smtlib.parser.theories.Ints._
+val x = QualifiedIdentifier(SimpleIdentifier(SSymbol("x")))
+val y = QualifiedIdentifier(SimpleIdentifier(SSymbol("y")))
+val formula = Assert(LessThan(NumeralLit(0), Plus(x, y)))
+smtlib.printer.RecursivePrinter.toString(formula) //(assert (< 0 (+ x y)))
+```
 
 The above is a little bit verbose due to the objective of supporting all of
 SMT-LIB. We are hoping to provide a nicer API in the future to build SMT-LIB
@@ -116,9 +126,11 @@ parsing of [`Tokens`](/src/main/scala/smtlib/lexer/Tokens.scala), The
 tokens. It reads lazily from a `java.io.Reader`, on invocation of the `nextToken`
 method:
 
-    class Lexer(reader: java.io.Reader) { 
-      def nextToken: Token = { ... }
-    }
+```scala
+class Lexer(reader: java.io.Reader) {
+  def nextToken: Token = { ... }
+}
+```
 
 One call to `nextToken` will only consume the input until the end of the
 current token. It will read one character at a time from the input `Reader`
@@ -147,10 +159,12 @@ interested in fully formated SMT-LIB expressions. The
 expressions. The [`Parser`](/src/main/scala/smtlib/parser/Parser.scala) consumes
 tokens generated by the above lexer:
 
-    class Parser(lexer: smtlib.lexer.Lexer) { 
-      def nextCommand: Command = { ... }
-      def nextTerm: Term = { ... }
-    }
+```scala
+class Parser(lexer: smtlib.lexer.Lexer) {
+  def nextCommand: Command = { ... }
+  def nextTerm: Term = { ... }
+}
+```
 
 It provides many `nextX` methods (more than shown above) to parse any expressions
 defined by the SMT-LIB standard grammar. The more common are the `nextCommand`