Initial check-in!

Author: munificent

.classpath

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<classpath>
+	<classpathentry kind="src" path="src"/>
+	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>
+	<classpathentry kind="output" path="bin"/>
+</classpath>

.gitignore

@@ -0,0 +1,2 @@
+# Ignore output files
+bin/

.project

@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<projectDescription>
+	<name>bantam</name>
+	<comment></comment>
+	<projects>
+	</projects>
+	<buildSpec>
+		<buildCommand>
+			<name>org.eclipse.jdt.core.javabuilder</name>
+			<arguments>
+			</arguments>
+		</buildCommand>
+	</buildSpec>
+	<natures>
+		<nature>org.eclipse.jdt.core.javanature</nature>
+	</natures>
+</projectDescription>

COPYRIGHT

@@ -0,0 +1,30 @@
+Bantam uses the MIT License:
+
+Copyright (c) 2011 Robert Nystrom
+
+Permission is hereby granted, free of charge, to
+any person obtaining a copy of this software and
+associated documentation files (the "Software"),
+to deal in the Software without restriction,
+including without limitation the rights to use,
+copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is
+furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission
+notice shall be included in all copies or
+substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT
+WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO
+THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

README.md

@@ -0,0 +1,3 @@
+This is a tiny little Java app to demonstrate Pratt parsing. I'm still putting
+together a couple of blog posts to explain this, but feel free to poke at the
+code until then.

src/com/stuffwithstuff/bantam/BantamParser.java

@@ -0,0 +1,69 @@
+package com.stuffwithstuff.bantam;
+
+import com.stuffwithstuff.bantam.parselets.*;
+
+/**
+ * Extends the generic Parser class with support for parsing the actual Bantam
+ * grammar.
+ */
+public class BantamParser extends Parser {
+  public BantamParser(Lexer lexer) {
+    super(lexer);
+    
+    // Register all of the parselets for the grammar.
+    
+    // Register the ones that need special parselets.
+    register(TokenType.NAME,       new NameParselet());
+    register(TokenType.ASSIGN,     new AssignParselet());
+    register(TokenType.QUESTION,   new ConditionalParselet());
+    register(TokenType.LEFT_PAREN, new GroupParselet());
+    register(TokenType.LEFT_PAREN, new CallParselet());
+
+    // Register the simple operator parselets.
+    prefix(TokenType.PLUS,      Precedence.PREFIX);
+    prefix(TokenType.MINUS,     Precedence.PREFIX);
+    prefix(TokenType.TILDE,     Precedence.PREFIX);
+    prefix(TokenType.BANG,      Precedence.PREFIX);
+    
+    // For kicks, we'll make "!" both prefix and postfix, kind of like ++.
+    postfix(TokenType.BANG,     Precedence.POSTFIX);
+
+    infixLeft(TokenType.PLUS,     Precedence.SUM);
+    infixLeft(TokenType.MINUS,    Precedence.SUM);
+    infixLeft(TokenType.ASTERISK, Precedence.PRODUCT);
+    infixLeft(TokenType.SLASH,    Precedence.PRODUCT);
+    infixRight(TokenType.CARET,   Precedence.EXPONENT);
+  }
+  
+  /**
+   * Registers a postfix unary operator parselet for the given token and
+   * precedence.
+   */
+  public void postfix(TokenType token, int precedence) {
+    register(token, new PostfixOperatorParselet(token, precedence));
+  }
+  
+  /**
+   * Registers a prefix unary operator parselet for the given token and
+   * precedence.
+   */
+  public void prefix(TokenType token, int precedence) {
+    register(token, new PrefixOperatorParselet(token, precedence));
+  }
+  
+  /**
+   * Registers a left-associative binary operator parselet for the given token
+   * and precedence.
+   */
+  public void infixLeft(TokenType token, int precedence) {
+    register(token, new BinaryOperatorParselet(token, precedence, false));
+  }
+  
+  /**
+   * Registers a right-associative binary operator parselet for the given token
+   * and precedence.
+   */
+  public void infixRight(TokenType token, int precedence) {
+    register(token, new BinaryOperatorParselet(token, precedence, true));
+  }
+}

src/com/stuffwithstuff/bantam/Lexer.java

@@ -0,0 +1,76 @@
+package com.stuffwithstuff.bantam;
+
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.Map;
+
+/**
+ * A very primitive lexer. Takes a string and splits it into a series of
+ * Tokens. Operators and punctuation are mapped to unique keywords. Names,
+ * which can be any series of letters, are turned into NAME tokens. All other
+ * characters are ignored (except to separate names). Numbers and strings are
+ * not supported. This is really just the bare minimum to give the parser
+ * something to work with.
+ */
+public class Lexer implements Iterator<Token> {
+  /**
+   * Creates a new Lexer to tokenize the given string.
+   * @param text String to tokenize.
+   */
+  public Lexer(String text) {
+    mIndex = 0;
+    mText = text;
+    
+    // Register all of the TokenTypes that are explicit punctuators.
+    for (TokenType type : TokenType.values()) {
+      Character punctuator = type.punctuator();
+      if (punctuator != null) {
+        mPunctuators.put(punctuator, type);
+      }
+    }
+  }
+  
+  @Override
+  public boolean hasNext() {
+    return true;
+  }
+
+  @Override
+  public Token next() {
+    while (mIndex < mText.length()) {
+      char c = mText.charAt(mIndex++);
+      
+      if (mPunctuators.containsKey(c)) {
+        // Handle punctuation.
+        return new Token(mPunctuators.get(c), Character.toString(c));
+      } else if (Character.isLetter(c)) {
+        // Handle names.
+        int start = mIndex - 1;
+        while (mIndex < mText.length()) {
+          if (!Character.isLetter(mText.charAt(mIndex))) break;
+          mIndex++;
+        }
+        
+        String name = mText.substring(start, mIndex);
+        return new Token(TokenType.NAME, name);
+      } else {
+        // Ignore all other characters (whitespace, etc.)
+      }
+    }
+    
+    // Once we've reached the end of the string, just return EOF tokens. We'll
+    // just keeping returning them as many times as we're asked so that the
+    // parser's lookahead doesn't have to worry about running out of tokens.
+    return new Token(TokenType.EOF, "");
+  }
+
+  @Override
+  public void remove() {
+    throw new UnsupportedOperationException();
+  }
+  
+  private final Map<Character, TokenType> mPunctuators =
+      new HashMap<Character, TokenType>();
+  private final String mText;
+  private int mIndex = 0;
+}

src/com/stuffwithstuff/bantam/Main.java

@@ -0,0 +1,85 @@
+package com.stuffwithstuff.bantam;
+
+import com.stuffwithstuff.bantam.expressions.Expression;
+
+public class Main {
+  public static void main(String[] args) {
+    // Function call.
+    test("a()", "a()");
+    test("a(b)", "a(b)");
+    test("a(b, c)", "a(b, c)");
+    test("a(b)(c)", "a(b)(c)");
+    test("a(b) + c(d)", "(a(b) + c(d))");
+    test("a(b ? c : d, e + f)", "a((b ? c : d), (e + f))");
+    
+    // Unary precedence.
+    test("~!-+a", "(~(!(-(+a))))");
+    test("a!!!", "(((a!)!)!)");
+    
+    // Unary and binary predecence.
+    test("-a * b", "((-a) * b)");
+    test("!a + b", "((!a) + b)");
+    test("~a ^ b", "((~a) ^ b)");
+    test("-a!",    "(-(a!))");
+    test("!a!",    "(!(a!))");
+    
+    // Binary precedence.
+    test("a = b + c * d ^ e - f / g", "(a = ((b + (c * (d ^ e))) - (f / g)))");
+    
+    // Binary associativity.
+    test("a = b = c", "(a = (b = c))");
+    test("a + b - c", "((a + b) - c)");
+    test("a * b / c", "((a * b) / c)");
+    test("a ^ b ^ c", "(a ^ (b ^ c))");
+    
+    // Conditional operator.
+    test("a ? b : c ? d : e", "(a ? b : (c ? d : e))");
+    test("a ? b ? c : d : e", "(a ? (b ? c : d) : e)");
+    test("a + b ? c * d : e / f", "((a + b) ? (c * d) : (e / f))");
+    
+    // Grouping.
+    test("a + (b + c) + d", "((a + (b + c)) + d)");
+    test("a ^ (b + c)", "(a ^ (b + c))");
+    test("(!a)!",    "((!a)!)");
+    
+    // Show the results.
+    if (sFailed == 0) {
+      System.out.println("Passed all " + sPassed + " tests.");
+    } else {
+      System.out.println("----");
+      System.out.println("Failed " + sFailed + " out of " +
+          (sFailed + sPassed) + " tests.");
+    }
+  }
+  
+  /**
+   * Parses the given chunk of code and verifies that it matches the expected
+   * pretty-printed result.
+   */
+  public static void test(String source, String expected) {
+    Lexer lexer = new Lexer(source);
+    Parser parser = new BantamParser(lexer);
+    
+    try {
+      Expression result = parser.parseExpression();
+      StringBuilder builder = new StringBuilder();
+      result.print(builder);
+      String actual = builder.toString();
+      
+      if (expected.equals(actual)) {
+        sPassed++;
+      } else {
+        sFailed++;
+        System.out.println("[FAIL] Expected: " + expected);
+        System.out.println("         Actual: " + actual);
+      }
+    } catch(ParseException ex) {
+      sFailed++;
+      System.out.println("[FAIL] Expected: " + expected);
+      System.out.println("          Error: " + ex.getMessage());
+    }
+  }
+  
+  private static int sPassed = 0;
+  private static int sFailed = 0;
+}

src/com/stuffwithstuff/bantam/ParseException.java

@@ -0,0 +1,8 @@
+package com.stuffwithstuff.bantam;
+
+@SuppressWarnings("serial")
+public class ParseException extends RuntimeException {
+  public ParseException(String message) {
+    super(message);
+  }
+}