diff --git a/app/PdeCompilerJavac.java b/app/PdeCompilerJavac.java
deleted file mode 100755
index c5f9c4edd..000000000
--- a/app/PdeCompilerJavac.java
+++ /dev/null
@@ -1,123 +0,0 @@
-/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
-
-/*
-  PdeCompilerJavac - compiler interface to kjc.. someday this will go away
-  Part of the Processing project - http://processing.org
-
-  Except where noted, code is written by Ben Fry and
-  Copyright (c) 2001-03 Massachusetts Institute of Technology
-
-  This program is free software; you can redistribute it and/or modify
-  it under the terms of the GNU General Public License as published by
-  the Free Software Foundation; either version 2 of the License, or
-  (at your option) any later version.
-
-  This program is distributed in the hope that it will be useful,
-  but WITHOUT ANY WARRANTY; without even the implied warranty of
-  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-  GNU General Public License for more details.
-
-  You should have received a copy of the GNU General Public License 
-  along with this program; if not, write to the Free Software Foundation, 
-  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
-*/
-
-
-/*
-
-
-import java.io.*;
-
-
-// this class is incomplete. it was added in an attempt to support
-// mac os 9, but the javac for jdk 1.1 doesn't seem to like the 
-// file format of the classes produced by jikes, which is revision
-// 57 code instead of rev 55. 
-
-// using jikes -target 1.1 doesn't seem to help. the next attempt 
-// was to use javac from the 1.1 jdk, which i attempted to hack
-// into the bagel build scripts, but javac actually crashed (not
-// just and exception, but an application crash) whenever used
-// (especially if called on long paths/from another directory).
-
-// there are plenty of ways to address this, but for the time being,
-// it's not worth the time so we'll just suspend macos9 support.
-
-public class PdeCompilerJavac extends PdeCompiler {
-
-  public PdeCompilerJavac(String buildPath, String className, 
-                          File includeFolder, PdeEditor editor) {
-    super(buildPath, className, includeFolder, editor);
-  }
-
-  public boolean compileJava(PrintStream leechErr) {
-
-    // probably not needed with javac
-    //System.setErr(leechErr); // redirect stderr to our leech filter
-
-    int argc = 0;
-    String args[] = new String[4];
-    args[argc++] = "-d";
-    args[argc++] = buildPath;
-    args[argc++] = "-nowarn";
-    args[argc++] = buildPath + File.separator + className + ".java";
-    //System.out.println("args = " + args[0] + " " + args[1]);
-
-    System.out.println("compiling with javac");
-    return new sun.tools.javac.Main(leechErr, "javac").compile(args);
-
-    // probably not needed with javac
-    //System.setErr(PdeEditorConsole.consoleErr);
-
-    //System.err.println("success = " + success);
-    //return success;
-  }
-
-  // part of the PdeMessageConsumer interface
-  //
-  public void message(String s) {
-    System.out.println("javac msg: " + s);
-
-    // as in: lib\build\Temporary_5476_6442.java:88: caution:Assignment of an expression to itself [KOPI]
-    if (s.indexOf("caution") != -1) return;
-
-    //
-    //System.out.println("leech2: " + new String(b, offset, length));
-    //String s = new String(b, offset, length);
-    //if (s.indexOf(tempFilename) == 0) {
-    String fullTempFilename = buildPath + File.separator + className + ".java";
-    if (s.indexOf(fullTempFilename) == 0) {
-      String s1 = s.substring(fullTempFilename.length() + 1);
-      int colon = s1.indexOf(':');
-      int lineNumber = Integer.parseInt(s1.substring(0, colon));
-      //System.out.println("pde / line number: " + lineNumber);
-
-      //String s2 = s1.substring(colon + 2);
-      int err = s1.indexOf("error:");
-      if (err != -1) {
-        //err += "error:".length();
-        String description = s1.substring(err + "error:".length());
-        description = description.trim();
-        
-        // as in: ...error:Constructor setup must be named Temporary_5362_2548 [JL1 8.6]
-        if(description.indexOf("Constructor setup must be named") != -1) {
-          description = "Missing function return type, or constructor does not match class name";
-        }
-        //exception = new PdeException(description, lineNumber-2);
-        exception = new PdeException(description, lineNumber-1);
-        editor.error(exception);
-
-      } else {
-        System.err.println("i suck: " + s);
-      }
-
-    } else {
-      //System.err.println("don't understand: " + s);
-      exception = new PdeException(SUPER_BADNESS);
-      editor.error(exception);
-    }
-  }
-}
-
-
-*/
\ No newline at end of file
diff --git a/app/preproc/.cvsignore b/app/preproc/.cvsignore
new file mode 100644
index 000000000..b010c249c
--- /dev/null
+++ b/app/preproc/.cvsignore
@@ -0,0 +1,9 @@
+*Lexer.java
+*Recognizer.java
+*TokenTypes.java
+*TokenTypes.txt
+*TreeParser.java
+*TreeParserTokenTypes.java
+*TreeParserTokenTypes.txt
+expanded*.g
+
diff --git a/app/preproc/ExtendedCommonASTWithHiddenTokens.java b/app/preproc/ExtendedCommonASTWithHiddenTokens.java
new file mode 100644
index 000000000..43519e89c
--- /dev/null
+++ b/app/preproc/ExtendedCommonASTWithHiddenTokens.java
@@ -0,0 +1,132 @@
+package antlr;
+
+/* ANTLR Translator Generator
+ * Project led by Terence Parr at http://www.jGuru.com
+ * Software rights: http://www.antlr.org/RIGHTS.html
+ *
+ * $Id$
+ */
+
+import java.io.*;
+import antlr.*;
+import antlr.collections.*;
+import antlr.collections.impl.*;
+
+/** A CommonAST whose initialization copies hidden token
+ *  information from the Token used to create a node.
+ */
+public class ExtendedCommonASTWithHiddenTokens 
+    extends CommonASTWithHiddenTokens {
+
+    public ExtendedCommonASTWithHiddenTokens() {
+        super();
+    }
+
+    public ExtendedCommonASTWithHiddenTokens(Token tok) {
+        super(tok);
+    }
+
+    public void initialize(AST ast) {
+        ExtendedCommonASTWithHiddenTokens a = 
+	    (ExtendedCommonASTWithHiddenTokens)ast;
+        super.initialize(a);
+        hiddenBefore = a.getHiddenBefore();
+        hiddenAfter = a.getHiddenAfter();
+    }
+
+    public String getHiddenAfterString() {
+
+	CommonHiddenStreamToken t;
+	StringBuffer hiddenAfterString = new StringBuffer(100);
+
+	for ( t = hiddenAfter ; t != null ; t = t.getHiddenAfter() ) {
+	    hiddenAfterString.append(t.getText());
+	}
+
+	return hiddenAfterString.toString();
+    }
+
+    public String getHiddenBeforeString() {
+
+	antlr.CommonHiddenStreamToken 
+	    child = null,
+	    parent = hiddenBefore;
+
+	// if there aren't any hidden tokens here, quietly return
+	// 
+	if (parent == null) {
+	    return "";
+	}
+
+	// traverse back to the head of the list of tokens before this node
+	do {
+	    child = parent;
+	    parent = child.getHiddenBefore();
+	} while (parent != null);
+
+	// dump that list
+
+	StringBuffer hiddenBeforeString = new StringBuffer(100);
+
+	for ( CommonHiddenStreamToken t = child; t != null ; 
+	      t = t.getHiddenAfter() ) {
+	    hiddenBeforeString.append(t.getText());
+	}
+
+	return hiddenBeforeString.toString();
+    }
+
+    public void xmlSerializeNode(Writer out)
+        throws IOException {
+        StringBuffer buf = new StringBuffer(100);
+        buf.append("<");
+        buf.append(getClass().getName() + " ");
+
+        buf.append("hiddenBeforeString=\"" + 
+		   encode(getHiddenBeforeString()) +
+		   "\" text=\"" + encode(getText()) + "\" type=\"" +
+                   getType() + "\" hiddenAfterString=\"" + 
+		   encode(getHiddenAfterString()) + "\"/>");
+        out.write(buf.toString());
+    }
+
+    public void xmlSerializeRootOpen(Writer out)
+        throws IOException {
+        StringBuffer buf = new StringBuffer(100);
+        buf.append("<");
+        buf.append(getClass().getName() + " ");
+        buf.append("hiddenBeforeString=\"" + 
+		   encode(getHiddenBeforeString()) +
+		   "\" text=\"" + encode(getText()) + "\" type=\"" +
+                   getType() + "\" hiddenAfterString=\"" + 
+		   encode(getHiddenAfterString()) + "\">\n");
+        out.write(buf.toString());
+    }
+
+    public void xmlSerializeRootClose(Writer out)
+        throws IOException {
+        out.write("</" + getClass().getName() + ">\n");
+    }
+
+    public void xmlSerialize(Writer out) throws IOException {
+        // print out this node and all siblings
+        for (AST node = this;
+             node != null;
+             node = node.getNextSibling()) {
+            if (node.getFirstChild() == null) {
+                // print guts (class name, attributes)
+                ((BaseAST)node).xmlSerializeNode(out);
+            }
+            else {
+                ((BaseAST)node).xmlSerializeRootOpen(out);
+
+                // print children
+                ((BaseAST)node.getFirstChild()).xmlSerialize(out);
+
+                // print end tag
+                ((BaseAST)node).xmlSerializeRootClose(out);
+            }
+        }
+    }
+
+}
diff --git a/app/preproc/PdeEmitter.java b/app/preproc/PdeEmitter.java
new file mode 100644
index 000000000..57c014f84
--- /dev/null
+++ b/app/preproc/PdeEmitter.java
@@ -0,0 +1,922 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+package processing.app.preproc;
+
+import processing.app.*;
+
+
+/* Based on original code copyright (c) 2003 Andy Tripp <atripp@comcast.net>.
+ * shipped under GPL with permission.
+ */
+
+import antlr.*;
+import antlr.collections.*;
+import antlr.collections.impl.*;
+import java.io.*;
+import java.util.*;
+
+/**
+ * PDEEmitter: A class that can take an ANTLR Java AST and produce
+ * reasonably formatted Java code from it. To use it, create a
+ * PDEEmitter object, call setOut() if you want to print to something
+ * other than System.out, and then call print(), passing the
+ * AST. Typically, the AST node that you pass would be the root of a
+ * tree - the ROOT_ID node that represents a Java file.
+ */
+
+public class PdeEmitter implements PdeTokenTypes
+{
+  private PrintStream out = System.out;
+  private PrintStream debug = System.err;
+  private static int ALL = -1;
+  private java.util.Stack stack = new java.util.Stack();
+  private static String[] tokenNames;
+  private final static int ROOT_ID = 0;
+  static {
+    setupTokenNames();
+  }
+
+  /*
+  private static Hashtable publicMethods;
+  private static final String publicMethodList[] = {
+    "setup", "draw", //"loop",
+    "mousePressed", "mouseReleased", "mouseClicked",
+    "mouseEntered", "mouseExited",
+    "mouseMoved", "mouseDragged",
+    "keyPressed", "keyReleased", "keyTyped"
+  };
+
+  static {
+    publicMethods = new Hashtable();
+    for (int i = 0; i < publicMethodList.length; i++) {
+      publicMethods.put(publicMethodList[i], new Object());
+    }
+  }
+  */
+
+  // Map each AST token type to a String
+  private static void setupTokenNames() {
+    tokenNames = new String[200];
+    for (int i=0; i<tokenNames.length; i++) {
+      tokenNames[i] = "ERROR:" + i;
+    }
+
+    tokenNames[POST_INC]="++";
+    tokenNames[POST_DEC]="--";
+    tokenNames[UNARY_MINUS]="-";
+    tokenNames[UNARY_PLUS]="+";
+    tokenNames[STAR]="*";
+    tokenNames[ASSIGN]="=";
+    tokenNames[PLUS_ASSIGN]="+=";
+    tokenNames[MINUS_ASSIGN]="-=";
+    tokenNames[STAR_ASSIGN]="*=";
+    tokenNames[DIV_ASSIGN]="/=";
+    tokenNames[MOD_ASSIGN]="%=";
+    tokenNames[SR_ASSIGN]=">>=";
+    tokenNames[BSR_ASSIGN]=">>>=";
+    tokenNames[SL_ASSIGN]="<<=";
+    tokenNames[BAND_ASSIGN]="&=";
+    tokenNames[BXOR_ASSIGN]="^=";
+    tokenNames[BOR_ASSIGN]="|=";
+    tokenNames[QUESTION]="?";
+    tokenNames[LOR]="||";
+    tokenNames[LAND]="&&";
+    tokenNames[BOR]="|";
+    tokenNames[BXOR]="^";
+    tokenNames[BAND]="&";
+    tokenNames[NOT_EQUAL]="!=";
+    tokenNames[EQUAL]="==";
+    tokenNames[LT]="<";
+    tokenNames[GT]=">";
+    tokenNames[LE]="<=";
+    tokenNames[GE]=">=";
+    tokenNames[SL]="<<";
+    tokenNames[SR]=">>";
+    tokenNames[BSR]=">>>";
+    tokenNames[PLUS]="+";
+    tokenNames[MINUS]="-";
+    tokenNames[DIV]="/";
+    tokenNames[MOD]="%";
+    tokenNames[INC]="++";
+    tokenNames[DEC]="--";
+    tokenNames[BNOT]="~";
+    tokenNames[LNOT]="!";
+    tokenNames[FINAL]="final";
+    tokenNames[ABSTRACT]="abstract";
+    tokenNames[LITERAL_package]="package";
+    tokenNames[LITERAL_import]="import";
+    tokenNames[LITERAL_void]="void";
+    tokenNames[LITERAL_boolean]="boolean";
+    tokenNames[LITERAL_byte]="byte";
+    tokenNames[LITERAL_char]="char";
+    tokenNames[LITERAL_short]="short";
+    tokenNames[LITERAL_int]="int";
+    tokenNames[LITERAL_float]="float";
+    tokenNames[LITERAL_long]="long";
+    tokenNames[LITERAL_double]="double";
+    tokenNames[LITERAL_private]="private";
+    tokenNames[LITERAL_public]="public";
+    tokenNames[LITERAL_protected]="protected";
+    tokenNames[LITERAL_static]="static";
+    tokenNames[LITERAL_transient]="transient";
+    tokenNames[LITERAL_native]="native";
+    tokenNames[LITERAL_threadsafe]="threadsafe";
+    tokenNames[LITERAL_synchronized]="synchronized";
+    tokenNames[LITERAL_volatile]="volatile";
+    tokenNames[LITERAL_class]="class";
+    tokenNames[LITERAL_extends]="extends";
+    tokenNames[LITERAL_interface]="interface";
+    tokenNames[LITERAL_implements]="implements";
+    tokenNames[LITERAL_throws]="throws";
+    tokenNames[LITERAL_if]="if";
+    tokenNames[LITERAL_else]="else";
+    tokenNames[LITERAL_for]="for";
+    tokenNames[LITERAL_while]="while";
+    tokenNames[LITERAL_do]="do";
+    tokenNames[LITERAL_break]="break";
+    tokenNames[LITERAL_continue]="continue";
+    tokenNames[LITERAL_return]="return";
+    tokenNames[LITERAL_switch]="switch";
+    tokenNames[LITERAL_throw]="throw";
+    tokenNames[LITERAL_case]="case";
+    tokenNames[LITERAL_default]="default";
+    tokenNames[LITERAL_try]="try";
+    tokenNames[LITERAL_finally]="finally";
+    tokenNames[LITERAL_catch]="catch";
+    tokenNames[LITERAL_instanceof]="instanceof";
+    tokenNames[LITERAL_this]="this";
+    tokenNames[LITERAL_super]="super";
+    tokenNames[LITERAL_true]="true";
+    tokenNames[LITERAL_false]="false";
+    tokenNames[LITERAL_null]="null";
+    tokenNames[LITERAL_new]="new";
+    tokenNames[LITERAL_color]="int";    // PDE specific alias
+  }
+
+  /**
+   * Specify a PrintStream to print to. System.out is the default.
+   * @param out the PrintStream to print to
+   */
+  public void setOut(PrintStream out) {
+    this.out = out;
+  }
+  private String name(AST ast) {
+    return tokenNames[ast.getType()];
+  }
+  private String name(int type) {
+    return tokenNames[type];
+  }
+
+  /**
+   * Find a child of the given AST that has the given type
+   * @returns a child AST of the given type. If it can't find a child of the
+   *          given type, return null.
+   */
+  private AST getChild(AST ast, int childType) {
+    AST child = ast.getFirstChild();
+    while (child != null) {
+      if (child.getType() == childType) {
+        // debug.println("getChild: found:" + name(ast));
+        return child;
+      }
+      child = child.getNextSibling();
+    }
+    return null;
+  }
+
+  /**
+   * Dump the list of hidden tokens linked to after the AST node passed in.
+   * Most hidden tokens are dumped from this function.
+   */
+  private void dumpHiddenAfter(AST ast) {
+    dumpHiddenTokens(((antlr.CommonASTWithHiddenTokens)ast).getHiddenAfter());
+  }
+
+  /**
+   * Dump the list of hidden tokens linked to before the AST node passed in.
+   * The only time hidden tokens need to be dumped with this function is when
+   * dealing parts of the tree where automatic tree construction was
+   * turned off with the ! operator in the grammar file and the nodes were
+   * manually constructed in such a way that the usual tokens don't have the
+   * necessary hiddenAfter links.
+   */
+  private void dumpHiddenBefore(AST ast) {
+
+    antlr.CommonHiddenStreamToken
+      child = null,
+      parent = ((antlr.CommonASTWithHiddenTokens)ast).getHiddenBefore();
+
+    // if there aren't any hidden tokens here, quietly return
+    //
+    if (parent == null) {
+      return;
+    }
+
+    // traverse back to the head of the list of tokens before this node
+    do {
+      child = parent;
+      parent = child.getHiddenBefore();
+    } while (parent != null);
+
+    // dump that list
+    dumpHiddenTokens(child);
+  }
+
+  /**
+   * Dump the list of hidden tokens linked to from the token passed in.
+   */
+  private void dumpHiddenTokens(antlr.CommonHiddenStreamToken t) {
+    for ( ; t != null ; t=PdePreprocessor.filter.getHiddenAfter(t) ) {
+      out.print(t.getText());
+    }
+  }
+
+  /**
+   * Print the children of the given AST
+   * @param ast The AST to print
+   * @returns true iff anything was printed
+   */
+  private boolean printChildren(AST ast) throws PdeException {
+    boolean ret = false;
+    AST child = ast.getFirstChild();
+    while (child != null) {
+      ret = true;
+      print(child);
+      child = child.getNextSibling();
+    }
+    return ret;
+  }
+
+  /**
+   * Tells whether an AST has any children or not.
+   * @return true iff the AST has at least one child
+   */
+  private boolean hasChildren(AST ast) {
+    return (ast.getFirstChild() != null);
+  }
+
+  /**
+   * Gets the best node in the subtree for printing.  This really means
+   * the next node which could potentially have hiddenBefore data.  It's
+   * usually the first printable leaf, but not always.
+   *
+   * @param includeThisNode     Should this node be included in the search?
+   *                            If false, only descendants are searched.
+   *
+   * @return the first printable leaf node in an AST
+   */
+  private AST getBestPrintableNode(AST ast, boolean includeThisNode) {
+    AST child;
+
+    if (includeThisNode) {
+      child = ast;
+    } else {
+      child = ast.getFirstChild();
+    }
+
+    if (child != null) {
+
+      switch (child.getType()) {
+
+        // the following node types are printing nodes that print before
+        // any children, but then also recurse over children.  So they
+        // may have hiddenBefore chains that need to be printed first.  Many
+        // statements and all unary expression types qualify.  Return these
+        // nodes directly
+      case CLASS_DEF:
+      case LITERAL_if:
+      case LITERAL_for:
+      case LITERAL_while:
+      case LITERAL_do:
+      case LITERAL_break:
+      case LITERAL_continue:
+      case LITERAL_return:
+      case LITERAL_switch:
+      case LITERAL_try:
+      case LITERAL_throw:
+      case LITERAL_synchronized:
+      case LITERAL_assert:
+      case BNOT:
+      case LNOT:
+      case INC:
+      case DEC:
+      case UNARY_MINUS:
+      case UNARY_PLUS:
+        return child;
+
+        // Some non-terminal node types (at the moment, I only know of
+        // MODIFIERS, but there may be other such types), can be
+        // leaves in the tree but not have any children.  If this is
+        // such a node, move on to the next sibling.
+      case MODIFIERS:
+        if (child.getFirstChild() == null ) {
+          return getBestPrintableNode(child.getNextSibling(), false);
+        }
+        // new jikes doesn't like fallthrough, so just duplicated here:
+        return getBestPrintableNode(child, false);
+
+      default:
+        return getBestPrintableNode(child, false);
+      }
+    }
+
+    return ast;
+  }
+
+  /**
+   * Prints a binary operator
+   */
+  private void printBinaryOperator(AST ast) throws PdeException {
+    print(ast.getFirstChild());
+    out.print(name(ast));
+    dumpHiddenAfter(ast);
+    print(ast.getFirstChild().getNextSibling());
+  }
+
+  /**
+   * Print the given AST. Call this function to print your PDE code.
+   *
+   * It works by making recursive calls to print children.
+   * So the code below is one big "switch" statement on the passed AST type.
+   */
+  public void print (AST ast) throws PdeException {
+    if (ast == null) {
+      return;
+    }
+
+    AST parent = null;
+    if (!stack.isEmpty()) {
+      parent = (AST) stack.peek();
+    }
+    stack.push(ast);
+
+    AST child1 = ast.getFirstChild();
+    AST child2 = null;
+    AST child3 = null;
+    if (child1 != null) {
+      child2 = child1.getNextSibling();
+      if (child2 != null) {
+        child3 = child2.getNextSibling();
+      }
+    }
+
+    switch(ast.getType()) {
+      // The top of the tree looks like this:
+      //  ROOT_ID  "Whatever.java"
+      //   package
+      //   imports
+      //   class definition
+    case ROOT_ID:
+      dumpHiddenTokens(PdePreprocessor.filter.getInitialHiddenToken());
+      printChildren(ast);
+      break;
+
+      // supporting a "package" statement in a PDE program has
+      // a bunch of issues with it that need to dealt in the compilation
+      // code too, so this isn't actually tested.
+    case PACKAGE_DEF:
+      out.print("package");
+      dumpHiddenAfter(ast);
+      print(ast.getFirstChild());
+      break;
+
+      // IMPORT has exactly one child
+    case IMPORT:
+      out.print("import");
+      dumpHiddenAfter(ast);
+      print(ast.getFirstChild());
+      break;
+
+    case CLASS_DEF:
+    case INTERFACE_DEF:
+      print(getChild(ast, MODIFIERS));
+      if (ast.getType() == CLASS_DEF) {
+        out.print("class");
+      } else {
+        out.print("interface");
+      }
+      dumpHiddenBefore(getChild(ast, IDENT));
+      print(getChild(ast, IDENT));
+      print(getChild(ast, EXTENDS_CLAUSE));
+      print(getChild(ast, IMPLEMENTS_CLAUSE));
+      print(getChild(ast, OBJBLOCK));
+      break;
+
+    case EXTENDS_CLAUSE:
+      if (hasChildren(ast)) {
+        out.print("extends");
+        dumpHiddenBefore(getBestPrintableNode(ast, false));
+        printChildren(ast);
+      }
+      break;
+
+    case IMPLEMENTS_CLAUSE:
+      if (hasChildren(ast)) {
+        out.print("implements");
+        dumpHiddenBefore(getBestPrintableNode(ast, false));
+        printChildren(ast);
+      }
+      break;
+
+      // DOT always has exactly two children.
+    case DOT:
+      print(child1);
+      out.print(".");
+      dumpHiddenAfter(ast);
+      print(child2);
+      break;
+
+    case MODIFIERS:
+    case OBJBLOCK:
+    case CTOR_DEF:
+      //case METHOD_DEF:
+    case PARAMETERS:
+    case PARAMETER_DEF:
+    case VARIABLE_DEF:
+    case TYPE:
+    case SLIST:
+    case ELIST:
+    case ARRAY_DECLARATOR:
+    case TYPECAST:
+    case EXPR:
+    case ARRAY_INIT:
+    case FOR_INIT:
+    case FOR_CONDITION:
+    case FOR_ITERATOR:
+    case METHOD_CALL:
+    case INSTANCE_INIT:
+    case INDEX_OP:
+    case SUPER_CTOR_CALL:
+    case CTOR_CALL:
+      printChildren(ast);
+      break;
+
+    case METHOD_DEF:
+      // kids seem to be: MODIFIERS TYPE setup PARAMETERS
+      //AST parent = (AST) stack.peek();
+      AST modifiersChild = ast.getFirstChild();
+      AST typeChild = modifiersChild.getNextSibling();
+      AST methodNameChild = typeChild.getNextSibling();
+      AST parametersChild = methodNameChild.getNextSibling();
+
+      // to output, use print(child) on each of the four
+
+      /*
+      // 1. figure out if this is setup, draw, or loop
+      String methodName = methodNameChild.getText();
+      if (publicMethods.get(methodName) != null) {
+        // make sure this feller is public
+        boolean foundPublic = false;
+        AST child = modifiersChild.getFirstChild();
+        while (child != null) {
+          if (child.getText().equals("public")) {
+            foundPublic = true;
+            child = null;
+          } else {
+            //out.print("." + child.getText() + ".");
+            child = child.getNextSibling();
+          }
+        }
+        if (!foundPublic) {
+          out.print("public ");
+        }
+      */
+
+      // if this method doesn't have a specifier, make it public
+      // (useful for setup/keyPressed/etc)
+      boolean foundSpecifier = false;
+      AST child = modifiersChild.getFirstChild();
+      while (child != null) {
+        String childText = child.getText();
+        if (childText.equals("public") ||
+            childText.equals("protected") ||
+            childText.equals("private")) {
+          foundSpecifier = true;
+          child = null;
+        } else {
+          //out.print("." + child.getText() + ".");
+          child = child.getNextSibling();
+        }
+      }
+      if (!foundSpecifier) {
+        out.print("public ");
+      }
+      printChildren(ast);  // everything is fine
+      break;
+
+      // if we have two children, it's of the form "a=0"
+      // if just one child, it's of the form "=0" (where the
+      // lhs is above this AST).
+    case ASSIGN:
+      if (child2 != null) {
+        print(child1);
+        out.print("=");
+        dumpHiddenAfter(ast);
+        print(child2);
+      }
+      else {
+        out.print("=");
+        dumpHiddenAfter(ast);
+        print(child1);
+      }
+      break;
+
+      // binary operators:
+    case PLUS:
+    case MINUS:
+    case DIV:
+    case MOD:
+    case NOT_EQUAL:
+    case EQUAL:
+    case LT:
+    case GT:
+    case LE:
+    case GE:
+    case LOR:
+    case LAND:
+    case BOR:
+    case BXOR:
+    case BAND:
+    case SL:
+    case SR:
+    case BSR:
+    case LITERAL_instanceof:
+    case PLUS_ASSIGN:
+    case MINUS_ASSIGN:
+    case STAR_ASSIGN:
+    case DIV_ASSIGN:
+    case MOD_ASSIGN:
+    case SR_ASSIGN:
+    case BSR_ASSIGN:
+    case SL_ASSIGN:
+    case BAND_ASSIGN:
+    case BXOR_ASSIGN:
+    case BOR_ASSIGN:
+      printBinaryOperator(ast);
+      break;
+
+
+    case LITERAL_for:
+      out.print(name(ast));
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case POST_INC:
+    case POST_DEC:
+      print(child1);
+      out.print(name(ast));
+      dumpHiddenAfter(ast);
+      break;
+
+      // unary operators:
+    case BNOT:
+    case LNOT:
+    case INC:
+    case DEC:
+    case UNARY_MINUS:
+    case UNARY_PLUS:
+      out.print(name(ast));
+      dumpHiddenAfter(ast);
+      print(child1);
+      break;
+
+    case LITERAL_new:
+      out.print("new");
+      dumpHiddenAfter(ast);
+      print(child1);
+      print(child2);
+      // "new String[] {...}": the stuff in {} is child3
+      if (child3 != null) {
+        print(child3);
+      }
+      break;
+
+    case LITERAL_return:
+      out.print("return");
+      dumpHiddenAfter(ast);
+      print(child1);
+      break;
+
+    case STATIC_INIT:
+      out.print("static");
+      dumpHiddenBefore(getBestPrintableNode(ast, false));
+      print(child1);
+      break;
+
+    case LITERAL_switch:
+      out.print("switch");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case CASE_GROUP:
+      printChildren(ast);
+      break;
+
+    case LITERAL_case:
+      out.print("case");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case LITERAL_default:
+      out.print("default");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case NUM_INT:
+    case CHAR_LITERAL:
+    case STRING_LITERAL:
+    case NUM_FLOAT:
+      out.print(ast.getText());
+      dumpHiddenAfter(ast);
+      break;
+
+    case LITERAL_private:
+    case LITERAL_public:
+    case LITERAL_protected:
+    case LITERAL_static:
+    case LITERAL_transient:
+    case LITERAL_native:
+    case LITERAL_threadsafe:
+    case LITERAL_synchronized:
+    case LITERAL_volatile:
+    case FINAL:
+    case ABSTRACT:
+    case LITERAL_package:
+    case LITERAL_void:
+    case LITERAL_boolean:
+    case LITERAL_byte:
+    case LITERAL_char:
+    case LITERAL_short:
+    case LITERAL_int:
+    case LITERAL_float:
+    case LITERAL_long:
+    case LITERAL_double:
+    case LITERAL_true:
+    case LITERAL_false:
+    case LITERAL_null:
+    case SEMI:
+    case LITERAL_this:
+    case LITERAL_super:
+    case LITERAL_continue:
+    case LITERAL_break:
+      out.print(name(ast));
+      dumpHiddenAfter(ast);
+      break;
+
+    case EMPTY_STAT:
+    case EMPTY_FIELD:
+      break;
+
+      // yuck:  Distinguish between "import x.y.*" and "x = 1 * 3"
+    case STAR:
+      if (hasChildren(ast)) {   // the binary mult. operator
+        printBinaryOperator(ast);
+      }
+      else {    // the special "*" in import:
+        out.print("*");
+        dumpHiddenAfter(ast);
+      }
+      break;
+
+    case LITERAL_throws:
+      out.print("throws");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case LITERAL_if:
+      out.print("if");
+      dumpHiddenAfter(ast);
+      print(child1);    // the "if" condition: an EXPR
+      print(child2);    // the "then" clause is an SLIST
+      if (child3 != null) {
+        out.print("else");
+        dumpHiddenBefore(getBestPrintableNode(child3, true));
+        print(child3);  // optional "else" clause: an SLIST
+      }
+      break;
+
+    case LITERAL_while:
+      out.print("while");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case LITERAL_do:
+      out.print("do");
+      dumpHiddenAfter(ast);
+      print(child1);            // an SLIST
+      out.print("while");
+      dumpHiddenBefore(getBestPrintableNode(child2, false));
+      print(child2);            // an EXPR
+      break;
+
+    case LITERAL_try:
+      out.print("try");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case LITERAL_catch:
+      out.print("catch");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+      // the first child is the "try" and the second is the SLIST
+    case LITERAL_finally:
+      out.print("finally");
+      dumpHiddenAfter(ast);
+      printChildren(ast);
+      break;
+
+    case LITERAL_throw:
+      out.print("throw");
+      dumpHiddenAfter(ast);
+      print(child1);
+      break;
+
+      // the dreaded trinary operator
+    case QUESTION:
+      print(child1);
+      out.print("?");
+      dumpHiddenAfter(ast);
+      print(child2);
+      print(child3);
+      break;
+
+      // pde specific or modified tokens start here
+
+      // Image -> BImage, Font -> BFont as appropriate
+    case IDENT:
+      /*
+      if (ast.getText().equals("Image") &&
+          PdePreferences.getBoolean("preproc.substitute_image")) { //, true)) {
+        out.print("BImage");
+      } else if (ast.getText().equals("Font") &&
+                 PdePreferences.getBoolean("preproc.substitute_font")) { //, true)) {
+        out.print("BFont");
+      } else {
+      */
+      out.print(ast.getText());
+      //}
+      dumpHiddenAfter(ast);
+      break;
+
+      // the color datatype is just an alias for int
+    case LITERAL_color:
+      out.print("int");
+      dumpHiddenAfter(ast);
+      break;
+
+    case WEBCOLOR_LITERAL:
+      if (ast.getText().length() != 6) {
+        System.err.println("Internal error: incorrect length of webcolor " +
+                           "literal should have been detected sooner.");
+        break;
+      }
+      out.print("0xff" + ast.getText());
+      dumpHiddenAfter(ast);
+      break;
+
+      // allow for stuff like int(43.2).
+    case CONSTRUCTOR_CAST:
+
+      AST nonTerminalTypeNode = child1;
+      AST terminalTypeNode = child1.getFirstChild();
+      AST exprToCast = child2;
+
+      /*
+        // if this is a string type, add .valueOf()
+      if (nonTerminalTypeNode.getType() == PdeRecognizer.TYPE &&
+          terminalTypeNode.getText().equals("String")) {
+
+        out.print(terminalTypeNode.getText() + ".valueOf");
+        dumpHiddenAfter(terminalTypeNode);
+        print(exprToCast);
+
+        // if the expresion to be cast is a string literal, try and parse it.
+        //
+        // ideally, we'd be able to do this for all expressions with a
+        // string type, not just string literals.  however, the parser
+        // doesn't currently track expression type, and for full
+        // functionality, we'd need to do semantic analysis to handle
+        // imports so that we could know the return types of method calls.
+        //
+      } else if (exprToCast.getFirstChild().getType() == STRING_LITERAL ) {
+
+        switch (terminalTypeNode.getType()) {
+
+        case PdeRecognizer.LITERAL_byte:
+          out.print("Byte.parseByte");
+          dumpHiddenAfter(terminalTypeNode);
+          print(exprToCast);
+          break;
+
+        case PdeRecognizer.LITERAL_double:
+          out.print("(new Double");
+          dumpHiddenAfter(terminalTypeNode);
+          out.print(exprToCast.getFirstChild().getText() + ").doubleValue()");
+          dumpHiddenAfter(exprToCast.getFirstChild());
+          break;
+
+        case PdeRecognizer.LITERAL_float:
+          out.print("(new Float");
+          dumpHiddenAfter(terminalTypeNode);
+          out.print(exprToCast.getFirstChild().getText() + ").floatValue()");
+          dumpHiddenAfter(exprToCast.getFirstChild());
+          break;
+
+        case PdeRecognizer.LITERAL_int:
+        case PdeRecognizer.LITERAL_color:
+          out.print("Integer.parseInt");
+          dumpHiddenAfter(terminalTypeNode);
+          print(exprToCast);
+          break;
+
+        case PdeRecognizer.LITERAL_long:
+          out.print("Long.parseLong");
+          break;
+
+        case PdeRecognizer.LITERAL_short:
+          out.print("Short.parseShort");
+          break;
+
+        default:
+          throw new PdeException(PdeCompiler.SUPER_BADNESS);
+        }
+
+        // for builtin types, use regular casting syntax
+      } else {
+      */
+
+      // result of below is (int)(4.0
+      //out.print("(");
+      //out.print(terminalTypeNode.getText() + ")"); // typename
+      //dumpHiddenAfter(terminalTypeNode);
+      //print(exprToCast);
+      //}
+
+      //out.print("(");
+      String pooType = terminalTypeNode.getText();
+      out.print("PApplet.to" +
+                Character.toUpperCase(pooType.charAt(0)) +
+                pooType.substring(1));
+      dumpHiddenAfter(terminalTypeNode);  // the left paren
+      print(exprToCast);
+      //out.print("x)");
+
+      break;
+
+
+      // making floating point literals default to floats, not doubles
+    case NUM_DOUBLE:
+      out.print(ast.getText());
+      if (PdePreferences.getBoolean("preproc.substitute_floats")) { //, true) ) {
+        out.print("f");
+      }
+      dumpHiddenAfter(ast);
+      break;
+
+
+    default:
+      debug.println("Invalid type:" + ast.getType());
+      break;
+
+
+/* The following are tokens, but I don't think JavaRecognizer
+   ever produces an AST with one of these types:
+   case COMMA:
+   case LITERAL_implements:
+   case LITERAL_class:
+   case LITERAL_extends:
+   case EOF:
+   case NULL_TREE_LOOKAHEAD:
+   case BLOCK:
+   case LABELED_STAT:   // refuse to implement on moral grounds :)
+   case LITERAL_import:
+   case LBRACK:
+   case RBRACK:
+   case LCURLY:
+   case RCURLY:
+   case LPAREN:
+   case RPAREN:
+   case LITERAL_else:   // else is a child of "if" AST
+   case COLON:          // part of the trinary operator
+   case WS:             // whitespace
+   case ESC:
+   case HEX_DIGIT:
+   case VOCAB:
+
+   case EXPONENT:       // exponents and float suffixes are left in the NUM_FLOAT
+   case FLOAT_SUFFIX
+*/
+    }
+
+    stack.pop();
+  }
+}
diff --git a/app/PdePreprocessor.java b/app/preproc/PdePreprocessor.java
similarity index 96%
rename from app/PdePreprocessor.java
rename to app/preproc/PdePreprocessor.java
index ae09f7d54..436d8823c 100644
--- a/app/PdePreprocessor.java
+++ b/app/preproc/PdePreprocessor.java
@@ -4,8 +4,8 @@
   PdePreprocessor - wrapper for default ANTLR-generated parser
   Part of the Processing project - http://processing.org
 
-  Except where noted, code is written by Ben Fry and
-  Copyright (c) 2001-03 Massachusetts Institute of Technology
+  Copyright (c) 2004-05 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
 
   ANTLR-generated parser and several supporting classes written
   by Dan Mosedale via funding from the Interaction Institute IVREA.
@@ -25,6 +25,9 @@
   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
+package processing.app.preproc;
+
+import processing.app.*;
 import processing.core.*;
 
 import java.io.*;
@@ -48,17 +51,17 @@ public class PdePreprocessor {
   // might be at the end instead of .* whcih would make trouble
   // other classes using this can lop of the . and anything after
   // it to produce a package name consistently.
-  String extraImports[];
+  public String extraImports[];
 
   // imports just from the code folder, treated differently
   // than the others, since the imports are auto-generated.
-  String codeFolderImports[];
+  public String codeFolderImports[];
 
-  static final int STATIC = 0;  // formerly BEGINNER
-  static final int ACTIVE = 1;  // formerly INTERMEDIATE
-  static final int JAVA   = 2;  // formerly ADVANCED
+  static public final int STATIC = 0;  // formerly BEGINNER
+  static public final int ACTIVE = 1;  // formerly INTERMEDIATE
+  static public final int JAVA   = 2;  // formerly ADVANCED
   // static to make it easier for the antlr preproc to get at it
-  static int programType = -1;
+  static public int programType = -1;
 
   Reader programReader;
   String buildPath;
diff --git a/app/preproc/README.txt b/app/preproc/README.txt
new file mode 100644
index 000000000..52c3d7b39
--- /dev/null
+++ b/app/preproc/README.txt
@@ -0,0 +1,106 @@
+The PDE Preprocessor is based on the Java Grammar that comes with
+ANTLR 2.7.2.  Moving it forward to a new version of the grammar
+shouldn't be too difficult.
+
+Here's some info about the various files in this directory:
+
+java.g: this is the ANTLR grammar for Java 1.3/1.4 from the ANTLR
+distribution.  It is in the public domain.  The only change to this
+file from the original this file is the uncommenting of the clauses
+required to support assert().
+
+java.tree.g: this describes the Abstract Syntax Tree (AST) generated
+by java.g.  It is only here as a reference for coders hacking on the
+preprocessor, it is not built or used at all.  Note that pde.g
+overrides some of the java.g rules so that in PDE ASTs, there are a
+few minor differences.  Also in the public domain.
+
+pde.g: this is the grammar and lexer for the PDE language itself.  It
+subclasses the java.g grammar and lexer.  There are a couple of
+overrides to java.g that I hope to convince the ANTLR folks to fold
+back into their grammar, but most of this file is highly specific to
+PDE itself.
+
+PdeEmitter.java: this class traverses the AST generated by the PDE
+Recognizer, and emits it as Java code, doing any necessary
+transformations along the way.  It is based on JavaEmitter.java,
+available from antlr.org, written by Andy Tripp <atripp@comcast.net>,
+who has given permission for it to be distributed under the GPL.
+
+ExtendedCommonASTWithHiddenTokens.java: this adds a necessary
+initialize() method, as well as a number of methods to allow for XML
+serialization of the parse tree in a such a way that the hidden tokens
+are visible.  Much of the code is taken from the original
+CommonASTWithHiddenTokens class.  I hope to convince the ANTLR folks
+to fold these changes back into that class so that this file will be
+unnecessary.
+
+TokenStreamCopyingHiddenTokenFilter.java: this class provides
+TokenStreamHiddenTokenFilters with the concept of tokens which can be
+copied so that they are seen by both the hidden token stream as well
+as the parser itself.  This is useful when one wants to use an
+existing parser (like the Java parser included with ANTLR) that throws
+away some tokens to create a parse tree which can be used to spit out
+a copy of the code with only minor modifications.  Partially derived
+from ANTLR code.  I hope to convince the ANTLR folks to fold this
+functionality back into ANTLR proper as well.
+
+whitespace_test.pde: a torture test to ensure that the preprocessor is
+correctly preserving whitespace, comments, and other hidden tokens
+correctly.  See the comments in the code for details about how to run
+the test.
+
+All other files in this directory are generated at build time by ANTLR
+itself.  The ANTLR manual goes into a fair amount of detail about the
+what each type of file is for.
+
+
+....
+
+
+Current Preprocessor Subsitutions:
+
+"compiler.substitute_floats" (currently "substitute_f")
+- treat doubles as floats, i.e. 12.3 becomes 12.3f so that people
+  don't have to add f after their numbers all the time. this is
+  confusing for beginners.
+
+"compiler.enhanced_casting"
+- byte(), char(), int(), float() works for casting. this is basic in
+  the current implementation, but should be expanded as described
+  above. color() works similarly to int(), however there is also a
+  *function* called color(r, g, b) in p5. will this cause trouble?
+
+"compiler.color_datattype"
+- 'color' is aliased to 'int' as a datatype to represent ARGB packed
+  into a single int, commonly used in p5 for pixels[] and other color
+  operations. this is just a search/replace type thing, and it can be
+  used interchangeably with int.
+
+"compiler.web_colors" (currently "inline_web_colors")
+- color c = #cc0080; should unpack to 0xffcc0080 (the ff at the top is
+  so that the color is opaque), which is just an int. 
+
+Other preprocessor functionality
+
+- detects what 'mode' the program is in: static (no function brackets
+  at all, just assumes everything is in draw), active (setup plus draw
+  or loop), and java mode (full java support). 
+  http://proce55ing.net/reference/environment/index.html
+
+- size and background are pulled from draw mode programs and placed
+  into setup(). this has a problem if size() is based on a variable,
+  which we try to avoid people doing, but would like to be able to
+  support it (perhaps by requiring the size() to be final?)
+
+- currently does a godawful scrambling of the comments so that the
+  substitution doesn't try to run on them. this also causes lots of
+  bizarro bugs.
+
+Possible?
+
+- would be nice to just type code wherever, mixing a 'static' style
+  app with a few functions. would be simpler for starting out. but it
+  seems that the declarations would have to be pulled out, but that
+  all seems problematic. or maybe it could all be inside a static { } 
+  block. but that wouldn't seem to work either.
diff --git a/app/preproc/TokenStreamCopyingHiddenTokenFilter.java b/app/preproc/TokenStreamCopyingHiddenTokenFilter.java
new file mode 100644
index 000000000..a80a2f3d9
--- /dev/null
+++ b/app/preproc/TokenStreamCopyingHiddenTokenFilter.java
@@ -0,0 +1,221 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+package antlr;
+//package processing.app.preproc;
+
+
+import antlr.*;
+import antlr.collections.impl.BitSet;
+
+/**
+ * This class provides TokenStreamHiddenTokenFilters with the concept of
+ * tokens which can be copied so that they are seen by both the hidden token
+ * stream as well as the parser itself.  This is useful when one wants to use
+ * an existing parser (like the Java parser included with ANTLR) that throws
+ * away some tokens to create a parse tree which can be used to spit out
+ * a copy of the code with only minor modifications.
+ *
+ * This code is partially derived from the public domain ANLTR TokenStream
+ */
+public class TokenStreamCopyingHiddenTokenFilter
+  extends TokenStreamHiddenTokenFilter
+  implements TokenStream {
+
+  protected BitSet copyMask;
+  CommonHiddenStreamToken hiddenCopy = null;
+
+  public TokenStreamCopyingHiddenTokenFilter(TokenStream input) {
+    super(input);
+    copyMask = new BitSet();
+  }
+
+  /**
+   * Indicate that all tokens of type tokenType should be copied.  The copy
+   * is put in the stream of hidden tokens, and the original is returned in the
+   * stream of normal tokens.
+   *
+   * @param tokenType   integer representing the token type to copied
+   */
+  public void copy(int tokenType) {
+    copyMask.add(tokenType);
+  }
+
+  /**
+   * Create a clone of the important parts of the given token.  Note that this
+   * does NOT copy the hiddenBefore and hiddenAfter fields.
+   *
+   * @param t   token to partially clone
+   * @return    newly created partial clone
+   */
+  public CommonHiddenStreamToken partialCloneToken(CommonHiddenStreamToken t) {
+
+    CommonHiddenStreamToken u = new CommonHiddenStreamToken(t.getType(),
+                                                            t.getText());
+    u.setColumn(t.getColumn());
+    u.setLine(t.getLine());
+    u.setFilename(t.getFilename());
+
+    return u;
+  }
+
+  public void linkAndCopyToken(CommonHiddenStreamToken prev,
+                               CommonHiddenStreamToken monitored) {
+    // create a copy of the token in the lookahead for use as hidden token
+    hiddenCopy = partialCloneToken(LA(1));
+
+    // attach copy to the previous token, whether hidden or monitored
+    prev.setHiddenAfter(hiddenCopy);
+
+    // if previous token was hidden, set the hiddenBefore pointer of the
+    // copy to point back to it
+    if (prev != monitored) {
+      hiddenCopy.setHiddenBefore(prev);
+    }
+
+    // we don't want the non-hidden copy to link back to the hidden
+    // copy on the next pass through this function, so we leave
+    // lastHiddenToken alone
+
+    //System.err.println("hidden copy: " + hiddenCopy.toString());
+
+    return;
+  }
+
+  private void consumeFirst() throws TokenStreamException {
+    consume(); // get first token of input stream
+
+    // Handle situation where hidden or discarded tokens
+    // appear first in input stream
+    CommonHiddenStreamToken p=null;
+
+    // while hidden, copied, or discarded scarf tokens
+    while ( hideMask.member(LA(1).getType()) ||
+            discardMask.member(LA(1).getType()) ||
+            copyMask.member(LA(1).getType()) ) {
+
+      // if we've hit one of the tokens that needs to be copied, we copy it
+      // and then break out of the loop, because the parser needs to see it
+      // too
+      //
+      if (copyMask.member(LA(1).getType())) {
+
+        // copy the token in the lookahead
+        hiddenCopy = partialCloneToken(LA(1));
+
+        // if there's an existing token before this, link that and the
+        // copy together
+        if (p != null) {
+          p.setHiddenAfter(hiddenCopy);
+          hiddenCopy.setHiddenBefore(p); // double-link
+        }
+
+        lastHiddenToken = hiddenCopy;
+        if (firstHidden == null) {
+          firstHidden = hiddenCopy;
+        }
+
+        // we don't want to consume this token, because it also needs to
+        // be passed through to the parser, so break out of the while look
+        // entirely
+        //
+        break;
+      } else if (hideMask.member(LA(1).getType())) {
+        if (p != null) {
+          p.setHiddenAfter(LA(1));
+          LA(1).setHiddenBefore(p); // double-link
+        }
+        p = LA(1);
+
+        lastHiddenToken = p;
+        if (firstHidden == null) {
+          firstHidden = p; // record hidden token if first
+        }
+      }
+      consume();
+    }
+  }
+
+  /** Return the next monitored token.
+   *  Test the token following the monitored token.
+   *  If following is another monitored token, save it
+   *  for the next invocation of nextToken (like a single
+   *  lookahead token) and return it then.
+   *  If following is unmonitored, nondiscarded (hidden)
+   *  channel token, add it to the monitored token.
+   *
+   *  Note: EOF must be a monitored Token.
+   */
+  public Token nextToken() throws TokenStreamException {
+    // handle an initial condition; don't want to get lookahead
+    // token of this splitter until first call to nextToken
+    if (LA(1) == null) {
+      consumeFirst();
+    }
+
+    //System.err.println();
+
+    // we always consume hidden tokens after monitored, thus,
+    // upon entry LA(1) is a monitored token.
+    CommonHiddenStreamToken monitored = LA(1);
+
+    // point to hidden tokens found during last invocation
+    monitored.setHiddenBefore(lastHiddenToken);
+    lastHiddenToken = null;
+
+    // Look for hidden tokens, hook them into list emanating
+    // from the monitored tokens.
+    consume();
+    CommonHiddenStreamToken prev = monitored;
+
+    // deal with as many not-purely-monitored tokens as possible
+    while ( hideMask.member(LA(1).getType()) ||
+            discardMask.member(LA(1).getType()) ||
+            copyMask.member(LA(1).getType()) ) {
+
+      if (copyMask.member(LA(1).getType())) {
+
+        // copy the token and link it backwards
+        if (hiddenCopy != null) {
+          linkAndCopyToken(hiddenCopy, monitored);
+        } else {
+          linkAndCopyToken(prev, monitored);
+        }
+
+        // we now need to parse it as a monitored token, so we return, which
+        // avoids the consume() call at the end of this loop.  the next call
+        // will parse it as a monitored token.
+        //System.err.println("returned: " + monitored.toString());
+        return monitored;
+
+      } else if (hideMask.member(LA(1).getType())) {
+
+        // attach the hidden token to the monitored in a chain
+        // link forwards
+        prev.setHiddenAfter(LA(1));
+
+        // link backwards
+        if (prev != monitored) { //hidden cannot point to monitored tokens
+          LA(1).setHiddenBefore(prev);
+        } else if (hiddenCopy != null) {
+          hiddenCopy.setHiddenAfter(LA(1));
+          LA(1).setHiddenBefore(hiddenCopy);
+          hiddenCopy = null;
+        }
+
+        //System.err.println("hidden: " + prev.getHiddenAfter().toString() + "\" after: " + prev.toString());
+        prev = lastHiddenToken = LA(1);
+      }
+
+      consume();
+    }
+
+    // remember the last hidden token for next time around
+    if (hiddenCopy != null) {
+      lastHiddenToken = hiddenCopy;
+      hiddenCopy = null;
+    }
+
+    //System.err.println("returned: " + monitored.toString());
+    return monitored;
+  }
+}
diff --git a/app/preproc/clean.sh b/app/preproc/clean.sh
new file mode 100755
index 000000000..a3db270b2
--- /dev/null
+++ b/app/preproc/clean.sh
@@ -0,0 +1,11 @@
+#!/bin/sh
+
+rm -f *Lexer.java
+rm -f *Recognizer.java
+rm -f *TokenTypes.java
+rm -f *TokenTypes.txt
+rm -f *TreeParser.java
+rm -f *TreeParserTokenTypes.java
+rm -f *TreeParserTokenTypes.txt
+rm -f expanded*.g
+
diff --git a/app/preproc/java.g b/app/preproc/java.g
new file mode 100644
index 000000000..601fb7330
--- /dev/null
+++ b/app/preproc/java.g
@@ -0,0 +1,1276 @@
+header {
+package antlr.java;
+}
+
+/** Java 1.3 Recognizer
+ *
+ * Run 'java Main [-showtree] directory-full-of-java-files'
+ *
+ * [The -showtree option pops up a Swing frame that shows
+ *  the AST constructed from the parser.]
+ *
+ * Run 'java Main <directory full of java files>'
+ *
+ * Contributing authors:
+ *		John Mitchell		johnm@non.net
+ *		Terence Parr		parrt@magelang.com
+ *		John Lilley			jlilley@empathy.com
+ *		Scott Stanchfield	thetick@magelang.com
+ *		Markus Mohnen       mohnen@informatik.rwth-aachen.de
+ *      Peter Williams      pete.williams@sun.com
+ *      Allan Jacobs        Allan.Jacobs@eng.sun.com
+ *      Steve Messick       messick@redhills.com
+ *      John Pybus			john@pybus.org
+ *
+ * Version 1.00 December 9, 1997 -- initial release
+ * Version 1.01 December 10, 1997
+ *		fixed bug in octal def (0..7 not 0..8)
+ * Version 1.10 August 1998 (parrt)
+ *		added tree construction
+ *		fixed definition of WS,comments for mac,pc,unix newlines
+ *		added unary plus
+ * Version 1.11 (Nov 20, 1998)
+ *		Added "shutup" option to turn off last ambig warning.
+ *		Fixed inner class def to allow named class defs as statements
+ *		synchronized requires compound not simple statement
+ *		add [] after builtInType DOT class in primaryExpression
+ *		"const" is reserved but not valid..removed from modifiers
+ * Version 1.12 (Feb 2, 1999)
+ *		Changed LITERAL_xxx to xxx in tree grammar.
+ *		Updated java.g to use tokens {...} now for 2.6.0 (new feature).
+ *
+ * Version 1.13 (Apr 23, 1999)
+ *		Didn't have (stat)? for else clause in tree parser.
+ *		Didn't gen ASTs for interface extends.  Updated tree parser too.
+ *		Updated to 2.6.0.
+ * Version 1.14 (Jun 20, 1999)
+ *		Allowed final/abstract on local classes.
+ *		Removed local interfaces from methods
+ *		Put instanceof precedence where it belongs...in relationalExpr
+ *			It also had expr not type as arg; fixed it.
+ *		Missing ! on SEMI in classBlock
+ *		fixed: (expr) + "string" was parsed incorrectly (+ as unary plus).
+ *		fixed: didn't like Object[].class in parser or tree parser
+ * Version 1.15 (Jun 26, 1999)
+ *		Screwed up rule with instanceof in it. :(  Fixed.
+ *		Tree parser didn't like (expr).something; fixed.
+ *		Allowed multiple inheritance in tree grammar. oops.
+ * Version 1.16 (August 22, 1999)
+ *		Extending an interface built a wacky tree: had extra EXTENDS.
+ *		Tree grammar didn't allow multiple superinterfaces.
+ *		Tree grammar didn't allow empty var initializer: {}
+ * Version 1.17 (October 12, 1999)
+ *		ESC lexer rule allowed 399 max not 377 max.
+ *		java.tree.g didn't handle the expression of synchronized
+ *		statements.
+ * Version 1.18 (August 12, 2001)
+ *      	Terence updated to Java 2 Version 1.3 by
+ *		observing/combining work of Allan Jacobs and Steve
+ *		Messick.  Handles 1.3 src.  Summary:
+ *		o  primary didn't include boolean.class kind of thing
+ *      	o  constructor calls parsed explicitly now:
+ * 		   see explicitConstructorInvocation
+ *		o  add strictfp modifier
+ *      	o  missing objBlock after new expression in tree grammar
+ *		o  merged local class definition alternatives, moved after declaration
+ *		o  fixed problem with ClassName.super.field
+ *      	o  reordered some alternatives to make things more efficient
+ *		o  long and double constants were not differentiated from int/float
+ *		o  whitespace rule was inefficient: matched only one char
+ *		o  add an examples directory with some nasty 1.3 cases
+ *		o  made Main.java use buffered IO and a Reader for Unicode support
+ *		o  supports UNICODE?
+ *		   Using Unicode charVocabulay makes code file big, but only
+ *		   in the bitsets at the end. I need to make ANTLR generate
+ *		   unicode bitsets more efficiently.
+ * Version 1.19 (April 25, 2002)
+ *		Terence added in nice fixes by John Pybus concerning floating
+ *		constants and problems with super() calls.  John did a nice
+ *		reorg of the primary/postfix expression stuff to read better
+ *		and makes f.g.super() parse properly (it was METHOD_CALL not
+ *		a SUPER_CTOR_CALL).  Also:
+ *
+ *		o  "finally" clause was a root...made it a child of "try"
+ *		o  Added stuff for asserts too for Java 1.4, but *commented out*
+ *		   as it is not backward compatible.
+ *
+ * Version 1.20 (October 27, 2002)
+ *
+ *      Terence ended up reorging John Pybus' stuff to
+ *      remove some nondeterminisms and some syntactic predicates.
+ *      Note that the grammar is stricter now; e.g., this(...) must
+ *	be the first statement.
+ *
+ *      Trinary ?: operator wasn't working as array name:
+ *          (isBig ? bigDigits : digits)[i];
+ *
+ *      Checked parser/tree parser on source for
+ *          Resin-2.0.5, jive-2.1.1, jdk 1.3.1, Lucene, antlr 2.7.2a4,
+ *	    and the 110k-line jGuru server source.
+ *
+ * This grammar is in the PUBLIC DOMAIN
+ */
+class JavaRecognizer extends Parser;
+options {
+	k = 2;                           // two token lookahead
+	exportVocab=Java;                // Call its vocabulary "Java"
+	codeGenMakeSwitchThreshold = 2;  // Some optimizations
+	codeGenBitsetTestThreshold = 3;
+	defaultErrorHandler = false;     // Don't generate parser error handlers
+	buildAST = true;
+}
+
+tokens {
+	BLOCK; MODIFIERS; OBJBLOCK; SLIST; CTOR_DEF; METHOD_DEF; VARIABLE_DEF;
+	INSTANCE_INIT; STATIC_INIT; TYPE; CLASS_DEF; INTERFACE_DEF;
+	PACKAGE_DEF; ARRAY_DECLARATOR; EXTENDS_CLAUSE; IMPLEMENTS_CLAUSE;
+	PARAMETERS; PARAMETER_DEF; LABELED_STAT; TYPECAST; INDEX_OP;
+	POST_INC; POST_DEC; METHOD_CALL; EXPR; ARRAY_INIT;
+	IMPORT; UNARY_MINUS; UNARY_PLUS; CASE_GROUP; ELIST; FOR_INIT; FOR_CONDITION;
+	FOR_ITERATOR; EMPTY_STAT; FINAL="final"; ABSTRACT="abstract";
+	STRICTFP="strictfp"; SUPER_CTOR_CALL; CTOR_CALL;
+}
+
+// Compilation Unit: In Java, this is a single file.  This is the start
+//   rule for this parser
+compilationUnit
+	:	// A compilation unit starts with an optional package definition
+		(	packageDefinition
+		|	/* nothing */
+		)
+
+		// Next we have a series of zero or more import statements
+		( importDefinition )*
+
+		// Wrapping things up with any number of class or interface
+		//    definitions
+		( typeDefinition )*
+
+		EOF!
+	;
+
+
+// Package statement: "package" followed by an identifier.
+packageDefinition
+	options {defaultErrorHandler = true;} // let ANTLR handle errors
+	:	p:"package"^ {#p.setType(PACKAGE_DEF);} identifier SEMI!
+	;
+
+
+// Import statement: import followed by a package or class name
+importDefinition
+	options {defaultErrorHandler = true;}
+	:	i:"import"^ {#i.setType(IMPORT);} identifierStar SEMI!
+	;
+
+// A type definition in a file is either a class or interface definition.
+typeDefinition
+	options {defaultErrorHandler = true;}
+	:	m:modifiers!
+		( classDefinition[#m]
+		| interfaceDefinition[#m]
+		)
+	|	SEMI!
+	;
+
+/** A declaration is the creation of a reference or primitive-type variable
+ *  Create a separate Type/Var tree for each var in the var list.
+ */
+declaration!
+	:	m:modifiers t:typeSpec[false] v:variableDefinitions[#m,#t]
+		{#declaration = #v;}
+	;
+
+// A type specification is a type name with possible brackets afterwards
+//   (which would make it an array type).
+typeSpec[boolean addImagNode]
+	: classTypeSpec[addImagNode]
+	| builtInTypeSpec[addImagNode]
+	;
+
+// A class type specification is a class type with possible brackets afterwards
+//   (which would make it an array type).
+classTypeSpec[boolean addImagNode]
+	:	identifier (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+		{
+			if ( addImagNode ) {
+				#classTypeSpec = #(#[TYPE,"TYPE"], #classTypeSpec);
+			}
+		}
+	;
+
+// A builtin type specification is a builtin type with possible brackets
+// afterwards (which would make it an array type).
+builtInTypeSpec[boolean addImagNode]
+	:	builtInType (lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+		{
+			if ( addImagNode ) {
+				#builtInTypeSpec = #(#[TYPE,"TYPE"], #builtInTypeSpec);
+			}
+		}
+	;
+
+// A type name. which is either a (possibly qualified) class name or
+//   a primitive (builtin) type
+type
+	:	identifier
+	|	builtInType
+	;
+
+// The primitive types.
+builtInType
+	:	"void"
+	|	"boolean"
+	|	"byte"
+	|	"char"
+	|	"short"
+	|	"int"
+	|	"float"
+	|	"long"
+	|	"double"
+	;
+
+// A (possibly-qualified) java identifier.  We start with the first IDENT
+//   and expand its name by adding dots and following IDENTS
+identifier
+	:	IDENT  ( DOT^ IDENT )*
+	;
+
+identifierStar
+	:	IDENT
+		( DOT^ IDENT )*
+		( DOT^ STAR  )?
+	;
+
+// A list of zero or more modifiers.  We could have used (modifier)* in
+//   place of a call to modifiers, but I thought it was a good idea to keep
+//   this rule separate so they can easily be collected in a Vector if
+//   someone so desires
+modifiers
+	:	( modifier )*
+		{#modifiers = #([MODIFIERS, "MODIFIERS"], #modifiers);}
+	;
+
+// modifiers for Java classes, interfaces, class/instance vars and methods
+modifier
+	:	"private"
+	|	"public"
+	|	"protected"
+	|	"static"
+	|	"transient"
+	|	"final"
+	|	"abstract"
+	|	"native"
+	|	"threadsafe"
+	|	"synchronized"
+//	|	"const"			// reserved word, but not valid
+	|	"volatile"
+	|	"strictfp"
+	;
+
+// Definition of a Java class
+classDefinition![AST modifiers]
+	:	"class" IDENT
+		// it _might_ have a superclass...
+		sc:superClassClause
+		// it might implement some interfaces...
+		ic:implementsClause
+		// now parse the body of the class
+		cb:classBlock
+		{#classDefinition = #(#[CLASS_DEF,"CLASS_DEF"],
+							   modifiers,IDENT,sc,ic,cb);}
+	;
+
+superClassClause!
+	:	( "extends" id:identifier )?
+		{#superClassClause = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],id);}
+	;
+
+// Definition of a Java Interface
+interfaceDefinition![AST modifiers]
+	:	"interface" IDENT
+		// it might extend some other interfaces
+		ie:interfaceExtends
+		// now parse the body of the interface (looks like a class...)
+		cb:classBlock
+		{#interfaceDefinition = #(#[INTERFACE_DEF,"INTERFACE_DEF"],
+									modifiers,IDENT,ie,cb);}
+	;
+
+
+// This is the body of a class.  You can have fields and extra semicolons,
+// That's about it (until you see what a field is...)
+classBlock
+	:	LCURLY!
+			( field | SEMI! )*
+		RCURLY!
+		{#classBlock = #([OBJBLOCK, "OBJBLOCK"], #classBlock);}
+	;
+
+// An interface can extend several other interfaces...
+interfaceExtends
+	:	(
+		e:"extends"!
+		identifier ( COMMA! identifier )*
+		)?
+		{#interfaceExtends = #(#[EXTENDS_CLAUSE,"EXTENDS_CLAUSE"],
+							#interfaceExtends);}
+	;
+
+// A class can implement several interfaces...
+implementsClause
+	:	(
+			i:"implements"! identifier ( COMMA! identifier )*
+		)?
+		{#implementsClause = #(#[IMPLEMENTS_CLAUSE,"IMPLEMENTS_CLAUSE"],
+								 #implementsClause);}
+	;
+
+// Now the various things that can be defined inside a class or interface...
+// Note that not all of these are really valid in an interface (constructors,
+//   for example), and if this grammar were used for a compiler there would
+//   need to be some semantic checks to make sure we're doing the right thing...
+field!
+	:	// method, constructor, or variable declaration
+		mods:modifiers
+		(	h:ctorHead s:constructorBody // constructor
+			{#field = #(#[CTOR_DEF,"CTOR_DEF"], mods, h, s);}
+
+		|	cd:classDefinition[#mods]       // inner class
+			{#field = #cd;}
+
+		|	id:interfaceDefinition[#mods]   // inner interface
+			{#field = #id;}
+
+		|	t:typeSpec[false]  // method or variable declaration(s)
+			(	IDENT  // the name of the method
+
+				// parse the formal parameter declarations.
+				LPAREN! param:parameterDeclarationList RPAREN!
+
+				rt:declaratorBrackets[#t]
+
+				// get the list of exceptions that this method is
+				// declared to throw
+				(tc:throwsClause)?
+
+				( s2:compoundStatement | SEMI )
+				{#field = #(#[METHOD_DEF,"METHOD_DEF"],
+						     mods,
+							 #(#[TYPE,"TYPE"],rt),
+							 IDENT,
+							 param,
+							 tc,
+							 s2);}
+			|	v:variableDefinitions[#mods,#t] SEMI
+//				{#field = #(#[VARIABLE_DEF,"VARIABLE_DEF"], v);}
+				{#field = #v;}
+			)
+		)
+
+    // "static { ... }" class initializer
+	|	"static" s3:compoundStatement
+		{#field = #(#[STATIC_INIT,"STATIC_INIT"], s3);}
+
+    // "{ ... }" instance initializer
+	|	s4:compoundStatement
+		{#field = #(#[INSTANCE_INIT,"INSTANCE_INIT"], s4);}
+	;
+
+constructorBody
+    :   lc:LCURLY^ {#lc.setType(SLIST);}
+            ( options { greedy=true; } : explicitConstructorInvocation)?
+            (statement)*
+        RCURLY!
+    ;
+
+/** Catch obvious constructor calls, but not the expr.super(...) calls */
+explicitConstructorInvocation
+    :   "this"! lp1:LPAREN^ argList RPAREN! SEMI!
+		{#lp1.setType(CTOR_CALL);}
+    |   "super"! lp2:LPAREN^ argList RPAREN! SEMI!
+		{#lp2.setType(SUPER_CTOR_CALL);}
+    ;
+
+variableDefinitions[AST mods, AST t]
+	:	variableDeclarator[getASTFactory().dupTree(mods),
+						   getASTFactory().dupTree(t)]
+		(	COMMA!
+			variableDeclarator[getASTFactory().dupTree(mods),
+							   getASTFactory().dupTree(t)]
+		)*
+	;
+
+/** Declaration of a variable.  This can be a class/instance variable,
+ *   or a local variable in a method
+ * It can also include possible initialization.
+ */
+variableDeclarator![AST mods, AST t]
+	:	id:IDENT d:declaratorBrackets[t] v:varInitializer
+		{#variableDeclarator = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, #(#[TYPE,"TYPE"],d), id, v);}
+	;
+
+declaratorBrackets[AST typ]
+	:	{#declaratorBrackets=typ;}
+		(lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+	;
+
+varInitializer
+	:	( ASSIGN^ initializer )?
+	;
+
+// This is an initializer used to set up an array.
+arrayInitializer
+	:	lc:LCURLY^ {#lc.setType(ARRAY_INIT);}
+			(	initializer
+				(
+					// CONFLICT: does a COMMA after an initializer start a new
+					//           initializer or start the option ',' at end?
+					//           ANTLR generates proper code by matching
+					//			 the comma as soon as possible.
+					options {
+						warnWhenFollowAmbig = false;
+					}
+				:
+					COMMA! initializer
+				)*
+				(COMMA!)?
+			)?
+		RCURLY!
+	;
+
+
+// The two "things" that can initialize an array element are an expression
+//   and another (nested) array initializer.
+initializer
+	:	expression
+	|	arrayInitializer
+	;
+
+// This is the header of a method.  It includes the name and parameters
+//   for the method.
+//   This also watches for a list of exception classes in a "throws" clause.
+ctorHead
+	:	IDENT  // the name of the method
+
+		// parse the formal parameter declarations.
+		LPAREN! parameterDeclarationList RPAREN!
+
+		// get the list of exceptions that this method is declared to throw
+		(throwsClause)?
+	;
+
+// This is a list of exception classes that the method is declared to throw
+throwsClause
+	:	"throws"^ identifier ( COMMA! identifier )*
+	;
+
+
+// A list of formal parameters
+parameterDeclarationList
+	:	( parameterDeclaration ( COMMA! parameterDeclaration )* )?
+		{#parameterDeclarationList = #(#[PARAMETERS,"PARAMETERS"],
+									#parameterDeclarationList);}
+	;
+
+// A formal parameter.
+parameterDeclaration!
+	:	pm:parameterModifier t:typeSpec[false] id:IDENT
+		pd:declaratorBrackets[#t]
+		{#parameterDeclaration = #(#[PARAMETER_DEF,"PARAMETER_DEF"],
+									pm, #([TYPE,"TYPE"],pd), id);}
+	;
+
+parameterModifier
+	:	(f:"final")?
+		{#parameterModifier = #(#[MODIFIERS,"MODIFIERS"], f);}
+	;
+
+// Compound statement.  This is used in many contexts:
+//   Inside a class definition prefixed with "static":
+//      it is a class initializer
+//   Inside a class definition without "static":
+//      it is an instance initializer
+//   As the body of a method
+//   As a completely indepdent braced block of code inside a method
+//      it starts a new scope for variable definitions
+
+compoundStatement
+	:	lc:LCURLY^ {#lc.setType(SLIST);}
+			// include the (possibly-empty) list of statements
+			(statement)*
+		RCURLY!
+	;
+
+
+statement
+	// A list of statements in curly braces -- start a new scope!
+	:	compoundStatement
+
+	// declarations are ambiguous with "ID DOT" relative to expression
+	// statements.  Must backtrack to be sure.  Could use a semantic
+	// predicate to test symbol table to see what the type was coming
+	// up, but that's pretty hard without a symbol table ;)
+	|	(declaration)=> declaration SEMI!
+
+	// An expression statement.  This could be a method call,
+	// assignment statement, or any other expression evaluated for
+	// side-effects.
+	|	expression SEMI!
+
+	// class definition
+	|	m:modifiers! classDefinition[#m]
+
+	// Attach a label to the front of a statement
+	|	IDENT c:COLON^ {#c.setType(LABELED_STAT);} statement
+
+	// If-else statement
+	|	"if"^ LPAREN! expression RPAREN! statement
+		(
+			// CONFLICT: the old "dangling-else" problem...
+			//           ANTLR generates proper code matching
+			//			 as soon as possible.  Hush warning.
+			options {
+				warnWhenFollowAmbig = false;
+			}
+		:
+			"else"! statement
+		)?
+
+	// For statement
+	|	"for"^
+			LPAREN!
+				forInit SEMI!   // initializer
+				forCond	SEMI!   // condition test
+				forIter         // updater
+			RPAREN!
+			statement                     // statement to loop over
+
+	// While statement
+	|	"while"^ LPAREN! expression RPAREN! statement
+
+	// do-while statement
+	|	"do"^ statement "while"! LPAREN! expression RPAREN! SEMI!
+
+	// get out of a loop (or switch)
+	|	"break"^ (IDENT)? SEMI!
+
+	// do next iteration of a loop
+	|	"continue"^ (IDENT)? SEMI!
+
+	// Return an expression
+	|	"return"^ (expression)? SEMI!
+
+	// switch/case statement
+	|	"switch"^ LPAREN! expression RPAREN! LCURLY!
+			( casesGroup )*
+		RCURLY!
+
+	// exception try-catch block
+	|	tryBlock
+
+	// throw an exception
+	|	"throw"^ expression SEMI!
+
+	// synchronize a statement
+	|	"synchronized"^ LPAREN! expression RPAREN! compoundStatement
+
+	// asserts (uncomment if you want 1.4 compatibility)
+	|	"assert"^ expression ( COLON! expression )? SEMI!
+
+	// empty statement
+	|	s:SEMI {#s.setType(EMPTY_STAT);}
+	;
+
+casesGroup
+	:	(	// CONFLICT: to which case group do the statements bind?
+			//           ANTLR generates proper code: it groups the
+			//           many "case"/"default" labels together then
+			//           follows them with the statements
+			options {
+				greedy = true;
+			}
+			:
+			aCase
+		)+
+		caseSList
+		{#casesGroup = #([CASE_GROUP, "CASE_GROUP"], #casesGroup);}
+	;
+
+aCase
+	:	("case"^ expression | "default") COLON!
+	;
+
+caseSList
+	:	(statement)*
+		{#caseSList = #(#[SLIST,"SLIST"],#caseSList);}
+	;
+
+// The initializer for a for loop
+forInit
+		// if it looks like a declaration, it is
+	:	(	(declaration)=> declaration
+		// otherwise it could be an expression list...
+		|	expressionList
+		)?
+		{#forInit = #(#[FOR_INIT,"FOR_INIT"],#forInit);}
+	;
+
+forCond
+	:	(expression)?
+		{#forCond = #(#[FOR_CONDITION,"FOR_CONDITION"],#forCond);}
+	;
+
+forIter
+	:	(expressionList)?
+		{#forIter = #(#[FOR_ITERATOR,"FOR_ITERATOR"],#forIter);}
+	;
+
+// an exception handler try/catch block
+tryBlock
+	:	"try"^ compoundStatement
+		(handler)*
+		( finallyClause )?
+	;
+
+finallyClause
+	:	"finally"^ compoundStatement
+	;
+
+// an exception handler
+handler
+	:	"catch"^ LPAREN! parameterDeclaration RPAREN! compoundStatement
+	;
+
+
+// expressions
+// Note that most of these expressions follow the pattern
+//   thisLevelExpression :
+//       nextHigherPrecedenceExpression
+//           (OPERATOR nextHigherPrecedenceExpression)*
+// which is a standard recursive definition for a parsing an expression.
+// The operators in java have the following precedences:
+//    lowest  (13)  = *= /= %= += -= <<= >>= >>>= &= ^= |=
+//            (12)  ?:
+//            (11)  ||
+//            (10)  &&
+//            ( 9)  |
+//            ( 8)  ^
+//            ( 7)  &
+//            ( 6)  == !=
+//            ( 5)  < <= > >=
+//            ( 4)  << >>
+//            ( 3)  +(binary) -(binary)
+//            ( 2)  * / %
+//            ( 1)  ++ -- +(unary) -(unary)  ~  !  (type)
+//                  []   () (method call)  . (dot -- identifier qualification)
+//                  new   ()  (explicit parenthesis)
+//
+// the last two are not usually on a precedence chart; I put them in
+// to point out that new has a higher precedence than '.', so you
+// can validy use
+//     new Frame().show()
+//
+// Note that the above precedence levels map to the rules below...
+// Once you have a precedence chart, writing the appropriate rules as below
+//   is usually very straightfoward
+
+
+
+// the mother of all expressions
+expression
+	:	assignmentExpression
+		{#expression = #(#[EXPR,"EXPR"],#expression);}
+	;
+
+
+// This is a list of expressions.
+expressionList
+	:	expression (COMMA! expression)*
+		{#expressionList = #(#[ELIST,"ELIST"], expressionList);}
+	;
+
+
+// assignment expression (level 13)
+assignmentExpression
+	:	conditionalExpression
+		(	(	ASSIGN^
+            |   PLUS_ASSIGN^
+            |   MINUS_ASSIGN^
+            |   STAR_ASSIGN^
+            |   DIV_ASSIGN^
+            |   MOD_ASSIGN^
+            |   SR_ASSIGN^
+            |   BSR_ASSIGN^
+            |   SL_ASSIGN^
+            |   BAND_ASSIGN^
+            |   BXOR_ASSIGN^
+            |   BOR_ASSIGN^
+            )
+			assignmentExpression
+		)?
+	;
+
+
+// conditional test (level 12)
+conditionalExpression
+	:	logicalOrExpression
+		( QUESTION^ assignmentExpression COLON! conditionalExpression )?
+	;
+
+
+// logical or (||)  (level 11)
+logicalOrExpression
+	:	logicalAndExpression (LOR^ logicalAndExpression)*
+	;
+
+
+// logical and (&&)  (level 10)
+logicalAndExpression
+	:	inclusiveOrExpression (LAND^ inclusiveOrExpression)*
+	;
+
+
+// bitwise or non-short-circuiting or (|)  (level 9)
+inclusiveOrExpression
+	:	exclusiveOrExpression (BOR^ exclusiveOrExpression)*
+	;
+
+
+// exclusive or (^)  (level 8)
+exclusiveOrExpression
+	:	andExpression (BXOR^ andExpression)*
+	;
+
+
+// bitwise or non-short-circuiting and (&)  (level 7)
+andExpression
+	:	equalityExpression (BAND^ equalityExpression)*
+	;
+
+
+// equality/inequality (==/!=) (level 6)
+equalityExpression
+	:	relationalExpression ((NOT_EQUAL^ | EQUAL^) relationalExpression)*
+	;
+
+
+// boolean relational expressions (level 5)
+relationalExpression
+	:	shiftExpression
+		(	(	(	LT^
+				|	GT^
+				|	LE^
+				|	GE^
+				)
+				shiftExpression
+			)*
+		|	"instanceof"^ typeSpec[true]
+		)
+	;
+
+
+// bit shift expressions (level 4)
+shiftExpression
+	:	additiveExpression ((SL^ | SR^ | BSR^) additiveExpression)*
+	;
+
+
+// binary addition/subtraction (level 3)
+additiveExpression
+	:	multiplicativeExpression ((PLUS^ | MINUS^) multiplicativeExpression)*
+	;
+
+
+// multiplication/division/modulo (level 2)
+multiplicativeExpression
+	:	unaryExpression ((STAR^ | DIV^ | MOD^ ) unaryExpression)*
+	;
+
+unaryExpression
+	:	INC^ unaryExpression
+	|	DEC^ unaryExpression
+	|	MINUS^ {#MINUS.setType(UNARY_MINUS);} unaryExpression
+	|	PLUS^  {#PLUS.setType(UNARY_PLUS);} unaryExpression
+	|	unaryExpressionNotPlusMinus
+	;
+
+unaryExpressionNotPlusMinus
+	:	BNOT^ unaryExpression
+	|	LNOT^ unaryExpression
+
+	|	(	// subrule allows option to shut off warnings
+			options {
+				// "(int" ambig with postfixExpr due to lack of sequence
+				// info in linear approximate LL(k).  It's ok.  Shut up.
+				generateAmbigWarnings=false;
+			}
+		:	// If typecast is built in type, must be numeric operand
+			// Also, no reason to backtrack if type keyword like int, float...
+			lpb:LPAREN^ {#lpb.setType(TYPECAST);} builtInTypeSpec[true] RPAREN!
+			unaryExpression
+
+			// Have to backtrack to see if operator follows.  If no operator
+			// follows, it's a typecast.  No semantic checking needed to parse.
+			// if it _looks_ like a cast, it _is_ a cast; else it's a "(expr)"
+		|	(LPAREN classTypeSpec[true] RPAREN unaryExpressionNotPlusMinus)=>
+			lp:LPAREN^ {#lp.setType(TYPECAST);} classTypeSpec[true] RPAREN!
+			unaryExpressionNotPlusMinus
+
+		|	postfixExpression
+		)
+	;
+
+// qualified names, array expressions, method invocation, post inc/dec
+postfixExpression
+	:
+    /*
+    "this"! lp1:LPAREN^ argList RPAREN!
+		{#lp1.setType(CTOR_CALL);}
+
+    |   "super"! lp2:LPAREN^ argList RPAREN!
+		{#lp2.setType(SUPER_CTOR_CALL);}
+    |
+    */
+        primaryExpression
+
+		(
+            /*
+            options {
+				// the use of postfixExpression in SUPER_CTOR_CALL adds DOT
+				// to the lookahead set, and gives loads of false non-det
+				// warnings.
+				// shut them off.
+				generateAmbigWarnings=false;
+			}
+		:	*/
+            DOT^ IDENT
+			(	lp:LPAREN^ {#lp.setType(METHOD_CALL);}
+				argList
+				RPAREN!
+			)?
+		|	DOT^ "this"
+
+		|	DOT^ "super"
+            (   // (new Outer()).super()  (create enclosing instance)
+                lp3:LPAREN^ argList RPAREN!
+                {#lp3.setType(SUPER_CTOR_CALL);}
+			|   DOT^ IDENT
+                (	lps:LPAREN^ {#lps.setType(METHOD_CALL);}
+                    argList
+                    RPAREN!
+                )?
+            )
+		|	DOT^ newExpression
+		|	lb:LBRACK^ {#lb.setType(INDEX_OP);} expression RBRACK!
+		)*
+
+		(   // possibly add on a post-increment or post-decrement.
+            // allows INC/DEC on too much, but semantics can check
+			in:INC^ {#in.setType(POST_INC);}
+	 	|	de:DEC^ {#de.setType(POST_DEC);}
+		)?
+ 	;
+
+// the basic element of an expression
+primaryExpression
+	:	identPrimary ( options {greedy=true;} : DOT^ "class" )?
+    |   constant
+	|	"true"
+	|	"false"
+	|	"null"
+    |   newExpression
+	|	"this"
+	|	"super"
+	|	LPAREN! assignmentExpression RPAREN!
+		// look for int.class and int[].class
+	|	builtInType
+		( lbt:LBRACK^ {#lbt.setType(ARRAY_DECLARATOR);} RBRACK! )*
+		DOT^ "class"
+	;
+
+/** Match a, a.b.c refs, a.b.c(...) refs, a.b.c[], a.b.c[].class,
+ *  and a.b.c.class refs.  Also this(...) and super(...).  Match
+ *  this or super.
+ */
+identPrimary
+	:	IDENT
+		(
+            options {
+				// .ident could match here or in postfixExpression.
+				// We do want to match here.  Turn off warning.
+				greedy=true;
+			}
+		:	DOT^ IDENT
+		)*
+		(
+            options {
+				// ARRAY_DECLARATOR here conflicts with INDEX_OP in
+				// postfixExpression on LBRACK RBRACK.
+				// We want to match [] here, so greedy.  This overcomes
+                // limitation of linear approximate lookahead.
+				greedy=true;
+		    }
+		:   ( lp:LPAREN^ {#lp.setType(METHOD_CALL);} argList RPAREN! )
+		|	( options {greedy=true;} :
+              lbc:LBRACK^ {#lbc.setType(ARRAY_DECLARATOR);} RBRACK!
+            )+
+		)?
+    ;
+
+/** object instantiation.
+ *  Trees are built as illustrated by the following input/tree pairs:
+ *
+ *  new T()
+ *
+ *  new
+ *   |
+ *   T --  ELIST
+ *           |
+ *          arg1 -- arg2 -- .. -- argn
+ *
+ *  new int[]
+ *
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR
+ *
+ *  new int[] {1,2}
+ *
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR -- ARRAY_INIT
+ *                                  |
+ *                                EXPR -- EXPR
+ *                                  |      |
+ *                                  1      2
+ *
+ *  new int[3]
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR
+ *                |
+ *              EXPR
+ *                |
+ *                3
+ *
+ *  new int[1][2]
+ *
+ *  new
+ *   |
+ *  int -- ARRAY_DECLARATOR
+ *               |
+ *         ARRAY_DECLARATOR -- EXPR
+ *               |              |
+ *             EXPR             1
+ *               |
+ *               2
+ *
+ */
+newExpression
+	:	"new"^ type
+		(	LPAREN! argList RPAREN! (classBlock)?
+
+			//java 1.1
+			// Note: This will allow bad constructs like
+			//    new int[4][][3] {exp,exp}.
+			//    There needs to be a semantic check here...
+			// to make sure:
+			//   a) [ expr ] and [ ] are not mixed
+			//   b) [ expr ] and an init are not used together
+
+		|	newArrayDeclarator (arrayInitializer)?
+		)
+	;
+
+argList
+	:	(	expressionList
+		|	/*nothing*/
+			{#argList = #[ELIST,"ELIST"];}
+		)
+	;
+
+newArrayDeclarator
+	:	(
+			// CONFLICT:
+			// newExpression is a primaryExpression which can be
+			// followed by an array index reference.  This is ok,
+			// as the generated code will stay in this loop as
+			// long as it sees an LBRACK (proper behavior)
+			options {
+				warnWhenFollowAmbig = false;
+			}
+		:
+			lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);}
+				(expression)?
+			RBRACK!
+		)+
+	;
+
+constant
+	:	NUM_INT
+	|	CHAR_LITERAL
+	|	STRING_LITERAL
+	|	NUM_FLOAT
+	|	NUM_LONG
+	|	NUM_DOUBLE
+	;
+
+
+//----------------------------------------------------------------------------
+// The Java scanner
+//----------------------------------------------------------------------------
+class JavaLexer extends Lexer;
+
+options {
+	exportVocab=Java;      // call the vocabulary "Java"
+	testLiterals=false;    // don't automatically test for literals
+	k=4;                   // four characters of lookahead
+	charVocabulary='\u0003'..'\uFFFF';
+	// without inlining some bitset tests, couldn't do unicode;
+	// I need to make ANTLR generate smaller bitsets; see
+	// bottom of JavaLexer.java
+	codeGenBitsetTestThreshold=20;
+}
+
+
+
+// OPERATORS
+QUESTION		:	'?'		;
+LPAREN			:	'('		;
+RPAREN			:	')'		;
+LBRACK			:	'['		;
+RBRACK			:	']'		;
+LCURLY			:	'{'		;
+RCURLY			:	'}'		;
+COLON			:	':'		;
+COMMA			:	','		;
+//DOT			:	'.'		;
+ASSIGN			:	'='		;
+EQUAL			:	"=="	;
+LNOT			:	'!'		;
+BNOT			:	'~'		;
+NOT_EQUAL		:	"!="	;
+DIV				:	'/'		;
+DIV_ASSIGN		:	"/="	;
+PLUS			:	'+'		;
+PLUS_ASSIGN		:	"+="	;
+INC				:	"++"	;
+MINUS			:	'-'		;
+MINUS_ASSIGN	:	"-="	;
+DEC				:	"--"	;
+STAR			:	'*'		;
+STAR_ASSIGN		:	"*="	;
+MOD				:	'%'		;
+MOD_ASSIGN		:	"%="	;
+SR				:	">>"	;
+SR_ASSIGN		:	">>="	;
+BSR				:	">>>"	;
+BSR_ASSIGN		:	">>>="	;
+GE				:	">="	;
+GT				:	">"		;
+SL				:	"<<"	;
+SL_ASSIGN		:	"<<="	;
+LE				:	"<="	;
+LT				:	'<'		;
+BXOR			:	'^'		;
+BXOR_ASSIGN		:	"^="	;
+BOR				:	'|'		;
+BOR_ASSIGN		:	"|="	;
+LOR				:	"||"	;
+BAND			:	'&'		;
+BAND_ASSIGN		:	"&="	;
+LAND			:	"&&"	;
+SEMI			:	';'		;
+
+
+// Whitespace -- ignored
+WS	:	(	' '
+		|	'\t'
+		|	'\f'
+			// handle newlines
+		|	(	options {generateAmbigWarnings=false;}
+			:	"\r\n"  // Evil DOS
+			|	'\r'    // Macintosh
+			|	'\n'    // Unix (the right way)
+			)
+			{ newline(); }
+		)+
+		{ _ttype = Token.SKIP; }
+	;
+
+// Single-line comments
+SL_COMMENT
+	:	"//"
+		(~('\n'|'\r'))* ('\n'|'\r'('\n')?)
+		{$setType(Token.SKIP); newline();}
+	;
+
+// multiple-line comments
+ML_COMMENT
+	:	"/*"
+		(	/*	'\r' '\n' can be matched in one alternative or by matching
+				'\r' in one iteration and '\n' in another.  I am trying to
+				handle any flavor of newline that comes in, but the language
+				that allows both "\r\n" and "\r" and "\n" to all be valid
+				newline is ambiguous.  Consequently, the resulting grammar
+				must be ambiguous.  I'm shutting this warning off.
+			 */
+			options {
+				generateAmbigWarnings=false;
+			}
+		:
+			{ LA(2)!='/' }? '*'
+		|	'\r' '\n'		{newline();}
+		|	'\r'			{newline();}
+		|	'\n'			{newline();}
+		|	~('*'|'\n'|'\r')
+		)*
+		"*/"
+		{$setType(Token.SKIP);}
+	;
+
+
+// character literals
+CHAR_LITERAL
+	:	'\'' ( ESC | ~'\'' ) '\''
+	;
+
+// string literals
+STRING_LITERAL
+	:	'"' (ESC|~('"'|'\\'))* '"'
+	;
+
+
+// escape sequence -- note that this is protected; it can only be called
+//   from another lexer rule -- it will not ever directly return a token to
+//   the parser
+// There are various ambiguities hushed in this rule.  The optional
+// '0'...'9' digit matches should be matched here rather than letting
+// them go back to STRING_LITERAL to be matched.  ANTLR does the
+// right thing by matching immediately; hence, it's ok to shut off
+// the FOLLOW ambig warnings.
+protected
+ESC
+	:	'\\'
+		(	'n'
+		|	'r'
+		|	't'
+		|	'b'
+		|	'f'
+		|	'"'
+		|	'\''
+		|	'\\'
+		|	('u')+ HEX_DIGIT HEX_DIGIT HEX_DIGIT HEX_DIGIT
+		|	'0'..'3'
+			(
+				options {
+					warnWhenFollowAmbig = false;
+				}
+			:	'0'..'7'
+				(
+					options {
+						warnWhenFollowAmbig = false;
+					}
+				:	'0'..'7'
+				)?
+			)?
+		|	'4'..'7'
+			(
+				options {
+					warnWhenFollowAmbig = false;
+				}
+			:	'0'..'7'
+			)?
+		)
+	;
+
+
+// hexadecimal digit (again, note it's protected!)
+protected
+HEX_DIGIT
+	:	('0'..'9'|'A'..'F'|'a'..'f')
+	;
+
+
+// a dummy rule to force vocabulary to be all characters (except special
+//   ones that ANTLR uses internally (0 to 2)
+protected
+VOCAB
+	:	'\3'..'\377'
+	;
+
+
+// an identifier.  Note that testLiterals is set to true!  This means
+// that after we match the rule, we look in the literals table to see
+// if it's a literal or really an identifer
+IDENT
+	options {testLiterals=true;}
+	:	('a'..'z'|'A'..'Z'|'_'|'$') ('a'..'z'|'A'..'Z'|'_'|'0'..'9'|'$')*
+	;
+
+
+// a numeric literal
+NUM_INT
+	{boolean isDecimal=false; Token t=null;}
+    :   '.' {_ttype = DOT;}
+            (	('0'..'9')+ (EXPONENT)? (f1:FLOAT_SUFFIX {t=f1;})?
+                {
+				if (t != null && t.getText().toUpperCase().indexOf('F')>=0) {
+                	_ttype = NUM_FLOAT;
+				}
+				else {
+                	_ttype = NUM_DOUBLE; // assume double
+				}
+				}
+            )?
+
+	|	(	'0' {isDecimal = true;} // special case for just '0'
+			(	('x'|'X')
+				(											// hex
+					// the 'e'|'E' and float suffix stuff look
+					// like hex digits, hence the (...)+ doesn't
+					// know when to stop: ambig.  ANTLR resolves
+					// it correctly by matching immediately.  It
+					// is therefor ok to hush warning.
+					options {
+						warnWhenFollowAmbig=false;
+					}
+				:	HEX_DIGIT
+				)+
+			|	('0'..'7')+									// octal
+			)?
+		|	('1'..'9') ('0'..'9')*  {isDecimal=true;}		// non-zero decimal
+		)
+		(	('l'|'L') { _ttype = NUM_LONG; }
+
+		// only check to see if it's a float if looks like decimal so far
+		|	{isDecimal}?
+            (   '.' ('0'..'9')* (EXPONENT)? (f2:FLOAT_SUFFIX {t=f2;})?
+            |   EXPONENT (f3:FLOAT_SUFFIX {t=f3;})?
+            |   f4:FLOAT_SUFFIX {t=f4;}
+            )
+            {
+			if (t != null && t.getText().toUpperCase() .indexOf('F') >= 0) {
+                _ttype = NUM_FLOAT;
+			}
+            else {
+	           	_ttype = NUM_DOUBLE; // assume double
+			}
+			}
+        )?
+	;
+
+
+// a couple protected methods to assist in matching floating point numbers
+protected
+EXPONENT
+	:	('e'|'E') ('+'|'-')? ('0'..'9')+
+	;
+
+
+protected
+FLOAT_SUFFIX
+	:	'f'|'F'|'d'|'D'
+	;
+
diff --git a/app/preproc/java.tree.g b/app/preproc/java.tree.g
new file mode 100644
index 000000000..e995ef49d
--- /dev/null
+++ b/app/preproc/java.tree.g
@@ -0,0 +1,326 @@
+package antlr;
+
+
+/** Java 1.3 AST Recognizer Grammar
+ *
+ * Author: (see java.g preamble)
+ *
+ * This grammar is in the PUBLIC DOMAIN
+ */
+class JavaTreeParser extends TreeParser;
+
+options {
+	importVocab = Java;
+}
+
+compilationUnit
+	:	(packageDefinition)?
+		(importDefinition)*
+		(typeDefinition)*
+	;
+
+packageDefinition
+	:	#( PACKAGE_DEF identifier )
+	;
+
+importDefinition
+	:	#( IMPORT identifierStar )
+	;
+
+typeDefinition
+	:	#(CLASS_DEF modifiers IDENT extendsClause implementsClause objBlock )
+	|	#(INTERFACE_DEF modifiers IDENT extendsClause interfaceBlock )
+	;
+
+typeSpec
+	:	#(TYPE typeSpecArray)
+	;
+
+typeSpecArray
+	:	#( ARRAY_DECLARATOR typeSpecArray )
+	|	type
+	;
+
+type:	identifier
+	|	builtInType
+	;
+
+builtInType
+    :   "void"
+    |   "boolean"
+    |   "byte"
+    |   "char"
+    |   "short"
+    |   "int"
+    |   "float"
+    |   "long"
+    |   "double"
+    ;
+
+modifiers
+	:	#( MODIFIERS (modifier)* )
+	;
+
+modifier
+    :   "private"
+    |   "public"
+    |   "protected"
+    |   "static"
+    |   "transient"
+    |   "final"
+    |   "abstract"
+    |   "native"
+    |   "threadsafe"
+    |   "synchronized"
+    |   "const"
+    |   "volatile"
+	|	"strictfp"
+    ;
+
+extendsClause
+	:	#(EXTENDS_CLAUSE (identifier)* )
+	;
+
+implementsClause
+	:	#(IMPLEMENTS_CLAUSE (identifier)* )
+	;
+
+
+interfaceBlock
+	:	#(	OBJBLOCK
+			(	methodDecl
+			|	variableDef
+			)*
+		)
+	;
+
+objBlock
+	:	#(	OBJBLOCK
+			(	ctorDef
+			|	methodDef
+			|	variableDef
+			|	typeDefinition
+			|	#(STATIC_INIT slist)
+			|	#(INSTANCE_INIT slist)
+			)*
+		)
+	;
+
+ctorDef
+	:	#(CTOR_DEF modifiers methodHead (slist)?)
+	;
+
+methodDecl
+	:	#(METHOD_DEF modifiers typeSpec methodHead)
+	;
+
+methodDef
+	:	#(METHOD_DEF modifiers typeSpec methodHead (slist)?)
+	;
+
+variableDef
+	:	#(VARIABLE_DEF modifiers typeSpec variableDeclarator varInitializer)
+	;
+
+parameterDef
+	:	#(PARAMETER_DEF modifiers typeSpec IDENT )
+	;
+
+objectinitializer
+	:	#(INSTANCE_INIT slist)
+	;
+
+variableDeclarator
+	:	IDENT
+	|	LBRACK variableDeclarator
+	;
+
+varInitializer
+	:	#(ASSIGN initializer)
+	|
+	;
+
+initializer
+	:	expression
+	|	arrayInitializer
+	;
+
+arrayInitializer
+	:	#(ARRAY_INIT (initializer)*)
+	;
+
+methodHead
+	:	IDENT #( PARAMETERS (parameterDef)* ) (throwsClause)?
+	;
+
+throwsClause
+	:	#( "throws" (identifier)* )
+	;
+
+identifier
+	:	IDENT
+	|	#( DOT identifier IDENT )
+	;
+
+identifierStar
+	:	IDENT
+	|	#( DOT identifier (STAR|IDENT) )
+	;
+
+slist
+	:	#( SLIST (stat)* )
+	;
+
+stat:	typeDefinition
+	|	variableDef
+	|	expression
+	|	#(LABELED_STAT IDENT stat)
+	|	#("if" expression stat (stat)? )
+	|	#(	"for"
+			#(FOR_INIT (variableDef | elist)?)
+			#(FOR_CONDITION (expression)?)
+			#(FOR_ITERATOR (elist)?)
+			stat
+		)
+	|	#("while" expression stat)
+	|	#("do" stat expression)
+	|	#("break" (IDENT)? )
+	|	#("continue" (IDENT)? )
+	|	#("return" (expression)? )
+	|	#("switch" expression (caseGroup)*)
+	|	#("throw" expression)
+	|	#("synchronized" expression stat)
+	|	tryBlock
+	|	slist // nested SLIST
+    // uncomment to make assert JDK 1.4 stuff work
+    |   #("assert" expression (expression)?)
+	|	EMPTY_STAT
+	;
+
+caseGroup
+	:	#(CASE_GROUP (#("case" expression) | "default")+ slist)
+	;
+
+tryBlock
+	:	#( "try" slist (handler)* (#("finally" slist))? )
+	;
+
+handler
+	:	#( "catch" parameterDef slist )
+	;
+
+elist
+	:	#( ELIST (expression)* )
+	;
+
+expression
+	:	#(EXPR expr)
+	;
+
+expr:	#(QUESTION expr expr expr)	// trinary operator
+	|	#(ASSIGN expr expr)			// binary operators...
+	|	#(PLUS_ASSIGN expr expr)
+	|	#(MINUS_ASSIGN expr expr)
+	|	#(STAR_ASSIGN expr expr)
+	|	#(DIV_ASSIGN expr expr)
+	|	#(MOD_ASSIGN expr expr)
+	|	#(SR_ASSIGN expr expr)
+	|	#(BSR_ASSIGN expr expr)
+	|	#(SL_ASSIGN expr expr)
+	|	#(BAND_ASSIGN expr expr)
+	|	#(BXOR_ASSIGN expr expr)
+	|	#(BOR_ASSIGN expr expr)
+	|	#(LOR expr expr)
+	|	#(LAND expr expr)
+	|	#(BOR expr expr)
+	|	#(BXOR expr expr)
+	|	#(BAND expr expr)
+	|	#(NOT_EQUAL expr expr)
+	|	#(EQUAL expr expr)
+	|	#(LT expr expr)
+	|	#(GT expr expr)
+	|	#(LE expr expr)
+	|	#(GE expr expr)
+	|	#(SL expr expr)
+	|	#(SR expr expr)
+	|	#(BSR expr expr)
+	|	#(PLUS expr expr)
+	|	#(MINUS expr expr)
+	|	#(DIV expr expr)
+	|	#(MOD expr expr)
+	|	#(STAR expr expr)
+	|	#(INC expr)
+	|	#(DEC expr)
+	|	#(POST_INC expr)
+	|	#(POST_DEC expr)
+	|	#(BNOT expr)
+	|	#(LNOT expr)
+	|	#("instanceof" expr expr)
+	|	#(UNARY_MINUS expr)
+	|	#(UNARY_PLUS expr)
+	|	primaryExpression
+	;
+
+primaryExpression
+    :   IDENT
+    |   #(	DOT
+			(	expr
+				(	IDENT
+				|	arrayIndex
+				|	"this"
+				|	"class"
+				|	#( "new" IDENT elist )
+				|   "super"
+				)
+			|	#(ARRAY_DECLARATOR typeSpecArray)
+			|	builtInType ("class")?
+			)
+		)
+	|	arrayIndex
+	|	#(METHOD_CALL primaryExpression elist)
+	|	ctorCall
+	|	#(TYPECAST typeSpec expr)
+	|   newExpression
+	|   constant
+    |   "super"
+    |   "true"
+    |   "false"
+    |   "this"
+    |   "null"
+	|	typeSpec // type name used with instanceof
+	;
+
+ctorCall
+	:	#( CTOR_CALL elist )
+	|	#( SUPER_CTOR_CALL
+			(	elist
+			|	primaryExpression elist
+			)
+		 )
+	;
+
+arrayIndex
+	:	#(INDEX_OP expr expression)
+	;
+
+constant
+    :   NUM_INT
+    |   CHAR_LITERAL
+    |   STRING_LITERAL
+    |   NUM_FLOAT
+    |   NUM_DOUBLE
+    |   NUM_LONG
+    ;
+
+newExpression
+	:	#(	"new" type
+			(	newArrayDeclarator (arrayInitializer)?
+			|	elist (objBlock)?
+			)
+		)
+
+	;
+
+newArrayDeclarator
+	:	#( ARRAY_DECLARATOR (newArrayDeclarator)? (expression)? )
+	;
diff --git a/app/preproc/make.sh b/app/preproc/make.sh
new file mode 100755
index 000000000..90324ddc9
--- /dev/null
+++ b/app/preproc/make.sh
@@ -0,0 +1,3 @@
+java -cp ../../build/macosx/work/lib/antlr.jar antlr.Tool java.g
+# now build the pde stuff that extends the java classes
+java -cp ../../build/macosx/work/lib/antlr.jar antlr.Tool -glib java.g pde.g
\ No newline at end of file
diff --git a/app/preproc/pde.g b/app/preproc/pde.g
new file mode 100644
index 000000000..69a69402e
--- /dev/null
+++ b/app/preproc/pde.g
@@ -0,0 +1,304 @@
+/* -*- mode: antlr; c-basic-offset: 4; indent-tabs-mode: nil -*- */
+header {
+package processing.app.preproc;
+
+import processing.app.*;
+}
+
+class PdeRecognizer extends JavaRecognizer;
+
+options {
+    importVocab = Java;
+    exportVocab = PdePartial;
+
+    codeGenMakeSwitchThreshold=10; // this is set high for debugging
+    codeGenBitsetTestThreshold=10; // this is set high for debugging
+
+    // developers may to want to set this to true for better
+    // debugging messages, however, doing so disables highlighting errors
+    // in the editor.
+    defaultErrorHandler = false; //true;
+}
+
+tokens {
+    CONSTRUCTOR_CAST; EMPTY_FIELD;
+}
+
+pdeProgram
+        // only java mode programs will have their own public classes or
+        // imports (and they must have at least one)
+    :   ( "public" "class" | "import" ) => javaProgram
+        { PdePreprocessor.programType = PdePreprocessor.JAVA; }
+
+        // the syntactic predicate here looks for any minimal (thus
+        // the non-greedy qualifier) number of fields, followed by
+        // the tokens that represent the definition of loop() or
+        // some other member function.  java mode programs may have such
+        // definitions, but they won't reach this point, having already been
+        // selected in the previous alternative.  static mode programs 
+        // don't have member functions.
+        //
+    |   ( ( options {greedy=false;}: possiblyEmptyField)* "void" IDENT LPAREN ) 
+        => activeProgram
+        { PdePreprocessor.programType = PdePreprocessor.ACTIVE; }
+
+    |   staticProgram
+        { PdePreprocessor.programType = PdePreprocessor.STATIC; }
+    ;
+
+// advanced mode is really just a normal java file
+javaProgram
+    :   compilationUnit
+    ;
+
+activeProgram
+    :  (possiblyEmptyField)+
+    ;
+
+staticProgram
+    :  (statement)*
+    ; 
+
+// copy of the java.g rule with WEBCOLOR_LITERAL added
+constant
+    :   NUM_INT
+    |   CHAR_LITERAL
+    |   STRING_LITERAL
+    |   NUM_FLOAT
+    |   NUM_LONG
+    |   NUM_DOUBLE
+    |   webcolor_literal
+    ; 
+
+// of the form #cc008f in PDE
+webcolor_literal
+    :   w:WEBCOLOR_LITERAL 
+    { PdePreferences.getBoolean("preproc.web_colors") && 
+      w.getText().length() == 6 }?  // must be exactly 6 hex digits
+    ;
+
+// copy of the java.g builtInType rule
+builtInConsCastType
+    :   "void"
+    |   "boolean"
+    |   "byte"
+    |   "char"
+    |   "short"
+    |   "int"
+    |   "float"
+    |   "long"
+    |   "double"
+    ;
+
+// our types include the java types and "color".  this is separated into two
+// rules so that constructor casts can just use the original typelist, since
+// we don't want to support the color type as a constructor cast.
+//
+builtInType
+    :   builtInConsCastType
+    |   "color"              // aliased to an int in PDE
+        { PdePreferences.getBoolean("preproc.color_datatype") }? 
+    ;
+
+// constructor style casts.
+constructorCast!
+    :   t:consCastTypeSpec[true]
+        LPAREN!
+        e:expression
+        RPAREN!
+        // if this is a string literal, make sure the type we're trying to cast
+        // to is one of the supported ones
+        //
+        { #e.getType() != STRING_LITERAL ||
+            ( #t.getType() == LITERAL_byte ||
+              #t.getType() == LITERAL_double ||
+              #t.getType() == LITERAL_float ||
+              #t.getType() == LITERAL_int ||
+              #t.getType() == LITERAL_long ||
+              #t.getType() == LITERAL_short ) }?
+        // create the node
+        //
+        {#constructorCast = #(#[CONSTRUCTOR_CAST,"CONSTRUCTOR_CAST"], t, e);}
+    ;
+
+// A list of types that be used as the destination type in a constructor-style
+// cast.  Ideally, this would include all class types, not just "String".  
+// Unfortunately, it's not possible to tell whether Foo(5) is supposed to be
+// a method call or a constructor cast without have a table of all valid
+// types or methods, which requires semantic analysis (eg processing of import
+// statements).  So we accept the set of built-in types plus "String".
+//
+consCastTypeSpec[boolean addImagNode]
+//	: stringTypeSpec[addImagNode]
+//	| builtInConsCastTypeSpec[addImagNode]
+        : builtInConsCastTypeSpec[addImagNode]
+// trying to remove String() cast [fry]
+	;
+
+//stringTypeSpec[boolean addImagNode]
+//    : id:IDENT { #id.getText().equals("String") }?
+//        {
+//            if ( addImagNode ) {
+//                #stringTypeSpec = #(#[TYPE,"TYPE"], 
+//                                   #stringTypeSpec);
+//            }
+//        }
+//    ;
+
+builtInConsCastTypeSpec[boolean addImagNode]
+    :    builtInConsCastType
+             {
+                 if ( addImagNode ) {
+                     #builtInConsCastTypeSpec = #(#[TYPE,"TYPE"],
+                                                  #builtInConsCastTypeSpec);
+                 }
+             }
+    ;
+
+// Since "color" tokens are lexed as LITERAL_color now, we need to have a rule
+// that can generate a method call from an expression that starts with this
+// token
+//
+colorMethodCall
+    : c:"color" {#c.setType(IDENT);} // this would default to LITERAL_color
+      lp:LPAREN^ {#lp.setType(METHOD_CALL);}
+      argList
+      RPAREN!
+    ;  
+
+// copy of the java.g rule with added constructorCast and colorMethodCall 
+// alternatives
+primaryExpression
+    :   (consCastTypeSpec[false] LPAREN) => constructorCast   
+            { PdePreferences.getBoolean("preproc.enhanced_casting") }?
+    |   identPrimary ( options {greedy=true;} : DOT^ "class" )?
+    |   constant
+    |   "true"
+    |   "false"
+    |   "null"
+    |   newExpression
+    |   "this"
+    |   "super"
+    |   LPAREN! assignmentExpression RPAREN!
+    |   colorMethodCall
+        // look for int.class and int[].class
+    |   builtInType
+        ( lbt:LBRACK^ {#lbt.setType(ARRAY_DECLARATOR);} RBRACK! )*
+        DOT^ "class"
+    ;
+
+// the below variable rule hacks are needed so that it's possible for the
+// emitter to correctly output variable declarations of the form "float a, b"
+// from the AST.  This means that our AST has a somewhat different form in
+// these rules than the java one does, and this new form may have its own 
+// semantic issues.  But it seems to fix the comma declaration issues.
+//
+variableDefinitions![AST mods, AST t]
+    :	vd:variableDeclarator[getASTFactory().dupTree(mods),
+                              getASTFactory().dupTree(t)]
+        {#variableDefinitions = #(#[VARIABLE_DEF,"VARIABLE_DEF"], mods, 
+                                  t, vd);}
+    ;
+variableDeclarator[AST mods, AST t]
+    :	( id:IDENT 	(lb:LBRACK^ {#lb.setType(ARRAY_DECLARATOR);} RBRACK!)*
+        v:varInitializer (COMMA!)? )+
+    ; 
+
+// java.g builds syntax trees with an inconsistent structure.  override one of
+// the rules there to fix this.
+//
+explicitConstructorInvocation!
+    :   t:"this" LPAREN a1:argList RPAREN SEMI
+        {#explicitConstructorInvocation = #(#[CTOR_CALL, "CTOR_CALL"], 
+                                            #t, #a1);}
+    |   s:"super" LPAREN a2:argList RPAREN SEMI
+        {#explicitConstructorInvocation = #(#[SUPER_CTOR_CALL, 
+                                              "SUPER_CTOR_CALL"], 
+                                            #s, #a2);}
+    ;
+
+// quick-n-dirty hack to the get the advanced class name.  we should 
+// really be getting it from the AST and not forking this rule from
+// the java.g copy at all.  Since this is a recursive descent parser, we get
+// the last class name in the file so that we don't end up with the classname
+// of an inner class.  If there is more than one "outer" class in a file,
+// this heuristic will fail.
+//
+classDefinition![AST modifiers]
+    :   "class" i:IDENT
+        // it _might_ have a superclass...
+        sc:superClassClause
+        // it might implement some interfaces...
+        ic:implementsClause
+        // now parse the body of the class
+        cb:classBlock
+        {#classDefinition = #(#[CLASS_DEF,"CLASS_DEF"],
+                              modifiers,i,sc,ic,cb);
+         PdePreprocessor.advClassName = i.getText();}
+    ;
+
+possiblyEmptyField
+    : field
+    | s:SEMI {#s.setType(EMPTY_FIELD);}
+    ;
+
+class PdeLexer extends JavaLexer;
+
+options {
+    importVocab=PdePartial;
+    exportVocab=Pde;
+}
+
+// We need to preserve whitespace and commentary instead of ignoring
+// like the supergrammar does.  Otherwise Jikes won't be able to give
+// us error messages that point to the equivalent PDE code.
+
+// WS, SL_COMMENT, ML_COMMENT are copies of the original productions,
+// but with the SKIP assigment removed.
+
+WS  :   (   ' '
+        |   '\t'
+        |   '\f'
+            // handle newlines
+        |   (   options {generateAmbigWarnings=false;}
+            :   "\r\n"  // Evil DOS
+            |   '\r'    // Macintosh
+            |   '\n'    // Unix (the right way)
+            )
+            { newline(); }
+        )+
+    ;
+
+// Single-line comments
+SL_COMMENT
+    :   "//"
+        (~('\n'|'\r'))* ('\n'|'\r'('\n')?)
+        {newline();}
+    ;
+
+// multiple-line comments
+ML_COMMENT
+    :   "/*"
+        (   /*  '\r' '\n' can be matched in one alternative or by matching
+                '\r' in one iteration and '\n' in another.  I am trying to
+                handle any flavor of newline that comes in, but the language
+                that allows both "\r\n" and "\r" and "\n" to all be valid
+                newline is ambiguous.  Consequently, the resulting grammar
+                must be ambiguous.  I'm shutting this warning off.
+             */
+            options {
+                generateAmbigWarnings=false;
+            }
+        :
+            { LA(2)!='/' }? '*'
+        |   '\r' '\n'       {newline();}
+        |   '\r'            {newline();}
+        |   '\n'            {newline();}
+        |   ~('*'|'\n'|'\r')
+        )*
+        "*/"
+    ;
+
+WEBCOLOR_LITERAL
+    : '#'! (HEX_DIGIT)+
+    ;
diff --git a/app/preproc/whitespace_test.pde b/app/preproc/whitespace_test.pde
new file mode 100644
index 000000000..290872db6
--- /dev/null
+++ b/app/preproc/whitespace_test.pde
@@ -0,0 +1,150 @@
+// this is a whitespace and other invisible token torture test for the ANTLR-based
+// preprocessor.  edit pde.properties and set "editor.save_build_files" to true.
+// then, build this in processing.  next, use
+//
+// diff -u --strip-trailing-cr \ 
+//   work/sketchbook/default/whitespace_test/whitespace_test.pde \ 
+//   work/lib/build/MyDemo.java
+//
+// to compare the files before and after preprocessing.  There should not be 
+// any differences.
+
+import // comment test
+  java.io.*;
+
+// comment 1
+public class // post-class comment
+
+// comment2
+  
+MyDemo extends BApplet implements // foo
+   java.lang. // bar
+    Cloneable {
+    
+  //argh
+    
+  public  // foo
+    String // bar
+      fff = /*rheet */ "stuff";
+    
+  static /*a*/ {
+    /*foo*/
+    /*bar*/
+    six = 6;
+    } /* b*/
+    
+  static /*a*/ final /*b*/ int six;
+  
+  void setup()
+  {
+    size(200, 200);
+    background(255);
+    
+    this . fff = /* ook */ (String)/*foo*/"yo";
+    rectMode(CENTER_DIAMETER); // comment 1a
+    noStroke();
+    fill(255, 204, 0);
+    
+    int q = /*a*/ - /*b*/ 1;
+    
+    boolean c = /*a*/ ! /*b*/ true;
+  }
+
+  int foo() /*a*/ throws /*b*/ java.lang.Exception /*c*/
+  {
+    int b = 7;
+    switch /*a*/ ( /*b*/ b /*c*/ ) {
+    case /*d*/ 1 /*e*/: /*f*/
+      int c=9;
+        /*g*/
+      break; /*h*/
+    default /*i*/ :
+      int d=9;
+      break;
+    }   
+       
+    try { /* qq */
+      loop(); /* rr */
+    } catch /*ss*/ (java.lang.Exception ex) /*tt*/ {
+      b = 8; /*tut*/
+      throw /*utu*/ ex;
+    } /*uu*/ finally /*vv*/ { 
+      b = 9;
+    } /*ww*/
+
+    b /*aaa*/ = /*bbb*/ true /*ccc*/ ? /*ddd*/ 0 /*eee*/
+      : /* fff*/ 1 /*ggg*/;
+    return /*a*/ 5 /*b*/;
+  }
+  
+  // comment 2
+  void loop()
+  {
+  
+    int arr1 /* VVV */ [ /* XXX */] /*YYY*/  ;
+    int[] arr2 = { /*a*/ 2, 3 /*b*/ } /*c*/ ;
+    
+    for /*a*/ (/*b*/ int j=0 /*c*/; /*d*/ j<2/*e*/ ; /*f*/ j++ /*g*/)
+      /*h*/
+      arr2[1] = 6;
+      
+     /*foo*/  
+     ;
+     /*bar*/
+    rect(width-mouseX, height-mouseY, 50, 50);
+    rect(mouseX, mouseY, 50, 50);
+    
+    if (/*a*/ arr2[1] == 6/*b*/) {
+      /*c*/
+      int d=7;
+    } /*d*/else /*e*/{
+      int e=8;
+      /*f*/
+    }
+    
+    int f;
+    if (/*aa*/ arr2[1] ==6 /*bb*/ ) 
+      /*cc*/
+      f=8; /*dd*/
+    else /*ee*/
+      f=10; /*ff*/
+      
+    while ( /*aaa*/ f < 15) /*bbb*/ {
+     f ++;
+    } /*ggg*/
+    
+    do /* aaaa */ {
+      f++;
+    } /*bbbb*/ while /*cccc*/ ( /*a*/ - /*b*/ 20 > f) /*dddd*/;
+    
+    f = 2 * 3 + 4;
+    
+    f = ( 2 * 3 ) + 4 + /*aa*/ -/*bb*/1;
+    
+    f = 2 * ( 3 + 4 ) ;
+    
+    fff = /*a*/ new /*b*/ String(/*c*/"foo"/*d*/) /*e*/;
+    
+    int arr3[] = /*a*/ new /*b*/ int/*c*/[/*d*/] /*e*/ {1/*f*/,2};
+    int arr4[][] = new /*a*/int/*b*/[1][2]/*c*/;
+
+  }
+  
+  class Shoe
+    {
+      Shoe(String brand)
+        {
+          println(brand);
+        }
+    }
+
+  class NikeAir extends Shoe
+    {
+      NikeAir()
+        {
+          /*a*/ super /*b*/ ( /*c*/ "Nike" /*d*/ ) /*e*/ ;
+          
+          /*aa*/ ( /*bb*/ new /*cc*/ MyDemo /*dd*/ (/*ee*/)/*ff*/)/*gg*/./*hh*/super/*ii*/(/*jj*/5/*kk*/);
+        }
+    }
+}
diff --git a/app/syntax/CTokenMarker.java b/app/syntax/CTokenMarker.java
new file mode 100644
index 000000000..c15183214
--- /dev/null
+++ b/app/syntax/CTokenMarker.java
@@ -0,0 +1,274 @@
+/*
+ * CTokenMarker.java - C token marker
+ * Copyright (C) 1998, 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.text.Segment;
+
+/**
+ * C token marker.
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class CTokenMarker extends TokenMarker
+{
+        public CTokenMarker()
+        {
+                this(true,getKeywords());
+        }
+
+        public CTokenMarker(boolean cpp, KeywordMap keywords)
+        {
+                this.cpp = cpp;
+                this.keywords = keywords;
+        }
+
+        public byte markTokensImpl(byte token, Segment line, int lineIndex)
+        {
+                char[] array = line.array;
+                int offset = line.offset;
+                lastOffset = offset;
+                lastKeyword = offset;
+                int mlength = line.count + offset;
+                boolean backslash = false;
+
+loop:           for(int i = offset; i < mlength; i++)
+                {
+                        int i1 = (i+1);
+
+                        char c = array[i];
+                        if(c == '\\')
+                        {
+                                backslash = !backslash;
+                                continue;
+                        }
+
+                        switch(token)
+                        {
+                        case Token.NULL:
+                                switch(c)
+                                {
+                                case '#':
+                                        if(backslash)
+                                                backslash = false;
+                                        else if(cpp)
+                                        {
+                                                if(doKeyword(line,i,c))
+                                                        break;
+                                                addToken(i - lastOffset,token);
+                                                addToken(mlength - i,Token.KEYWORD2);
+                                                lastOffset = lastKeyword = mlength;
+                                                break loop;
+                                        }
+                                        break;
+                                case '"':
+                                        doKeyword(line,i,c);
+                                        if(backslash)
+                                                backslash = false;
+                                        else
+                                        {
+                                                addToken(i - lastOffset,token);
+                                                token = Token.LITERAL1;
+                                                lastOffset = lastKeyword = i;
+                                        }
+                                        break;
+                                case '\'':
+                                        doKeyword(line,i,c);
+                                        if(backslash)
+                                                backslash = false;
+                                        else
+                                        {
+                                                addToken(i - lastOffset,token);
+                                                token = Token.LITERAL2;
+                                                lastOffset = lastKeyword = i;
+                                        }
+                                        break;
+                                case ':':
+                                        if(lastKeyword == offset)
+                                        {
+                                                if(doKeyword(line,i,c))
+                                                        break;
+                                                backslash = false;
+                                                addToken(i1 - lastOffset,Token.LABEL);
+                                                lastOffset = lastKeyword = i1;
+                                        }
+                                        else if(doKeyword(line,i,c))
+                                                break;
+                                        break;
+                                case '/':
+                                        backslash = false;
+                                        doKeyword(line,i,c);
+                                        if(mlength - i > 1)
+                                        {
+                                                switch(array[i1])
+                                                {
+                                                case '*':
+                                                        addToken(i - lastOffset,token);
+                                                        lastOffset = lastKeyword = i;
+                                                        if(mlength - i > 2 && array[i+2] == '*')
+                                                                token = Token.COMMENT2;
+                                                        else
+                                                                token = Token.COMMENT1;
+                                                        break;
+                                                case '/':
+                                                        addToken(i - lastOffset,token);
+                                                        addToken(mlength - i,Token.COMMENT1);
+                                                        lastOffset = lastKeyword = mlength;
+                                                        break loop;
+                                                }
+                                        }
+                                        break;
+                                default:
+                                        backslash = false;
+                                        if(!Character.isLetterOrDigit(c)
+                                                && c != '_')
+                                                doKeyword(line,i,c);
+                                        break;
+                                }
+                                break;
+                        case Token.COMMENT1:
+                        case Token.COMMENT2:
+                                backslash = false;
+                                if(c == '*' && mlength - i > 1)
+                                {
+                                        if(array[i1] == '/')
+                                        {
+                                                i++;
+                                                addToken((i+1) - lastOffset,token);
+                                                token = Token.NULL;
+                                                lastOffset = lastKeyword = i+1;
+                                        }
+                                }
+                                break;
+                        case Token.LITERAL1:
+                                if(backslash)
+                                        backslash = false;
+                                else if(c == '"')
+                                {
+                                        addToken(i1 - lastOffset,token);
+                                        token = Token.NULL;
+                                        lastOffset = lastKeyword = i1;
+                                }
+                                break;
+                        case Token.LITERAL2:
+                                if(backslash)
+                                        backslash = false;
+                                else if(c == '\'')
+                                {
+                                        addToken(i1 - lastOffset,Token.LITERAL1);
+                                        token = Token.NULL;
+                                        lastOffset = lastKeyword = i1;
+                                }
+                                break;
+                        default:
+                                throw new InternalError("Invalid state: "
+                                        + token);
+                        }
+                }
+
+                if(token == Token.NULL)
+                        doKeyword(line,mlength,'\0');
+
+                switch(token)
+                {
+                case Token.LITERAL1:
+                case Token.LITERAL2:
+                        addToken(mlength - lastOffset,Token.INVALID);
+                        token = Token.NULL;
+                        break;
+                case Token.KEYWORD2:
+                        addToken(mlength - lastOffset,token);
+                        if (!backslash) token = Token.NULL;
+                        addToken(mlength - lastOffset,token);
+                        break;
+                default:
+                        addToken(mlength - lastOffset,token);
+                        break;
+                }
+
+                return token;
+        }
+
+        public static KeywordMap getKeywords()
+        {
+                if(cKeywords == null)
+                {
+                        cKeywords = new KeywordMap(false);
+                        cKeywords.add("char",Token.KEYWORD3);
+                        cKeywords.add("double",Token.KEYWORD3);
+                        cKeywords.add("enum",Token.KEYWORD3);
+                        cKeywords.add("float",Token.KEYWORD3);
+                        cKeywords.add("int",Token.KEYWORD3);
+                        cKeywords.add("long",Token.KEYWORD3);
+                        cKeywords.add("short",Token.KEYWORD3);
+                        cKeywords.add("signed",Token.KEYWORD3);
+                        cKeywords.add("struct",Token.KEYWORD3);
+                        cKeywords.add("typedef",Token.KEYWORD3);
+                        cKeywords.add("union",Token.KEYWORD3);
+                        cKeywords.add("unsigned",Token.KEYWORD3);
+                        cKeywords.add("void",Token.KEYWORD3);
+                        cKeywords.add("auto",Token.KEYWORD1);
+                        cKeywords.add("const",Token.KEYWORD1);
+                        cKeywords.add("extern",Token.KEYWORD1);
+                        cKeywords.add("register",Token.KEYWORD1);
+                        cKeywords.add("static",Token.KEYWORD1);
+                        cKeywords.add("volatile",Token.KEYWORD1);
+                        cKeywords.add("break",Token.KEYWORD1);
+                        cKeywords.add("case",Token.KEYWORD1);
+                        cKeywords.add("continue",Token.KEYWORD1);
+                        cKeywords.add("default",Token.KEYWORD1);
+                        cKeywords.add("do",Token.KEYWORD1);
+                        cKeywords.add("else",Token.KEYWORD1);
+                        cKeywords.add("for",Token.KEYWORD1);
+                        cKeywords.add("goto",Token.KEYWORD1);
+                        cKeywords.add("if",Token.KEYWORD1);
+                        cKeywords.add("return",Token.KEYWORD1);
+                        cKeywords.add("sizeof",Token.KEYWORD1);
+                        cKeywords.add("switch",Token.KEYWORD1);
+                        cKeywords.add("while",Token.KEYWORD1);
+                        cKeywords.add("asm",Token.KEYWORD2);
+                        cKeywords.add("asmlinkage",Token.KEYWORD2);
+                        cKeywords.add("far",Token.KEYWORD2);
+                        cKeywords.add("huge",Token.KEYWORD2);
+                        cKeywords.add("inline",Token.KEYWORD2);
+                        cKeywords.add("near",Token.KEYWORD2);
+                        cKeywords.add("pascal",Token.KEYWORD2);
+                        cKeywords.add("true",Token.LITERAL2);
+                        cKeywords.add("false",Token.LITERAL2);
+                        cKeywords.add("NULL",Token.LITERAL2);
+                }
+                return cKeywords;
+        }
+
+        // private members
+        private static KeywordMap cKeywords;
+
+        private boolean cpp;
+        private KeywordMap keywords;
+        private int lastOffset;
+        private int lastKeyword;
+
+        private boolean doKeyword(Segment line, int i, char c)
+        {
+                int i1 = i+1;
+
+                int len = i - lastKeyword;
+                byte id = keywords.lookup(line,lastKeyword,len);
+                if(id != Token.NULL)
+                {
+                        if(lastKeyword != lastOffset)
+                                addToken(lastKeyword - lastOffset,Token.NULL);
+                        addToken(len,id);
+                        lastOffset = i;
+                }
+                lastKeyword = i1;
+                return false;
+        }
+}
diff --git a/app/syntax/DefaultInputHandler.java b/app/syntax/DefaultInputHandler.java
new file mode 100644
index 000000000..aa4933448
--- /dev/null
+++ b/app/syntax/DefaultInputHandler.java
@@ -0,0 +1,365 @@
+/*
+ * DefaultInputHandler.java - Default implementation of an input handler
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.KeyStroke;
+import java.awt.event.*;
+import java.awt.Toolkit;
+import java.util.Hashtable;
+import java.util.StringTokenizer;
+
+/**
+ * The default input handler. It maps sequences of keystrokes into actions
+ * and inserts key typed events into the text area.
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class DefaultInputHandler extends InputHandler
+{
+        /**
+         * Creates a new input handler with no key bindings defined.
+         */
+        public DefaultInputHandler()
+        {
+                bindings = currentBindings = new Hashtable();
+        }
+
+        /**
+         * Sets up the default key bindings.
+         */
+        public void addDefaultKeyBindings()
+        {
+                addKeyBinding("BACK_SPACE",BACKSPACE);
+                addKeyBinding("C+BACK_SPACE",BACKSPACE_WORD);
+                addKeyBinding("DELETE",DELETE);
+                addKeyBinding("C+DELETE",DELETE_WORD);
+
+                addKeyBinding("ENTER",INSERT_BREAK);
+                addKeyBinding("TAB",INSERT_TAB);
+
+                addKeyBinding("INSERT",OVERWRITE);
+                addKeyBinding("C+\\",TOGGLE_RECT);
+
+                addKeyBinding("HOME",HOME);
+                addKeyBinding("END",END);
+                addKeyBinding("S+HOME",SELECT_HOME);
+                addKeyBinding("S+END",SELECT_END);
+                addKeyBinding("C+HOME",DOCUMENT_HOME);
+                addKeyBinding("C+END",DOCUMENT_END);
+                addKeyBinding("CS+HOME",SELECT_DOC_HOME);
+                addKeyBinding("CS+END",SELECT_DOC_END);
+
+                addKeyBinding("PAGE_UP",PREV_PAGE);
+                addKeyBinding("PAGE_DOWN",NEXT_PAGE);
+                addKeyBinding("S+PAGE_UP",SELECT_PREV_PAGE);
+                addKeyBinding("S+PAGE_DOWN",SELECT_NEXT_PAGE);
+
+                addKeyBinding("LEFT",PREV_CHAR);
+                addKeyBinding("S+LEFT",SELECT_PREV_CHAR);
+                addKeyBinding("C+LEFT",PREV_WORD);
+                addKeyBinding("CS+LEFT",SELECT_PREV_WORD);
+                addKeyBinding("RIGHT",NEXT_CHAR);
+                addKeyBinding("S+RIGHT",SELECT_NEXT_CHAR);
+                addKeyBinding("C+RIGHT",NEXT_WORD);
+                addKeyBinding("CS+RIGHT",SELECT_NEXT_WORD);
+                addKeyBinding("UP",PREV_LINE);
+                addKeyBinding("S+UP",SELECT_PREV_LINE);
+                addKeyBinding("DOWN",NEXT_LINE);
+                addKeyBinding("S+DOWN",SELECT_NEXT_LINE);
+
+                addKeyBinding("C+ENTER",REPEAT);
+        }
+
+        /**
+         * Adds a key binding to this input handler. The key binding is
+         * a list of white space separated key strokes of the form
+         * <i>[modifiers+]key</i> where modifier is C for Control, A for Alt,
+         * or S for Shift, and key is either a character (a-z) or a field
+         * name in the KeyEvent class prefixed with VK_ (e.g., BACK_SPACE)
+         * @param keyBinding The key binding
+         * @param action The action
+         */
+        public void addKeyBinding(String keyBinding, ActionListener action)
+        {
+                Hashtable current = bindings;
+
+                StringTokenizer st = new StringTokenizer(keyBinding);
+                while(st.hasMoreTokens())
+                {
+                        KeyStroke keyStroke = parseKeyStroke(st.nextToken());
+                        if(keyStroke == null)
+                                return;
+
+                        if(st.hasMoreTokens())
+                        {
+                                Object o = current.get(keyStroke);
+                                if(o instanceof Hashtable)
+                                        current = (Hashtable)o;
+                                else
+                                {
+                                        o = new Hashtable();
+                                        current.put(keyStroke,o);
+                                        current = (Hashtable)o;
+                                }
+                        }
+                        else
+                                current.put(keyStroke,action);
+                }
+        }
+
+        /**
+         * Removes a key binding from this input handler. This is not yet
+         * implemented.
+         * @param keyBinding The key binding
+         */
+        public void removeKeyBinding(String keyBinding)
+        {
+                throw new InternalError("Not yet implemented");
+        }
+
+        /**
+         * Removes all key bindings from this input handler.
+         */
+        public void removeAllKeyBindings()
+        {
+                bindings.clear();
+        }
+
+        /**
+         * Returns a copy of this input handler that shares the same
+         * key bindings. Setting key bindings in the copy will also
+         * set them in the original.
+         */
+        public InputHandler copy()
+        {
+                return new DefaultInputHandler(this);
+        }
+
+        /**
+         * Handle a key pressed event. This will look up the binding for
+         * the key stroke and execute it.
+         */
+        public void keyPressed(KeyEvent evt)
+        {
+                int keyCode = evt.getKeyCode();
+                int modifiers = evt.getModifiers();
+
+                // don't get command-s or other menu key equivs on mac
+                if ((modifiers & KeyEvent.META_MASK) != 0) return;
+
+                /*
+                char keyChar = evt.getKeyChar();
+                System.out.println("code=" + keyCode + " char=" + keyChar +
+                                   " charint=" + ((int)keyChar));
+                System.out.println("other codes " + KeyEvent.VK_ALT + " " +
+                                   KeyEvent.VK_META);
+                */
+
+                if(keyCode == KeyEvent.VK_CONTROL ||
+                        keyCode == KeyEvent.VK_SHIFT ||
+                        keyCode == KeyEvent.VK_ALT ||
+                        keyCode == KeyEvent.VK_META)
+                        return;
+
+                if((modifiers & ~KeyEvent.SHIFT_MASK) != 0
+                        || evt.isActionKey()
+                        || keyCode == KeyEvent.VK_BACK_SPACE
+                        || keyCode == KeyEvent.VK_DELETE
+                        || keyCode == KeyEvent.VK_ENTER
+                        || keyCode == KeyEvent.VK_TAB
+                        || keyCode == KeyEvent.VK_ESCAPE)
+                {
+                        if(grabAction != null)
+                        {
+                                handleGrabAction(evt);
+                                return;
+                        }
+
+                        KeyStroke keyStroke = KeyStroke.getKeyStroke(keyCode,
+                                modifiers);
+                        Object o = currentBindings.get(keyStroke);
+                        if(o == null)
+                        {
+                                // Don't beep if the user presses some
+                                // key we don't know about unless a
+                                // prefix is active. Otherwise it will
+                                // beep when caps lock is pressed, etc.
+                                if(currentBindings != bindings)
+                                {
+                                        Toolkit.getDefaultToolkit().beep();
+                                        // F10 should be passed on, but C+e F10
+                                        // shouldn't
+                                        repeatCount = 0;
+                                        repeat = false;
+                                        evt.consume();
+                                }
+                                currentBindings = bindings;
+                                return;
+                        }
+                        else if(o instanceof ActionListener)
+                        {
+                                currentBindings = bindings;
+
+                                executeAction(((ActionListener)o),
+                                        evt.getSource(),null);
+
+                                evt.consume();
+                                return;
+                        }
+                        else if(o instanceof Hashtable)
+                        {
+                                currentBindings = (Hashtable)o;
+                                evt.consume();
+                                return;
+                        }
+                }
+        }
+
+        /**
+         * Handle a key typed event. This inserts the key into the text area.
+         */
+        public void keyTyped(KeyEvent evt)
+        {
+                int modifiers = evt.getModifiers();
+                char c = evt.getKeyChar();
+
+                // this is the apple/cmd key on macosx.. so menu commands
+                // were being passed through as legit keys.. added this line
+                // in an attempt to prevent.
+                if ((modifiers & KeyEvent.META_MASK) != 0) return;
+
+                if (c != KeyEvent.CHAR_UNDEFINED) // &&
+                  //                (modifiers & KeyEvent.ALT_MASK) == 0)
+                {
+                  if(c >= 0x20 && c != 0x7f)
+                        {
+                                KeyStroke keyStroke = KeyStroke.getKeyStroke(
+                                        Character.toUpperCase(c));
+                                Object o = currentBindings.get(keyStroke);
+
+                                if(o instanceof Hashtable)
+                                {
+                                        currentBindings = (Hashtable)o;
+                                        return;
+                                }
+                                else if(o instanceof ActionListener)
+                                {
+                                        currentBindings = bindings;
+                                        executeAction((ActionListener)o,
+                                                evt.getSource(),
+                                                String.valueOf(c));
+                                        return;
+                                }
+
+                                currentBindings = bindings;
+
+                                if(grabAction != null)
+                                {
+                                        handleGrabAction(evt);
+                                        return;
+                                }
+
+                                // 0-9 adds another 'digit' to the repeat number
+                                if(repeat && Character.isDigit(c))
+                                {
+                                        repeatCount *= 10;
+                                        repeatCount += (c - '0');
+                                        return;
+                                }
+
+                                executeAction(INSERT_CHAR,evt.getSource(),
+                                        String.valueOf(evt.getKeyChar()));
+
+                                repeatCount = 0;
+                                repeat = false;
+                        }
+                }
+        }
+
+        /**
+         * Converts a string to a keystroke. The string should be of the
+         * form <i>modifiers</i>+<i>shortcut</i> where <i>modifiers</i>
+         * is any combination of A for Alt, C for Control, S for Shift
+         * or M for Meta, and <i>shortcut</i> is either a single character,
+         * or a keycode name from the <code>KeyEvent</code> class, without
+         * the <code>VK_</code> prefix.
+         * @param keyStroke A string description of the key stroke
+         */
+        public static KeyStroke parseKeyStroke(String keyStroke)
+        {
+                if(keyStroke == null)
+                        return null;
+                int modifiers = 0;
+                int index = keyStroke.indexOf('+');
+                if(index != -1)
+                {
+                        for(int i = 0; i < index; i++)
+                        {
+                                switch(Character.toUpperCase(keyStroke
+                                        .charAt(i)))
+                                {
+                                case 'A':
+                                        modifiers |= InputEvent.ALT_MASK;
+                                        break;
+                                case 'C':
+                                        modifiers |= InputEvent.CTRL_MASK;
+                                        break;
+                                case 'M':
+                                        modifiers |= InputEvent.META_MASK;
+                                        break;
+                                case 'S':
+                                        modifiers |= InputEvent.SHIFT_MASK;
+                                        break;
+                                }
+                        }
+                }
+                String key = keyStroke.substring(index + 1);
+                if(key.length() == 1)
+                {
+                        char ch = Character.toUpperCase(key.charAt(0));
+                        if(modifiers == 0)
+                                return KeyStroke.getKeyStroke(ch);
+                        else
+                                return KeyStroke.getKeyStroke(ch,modifiers);
+                }
+                else if(key.length() == 0)
+                {
+                        System.err.println("Invalid key stroke: " + keyStroke);
+                        return null;
+                }
+                else
+                {
+                        int ch;
+
+                        try
+                        {
+                                ch = KeyEvent.class.getField("VK_".concat(key))
+                                        .getInt(null);
+                        }
+                        catch(Exception e)
+                        {
+                                System.err.println("Invalid key stroke: "
+                                        + keyStroke);
+                                return null;
+                        }
+
+                        return KeyStroke.getKeyStroke(ch,modifiers);
+                }
+        }
+
+        // private members
+        private Hashtable bindings;
+        private Hashtable currentBindings;
+
+        private DefaultInputHandler(DefaultInputHandler copy)
+        {
+                bindings = currentBindings = copy.bindings;
+        }
+}
diff --git a/app/syntax/InputHandler.java b/app/syntax/InputHandler.java
new file mode 100644
index 000000000..3c2186792
--- /dev/null
+++ b/app/syntax/InputHandler.java
@@ -0,0 +1,1071 @@
+/*
+ * InputHandler.java - Manages key bindings and executes actions
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.text.*;
+import javax.swing.JPopupMenu;
+import java.awt.event.*;
+import java.awt.Component;
+import java.util.*;
+
+/**
+ * An input handler converts the user's key strokes into concrete actions.
+ * It also takes care of macro recording and action repetition.<p>
+ *
+ * This class provides all the necessary support code for an input
+ * handler, but doesn't actually do any key binding logic. It is up
+ * to the implementations of this class to do so.
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ * @see org.gjt.sp.jedit.textarea.DefaultInputHandler
+ */
+public abstract class InputHandler extends KeyAdapter
+{
+        /**
+         * If this client property is set to Boolean.TRUE on the text area,
+         * the home/end keys will support 'smart' BRIEF-like behaviour
+         * (one press = start/end of line, two presses = start/end of
+         * viewscreen, three presses = start/end of document). By default,
+         * this property is not set.
+         */
+        public static final String SMART_HOME_END_PROPERTY = "InputHandler.homeEnd";
+
+        public static final ActionListener BACKSPACE = new backspace();
+        public static final ActionListener BACKSPACE_WORD = new backspace_word();
+        public static final ActionListener DELETE = new delete();
+        public static final ActionListener DELETE_WORD = new delete_word();
+        public static final ActionListener END = new end(false);
+        public static final ActionListener DOCUMENT_END = new document_end(false);
+        public static final ActionListener SELECT_END = new end(true);
+        public static final ActionListener SELECT_DOC_END = new document_end(true);
+        public static final ActionListener INSERT_BREAK = new insert_break();
+        public static final ActionListener INSERT_TAB = new insert_tab();
+        public static final ActionListener HOME = new home(false);
+        public static final ActionListener DOCUMENT_HOME = new document_home(false);
+        public static final ActionListener SELECT_HOME = new home(true);
+        public static final ActionListener SELECT_DOC_HOME = new document_home(true);
+        public static final ActionListener NEXT_CHAR = new next_char(false);
+        public static final ActionListener NEXT_LINE = new next_line(false);
+        public static final ActionListener NEXT_PAGE = new next_page(false);
+        public static final ActionListener NEXT_WORD = new next_word(false);
+        public static final ActionListener SELECT_NEXT_CHAR = new next_char(true);
+        public static final ActionListener SELECT_NEXT_LINE = new next_line(true);
+        public static final ActionListener SELECT_NEXT_PAGE = new next_page(true);
+        public static final ActionListener SELECT_NEXT_WORD = new next_word(true);
+        public static final ActionListener OVERWRITE = new overwrite();
+        public static final ActionListener PREV_CHAR = new prev_char(false);
+        public static final ActionListener PREV_LINE = new prev_line(false);
+        public static final ActionListener PREV_PAGE = new prev_page(false);
+        public static final ActionListener PREV_WORD = new prev_word(false);
+        public static final ActionListener SELECT_PREV_CHAR = new prev_char(true);
+        public static final ActionListener SELECT_PREV_LINE = new prev_line(true);
+        public static final ActionListener SELECT_PREV_PAGE = new prev_page(true);
+        public static final ActionListener SELECT_PREV_WORD = new prev_word(true);
+        public static final ActionListener REPEAT = new repeat();
+        public static final ActionListener TOGGLE_RECT = new toggle_rect();
+
+        // Default action
+        public static final ActionListener INSERT_CHAR = new insert_char();
+
+        private static Hashtable actions;
+
+        static
+        {
+                actions = new Hashtable();
+                actions.put("backspace",BACKSPACE);
+                actions.put("backspace-word",BACKSPACE_WORD);
+                actions.put("delete",DELETE);
+                actions.put("delete-word",DELETE_WORD);
+                actions.put("end",END);
+                actions.put("select-end",SELECT_END);
+                actions.put("document-end",DOCUMENT_END);
+                actions.put("select-doc-end",SELECT_DOC_END);
+                actions.put("insert-break",INSERT_BREAK);
+                actions.put("insert-tab",INSERT_TAB);
+                actions.put("home",HOME);
+                actions.put("select-home",SELECT_HOME);
+                actions.put("document-home",DOCUMENT_HOME);
+                actions.put("select-doc-home",SELECT_DOC_HOME);
+                actions.put("next-char",NEXT_CHAR);
+                actions.put("next-line",NEXT_LINE);
+                actions.put("next-page",NEXT_PAGE);
+                actions.put("next-word",NEXT_WORD);
+                actions.put("select-next-char",SELECT_NEXT_CHAR);
+                actions.put("select-next-line",SELECT_NEXT_LINE);
+                actions.put("select-next-page",SELECT_NEXT_PAGE);
+                actions.put("select-next-word",SELECT_NEXT_WORD);
+                actions.put("overwrite",OVERWRITE);
+                actions.put("prev-char",PREV_CHAR);
+                actions.put("prev-line",PREV_LINE);
+                actions.put("prev-page",PREV_PAGE);
+                actions.put("prev-word",PREV_WORD);
+                actions.put("select-prev-char",SELECT_PREV_CHAR);
+                actions.put("select-prev-line",SELECT_PREV_LINE);
+                actions.put("select-prev-page",SELECT_PREV_PAGE);
+                actions.put("select-prev-word",SELECT_PREV_WORD);
+                actions.put("repeat",REPEAT);
+                actions.put("toggle-rect",TOGGLE_RECT);
+                actions.put("insert-char",INSERT_CHAR);
+        }
+
+        /**
+         * Returns a named text area action.
+         * @param name The action name
+         */
+        public static ActionListener getAction(String name)
+        {
+                return (ActionListener)actions.get(name);
+        }
+
+        /**
+         * Returns the name of the specified text area action.
+         * @param listener The action
+         */
+        public static String getActionName(ActionListener listener)
+        {
+                Enumeration en = getActions();
+                while(en.hasMoreElements())
+                {
+                        String name = (String)en.nextElement();
+                        ActionListener _listener = getAction(name);
+                        if(_listener == listener)
+                                return name;
+                }
+                return null;
+        }
+
+        /**
+         * Returns an enumeration of all available actions.
+         */
+        public static Enumeration getActions()
+        {
+                return actions.keys();
+        }
+
+        /**
+         * Adds the default key bindings to this input handler.
+         * This should not be called in the constructor of this
+         * input handler, because applications might load the
+         * key bindings from a file, etc.
+         */
+        public abstract void addDefaultKeyBindings();
+
+        /**
+         * Adds a key binding to this input handler.
+         * @param keyBinding The key binding (the format of this is
+         * input-handler specific)
+         * @param action The action
+         */
+        public abstract void addKeyBinding(String keyBinding, ActionListener action);
+
+        /**
+         * Removes a key binding from this input handler.
+         * @param keyBinding The key binding
+         */
+        public abstract void removeKeyBinding(String keyBinding);
+
+        /**
+         * Removes all key bindings from this input handler.
+         */
+        public abstract void removeAllKeyBindings();
+
+        /**
+         * Grabs the next key typed event and invokes the specified
+         * action with the key as a the action command.
+         * @param action The action
+         */
+        public void grabNextKeyStroke(ActionListener listener)
+        {
+                grabAction = listener;
+        }
+
+        /**
+         * Returns if repeating is enabled. When repeating is enabled,
+         * actions will be executed multiple times. This is usually
+         * invoked with a special key stroke in the input handler.
+         */
+        public boolean isRepeatEnabled()
+        {
+                return repeat;
+        }
+
+        /**
+         * Enables repeating. When repeating is enabled, actions will be
+         * executed multiple times. Once repeating is enabled, the input
+         * handler should read a number from the keyboard.
+         */
+        public void setRepeatEnabled(boolean repeat)
+        {
+                this.repeat = repeat;
+        }
+
+        /**
+         * Returns the number of times the next action will be repeated.
+         */
+        public int getRepeatCount()
+        {
+                return (repeat ? Math.max(1,repeatCount) : 1);
+        }
+
+        /**
+         * Sets the number of times the next action will be repeated.
+         * @param repeatCount The repeat count
+         */
+        public void setRepeatCount(int repeatCount)
+        {
+                this.repeatCount = repeatCount;
+        }
+
+        /**
+         * Returns the macro recorder. If this is non-null, all executed
+         * actions should be forwarded to the recorder.
+         */
+        public InputHandler.MacroRecorder getMacroRecorder()
+        {
+                return recorder;
+        }
+
+        /**
+         * Sets the macro recorder. If this is non-null, all executed
+         * actions should be forwarded to the recorder.
+         * @param recorder The macro recorder
+         */
+        public void setMacroRecorder(InputHandler.MacroRecorder recorder)
+        {
+                this.recorder = recorder;
+        }
+
+        /**
+         * Returns a copy of this input handler that shares the same
+         * key bindings. Setting key bindings in the copy will also
+         * set them in the original.
+         */
+        public abstract InputHandler copy();
+
+        /**
+         * Executes the specified action, repeating and recording it as
+         * necessary.
+         * @param listener The action listener
+         * @param source The event source
+         * @param actionCommand The action command
+         */
+        public void executeAction(ActionListener listener, Object source,
+                String actionCommand)
+        {
+                // create event
+                ActionEvent evt = new ActionEvent(source,
+                        ActionEvent.ACTION_PERFORMED,
+                        actionCommand);
+
+                // don't do anything if the action is a wrapper
+                // (like EditAction.Wrapper)
+                if(listener instanceof Wrapper)
+                {
+                        listener.actionPerformed(evt);
+                        return;
+                }
+
+                // remember old values, in case action changes them
+                boolean _repeat = repeat;
+                int _repeatCount = getRepeatCount();
+
+                // execute the action
+                if(listener instanceof InputHandler.NonRepeatable)
+                        listener.actionPerformed(evt);
+                else
+                {
+                        for(int i = 0; i < Math.max(1,repeatCount); i++)
+                                listener.actionPerformed(evt);
+                }
+
+                // do recording. Notice that we do no recording whatsoever
+                // for actions that grab keys
+                if(grabAction == null)
+                {
+                        if(recorder != null)
+                        {
+                                if(!(listener instanceof InputHandler.NonRecordable))
+                                {
+                                        if(_repeatCount != 1)
+                                                recorder.actionPerformed(REPEAT,String.valueOf(_repeatCount));
+
+                                        recorder.actionPerformed(listener,actionCommand);
+                                }
+                        }
+
+                        // If repeat was true originally, clear it
+                        // Otherwise it might have been set by the action, etc
+                        if(_repeat)
+                        {
+                                repeat = false;
+                                repeatCount = 0;
+                        }
+                }
+        }
+
+        /**
+         * Returns the text area that fired the specified event.
+         * @param evt The event
+         */
+        public static JEditTextArea getTextArea(EventObject evt)
+        {
+                if(evt != null)
+                {
+                        Object o = evt.getSource();
+                        if(o instanceof Component)
+                        {
+                                // find the parent text area
+                                Component c = (Component)o;
+                                for(;;)
+                                {
+                                        if(c instanceof JEditTextArea)
+                                                return (JEditTextArea)c;
+                                        else if(c == null)
+                                                break;
+                                        if(c instanceof JPopupMenu)
+                                                c = ((JPopupMenu)c)
+                                                        .getInvoker();
+                                        else
+                                                c = c.getParent();
+                                }
+                        }
+                }
+
+                // this shouldn't happen
+                System.err.println("BUG: getTextArea() returning null");
+                System.err.println("Report this to Slava Pestov <sp@gjt.org>");
+                return null;
+        }
+
+        // protected members
+
+        /**
+         * If a key is being grabbed, this method should be called with
+         * the appropriate key event. It executes the grab action with
+         * the typed character as the parameter.
+         */
+        protected void handleGrabAction(KeyEvent evt)
+        {
+                // Clear it *before* it is executed so that executeAction()
+                // resets the repeat count
+                ActionListener _grabAction = grabAction;
+                grabAction = null;
+                executeAction(_grabAction,evt.getSource(),
+                        String.valueOf(evt.getKeyChar()));
+        }
+
+        // protected members
+        protected ActionListener grabAction;
+        protected boolean repeat;
+        protected int repeatCount;
+        protected InputHandler.MacroRecorder recorder;
+
+        /**
+         * If an action implements this interface, it should not be repeated.
+         * Instead, it will handle the repetition itself.
+         */
+        public interface NonRepeatable {}
+
+        /**
+         * If an action implements this interface, it should not be recorded
+         * by the macro recorder. Instead, it will do its own recording.
+         */
+        public interface NonRecordable {}
+
+        /**
+         * For use by EditAction.Wrapper only.
+         * @since jEdit 2.2final
+         */
+        public interface Wrapper {}
+
+        /**
+         * Macro recorder.
+         */
+        public interface MacroRecorder
+        {
+                void actionPerformed(ActionListener listener,
+                        String actionCommand);
+        }
+
+        public static class backspace implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+
+                        if(!textArea.isEditable())
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        if(textArea.getSelectionStart()
+                           != textArea.getSelectionEnd())
+                        {
+                                textArea.setSelectedText("");
+                        }
+                        else
+                        {
+                                int caret = textArea.getCaretPosition();
+                                if(caret == 0)
+                                {
+                                        textArea.getToolkit().beep();
+                                        return;
+                                }
+                                try
+                                {
+                                        textArea.getDocument().remove(caret - 1,1);
+                                }
+                                catch(BadLocationException bl)
+                                {
+                                        bl.printStackTrace();
+                                }
+                        }
+                }
+        }
+
+        public static class backspace_word implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int start = textArea.getSelectionStart();
+                        if(start != textArea.getSelectionEnd())
+                        {
+                                textArea.setSelectedText("");
+                        }
+
+                        int line = textArea.getCaretLine();
+                        int lineStart = textArea.getLineStartOffset(line);
+                        int caret = start - lineStart;
+
+                        String lineText = textArea.getLineText(textArea
+                                .getCaretLine());
+
+                        if(caret == 0)
+                        {
+                                if(lineStart == 0)
+                                {
+                                        textArea.getToolkit().beep();
+                                        return;
+                                }
+                                caret--;
+                        }
+                        else
+                        {
+                                String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
+                                caret = TextUtilities.findWordStart(lineText,caret,noWordSep);
+                        }
+
+                        try
+                        {
+                                textArea.getDocument().remove(
+                                                caret + lineStart,
+                                                start - (caret + lineStart));
+                        }
+                        catch(BadLocationException bl)
+                        {
+                                bl.printStackTrace();
+                        }
+                }
+        }
+
+        public static class delete implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+
+                        if(!textArea.isEditable())
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        if(textArea.getSelectionStart()
+                           != textArea.getSelectionEnd())
+                        {
+                                textArea.setSelectedText("");
+                        }
+                        else
+                        {
+                                int caret = textArea.getCaretPosition();
+                                if(caret == textArea.getDocumentLength())
+                                {
+                                        textArea.getToolkit().beep();
+                                        return;
+                                }
+                                try
+                                {
+                                        textArea.getDocument().remove(caret,1);
+                                }
+                                catch(BadLocationException bl)
+                                {
+                                        bl.printStackTrace();
+                                }
+                        }
+                }
+        }
+
+        public static class delete_word implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int start = textArea.getSelectionStart();
+                        if(start != textArea.getSelectionEnd())
+                        {
+                                textArea.setSelectedText("");
+                        }
+
+                        int line = textArea.getCaretLine();
+                        int lineStart = textArea.getLineStartOffset(line);
+                        int caret = start - lineStart;
+
+                        String lineText = textArea.getLineText(textArea
+                                .getCaretLine());
+
+                        if(caret == lineText.length())
+                        {
+                                if(lineStart + caret == textArea.getDocumentLength())
+                                {
+                                        textArea.getToolkit().beep();
+                                        return;
+                                }
+                                caret++;
+                        }
+                        else
+                        {
+                                String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
+                                caret = TextUtilities.findWordEnd(lineText,caret,noWordSep);
+                        }
+
+                        try
+                        {
+                                textArea.getDocument().remove(start,
+                                        (caret + lineStart) - start);
+                        }
+                        catch(BadLocationException bl)
+                        {
+                                bl.printStackTrace();
+                        }
+                }
+        }
+
+        public static class end implements ActionListener
+        {
+                private boolean select;
+
+                public end(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+
+                        int caret = textArea.getCaretPosition();
+
+                        int lastOfLine = textArea.getLineEndOffset(
+                                textArea.getCaretLine()) - 1;
+                        int lastVisibleLine = textArea.getFirstLine()
+                                + textArea.getVisibleLines();
+                        if(lastVisibleLine >= textArea.getLineCount())
+                        {
+                                lastVisibleLine = Math.min(textArea.getLineCount() - 1,
+                                        lastVisibleLine);
+                        }
+                        else
+                                lastVisibleLine -= (textArea.getElectricScroll() + 1);
+
+                        int lastVisible = textArea.getLineEndOffset(lastVisibleLine) - 1;
+                        int lastDocument = textArea.getDocumentLength();
+
+                        if(caret == lastDocument)
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+                        else if(!Boolean.TRUE.equals(textArea.getClientProperty(
+                                SMART_HOME_END_PROPERTY)))
+                                caret = lastOfLine;
+                        else if(caret == lastVisible)
+                                caret = lastDocument;
+                        else if(caret == lastOfLine)
+                                caret = lastVisible;
+                        else
+                                caret = lastOfLine;
+
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),caret);
+                        else
+                                textArea.setCaretPosition(caret);
+                }
+        }
+
+        public static class document_end implements ActionListener
+        {
+                private boolean select;
+
+                public document_end(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),
+                                        textArea.getDocumentLength());
+                        else
+                                textArea.setCaretPosition(textArea
+                                        .getDocumentLength());
+                }
+        }
+
+        public static class home implements ActionListener
+        {
+                private boolean select;
+
+                public home(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+
+                        int caret = textArea.getCaretPosition();
+
+                        int firstLine = textArea.getFirstLine();
+
+                        int firstOfLine = textArea.getLineStartOffset(
+                                textArea.getCaretLine());
+                        int firstVisibleLine = (firstLine == 0 ? 0 :
+                                firstLine + textArea.getElectricScroll());
+                        int firstVisible = textArea.getLineStartOffset(
+                                firstVisibleLine);
+
+                        if(caret == 0)
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+                        else if(!Boolean.TRUE.equals(textArea.getClientProperty(
+                                SMART_HOME_END_PROPERTY)))
+                                caret = firstOfLine;
+                        else if(caret == firstVisible)
+                                caret = 0;
+                        else if(caret == firstOfLine)
+                                caret = firstVisible;
+                        else
+                                caret = firstOfLine;
+
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),caret);
+                        else
+                                textArea.setCaretPosition(caret);
+                }
+        }
+
+        public static class document_home implements ActionListener
+        {
+                private boolean select;
+
+                public document_home(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),0);
+                        else
+                                textArea.setCaretPosition(0);
+                }
+        }
+
+        public static class insert_break implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+
+                        if(!textArea.isEditable())
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        textArea.setSelectedText("\n");
+                }
+        }
+
+        public static class insert_tab implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+
+                        if(!textArea.isEditable())
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        textArea.overwriteSetSelectedText("\t");
+                }
+        }
+
+        public static class next_char implements ActionListener
+        {
+                private boolean select;
+
+                public next_char(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int caret = textArea.getCaretPosition();
+                        if(caret == textArea.getDocumentLength())
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),
+                                        caret + 1);
+                        else
+                                textArea.setCaretPosition(caret + 1);
+                }
+        }
+
+        public static class next_line implements ActionListener
+        {
+                private boolean select;
+
+                public next_line(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int caret = textArea.getCaretPosition();
+                        int line = textArea.getCaretLine();
+
+                        if(line == textArea.getLineCount() - 1)
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        int magic = textArea.getMagicCaretPosition();
+                        if(magic == -1)
+                        {
+                                magic = textArea.offsetToX(line,
+                                        caret - textArea.getLineStartOffset(line));
+                        }
+
+                        caret = textArea.getLineStartOffset(line + 1)
+                                + textArea.xToOffset(line + 1,magic);
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),caret);
+                        else
+                                textArea.setCaretPosition(caret);
+                        textArea.setMagicCaretPosition(magic);
+                }
+        }
+
+        public static class next_page implements ActionListener
+        {
+                private boolean select;
+
+                public next_page(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int lineCount = textArea.getLineCount();
+                        int firstLine = textArea.getFirstLine();
+                        int visibleLines = textArea.getVisibleLines();
+                        int line = textArea.getCaretLine();
+
+                        firstLine += visibleLines;
+
+                        if(firstLine + visibleLines >= lineCount - 1)
+                                firstLine = lineCount - visibleLines;
+
+                        textArea.setFirstLine(firstLine);
+
+                        int caret = textArea.getLineStartOffset(
+                                Math.min(textArea.getLineCount() - 1,
+                                line + visibleLines));
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),caret);
+                        else
+                                textArea.setCaretPosition(caret);
+                }
+        }
+
+        public static class next_word implements ActionListener
+        {
+                private boolean select;
+
+                public next_word(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int caret = textArea.getCaretPosition();
+                        int line = textArea.getCaretLine();
+                        int lineStart = textArea.getLineStartOffset(line);
+                        caret -= lineStart;
+
+                        String lineText = textArea.getLineText(textArea
+                                .getCaretLine());
+
+                        if(caret == lineText.length())
+                        {
+                                if(lineStart + caret == textArea.getDocumentLength())
+                                {
+                                        textArea.getToolkit().beep();
+                                        return;
+                                }
+                                caret++;
+                        }
+                        else
+                        {
+                                String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
+                                caret = TextUtilities.findWordEnd(lineText,caret,noWordSep);
+                        }
+
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),
+                                        lineStart + caret);
+                        else
+                                textArea.setCaretPosition(lineStart + caret);
+                }
+        }
+
+        public static class overwrite implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        textArea.setOverwriteEnabled(
+                                !textArea.isOverwriteEnabled());
+                }
+        }
+
+        public static class prev_char implements ActionListener
+        {
+                private boolean select;
+
+                public prev_char(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int caret = textArea.getCaretPosition();
+                        if(caret == 0)
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),
+                                        caret - 1);
+                        else
+                                textArea.setCaretPosition(caret - 1);
+                }
+        }
+
+        public static class prev_line implements ActionListener
+        {
+                private boolean select;
+
+                public prev_line(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int caret = textArea.getCaretPosition();
+                        int line = textArea.getCaretLine();
+
+                        if(line == 0)
+                        {
+                                textArea.getToolkit().beep();
+                                return;
+                        }
+
+                        int magic = textArea.getMagicCaretPosition();
+                        if(magic == -1)
+                        {
+                                magic = textArea.offsetToX(line,
+                                        caret - textArea.getLineStartOffset(line));
+                        }
+
+                        caret = textArea.getLineStartOffset(line - 1)
+                                + textArea.xToOffset(line - 1,magic);
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),caret);
+                        else
+                                textArea.setCaretPosition(caret);
+                        textArea.setMagicCaretPosition(magic);
+                }
+        }
+
+        public static class prev_page implements ActionListener
+        {
+                private boolean select;
+
+                public prev_page(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int firstLine = textArea.getFirstLine();
+                        int visibleLines = textArea.getVisibleLines();
+                        int line = textArea.getCaretLine();
+
+                        if(firstLine < visibleLines)
+                                firstLine = visibleLines;
+
+                        textArea.setFirstLine(firstLine - visibleLines);
+
+                        int caret = textArea.getLineStartOffset(
+                                Math.max(0,line - visibleLines));
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),caret);
+                        else
+                                textArea.setCaretPosition(caret);
+                }
+        }
+
+        public static class prev_word implements ActionListener
+        {
+                private boolean select;
+
+                public prev_word(boolean select)
+                {
+                        this.select = select;
+                }
+
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        int caret = textArea.getCaretPosition();
+                        int line = textArea.getCaretLine();
+                        int lineStart = textArea.getLineStartOffset(line);
+                        caret -= lineStart;
+
+                        String lineText = textArea.getLineText(textArea
+                                .getCaretLine());
+
+                        if(caret == 0)
+                        {
+                                if(lineStart == 0)
+                                {
+                                        textArea.getToolkit().beep();
+                                        return;
+                                }
+                                caret--;
+                        }
+                        else
+                        {
+                                String noWordSep = (String)textArea.getDocument().getProperty("noWordSep");
+                                caret = TextUtilities.findWordStart(lineText,caret,noWordSep);
+                        }
+
+                        if(select)
+                                textArea.select(textArea.getMarkPosition(),
+                                        lineStart + caret);
+                        else
+                                textArea.setCaretPosition(lineStart + caret);
+                }
+        }
+
+        public static class repeat implements ActionListener,
+                InputHandler.NonRecordable
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        textArea.getInputHandler().setRepeatEnabled(true);
+                        String actionCommand = evt.getActionCommand();
+                        if(actionCommand != null)
+                        {
+                                textArea.getInputHandler().setRepeatCount(
+                                        Integer.parseInt(actionCommand));
+                        }
+                }
+        }
+
+        public static class toggle_rect implements ActionListener
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        textArea.setSelectionRectangular(
+                                !textArea.isSelectionRectangular());
+                }
+        }
+
+        public static class insert_char implements ActionListener,
+                InputHandler.NonRepeatable
+        {
+                public void actionPerformed(ActionEvent evt)
+                {
+                        JEditTextArea textArea = getTextArea(evt);
+                        String str = evt.getActionCommand();
+                        int repeatCount = textArea.getInputHandler().getRepeatCount();
+
+                        if(textArea.isEditable())
+                        {
+                                StringBuffer buf = new StringBuffer();
+                                for(int i = 0; i < repeatCount; i++)
+                                        buf.append(str);
+                                textArea.overwriteSetSelectedText(buf.toString());
+                        }
+                        else
+                        {
+                                textArea.getToolkit().beep();
+                        }
+                }
+        }
+}
diff --git a/app/syntax/JEditTextArea.java b/app/syntax/JEditTextArea.java
new file mode 100644
index 000000000..ad1d0f002
--- /dev/null
+++ b/app/syntax/JEditTextArea.java
@@ -0,0 +1,2227 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+ * JEditTextArea.java - jEdit's text component
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import processing.app.*;
+
+import javax.swing.event.*;
+import javax.swing.text.*;
+import javax.swing.undo.*;
+import javax.swing.*;
+import java.awt.datatransfer.*;
+import java.awt.event.*;
+import java.awt.*;
+import java.io.*;
+import java.util.Enumeration;
+import java.util.Vector;
+
+/**
+ * jEdit's text area component. It is more suited for editing program
+ * source code than JEditorPane, because it drops the unnecessary features
+ * (images, variable-width lines, and so on) and adds a whole bunch of
+ * useful goodies such as:
+ * <ul>
+ * <li>More flexible key binding scheme
+ * <li>Supports macro recorders
+ * <li>Rectangular selection
+ * <li>Bracket highlighting
+ * <li>Syntax highlighting
+ * <li>Command repetition
+ * <li>Block caret can be enabled
+ * </ul>
+ * It is also faster and doesn't have as many problems. It can be used
+ * in other applications; the only other part of jEdit it depends on is
+ * the syntax package.<p>
+ *
+ * To use it in your app, treat it like any other component, for example:
+ * <pre>JEditTextArea ta = new JEditTextArea();
+ * ta.setTokenMarker(new JavaTokenMarker());
+ * ta.setText("public class Test {\n"
+ *     + "    public static void main(String[] args) {\n"
+ *     + "        System.out.println(\"Hello World\");\n"
+ *     + "    }\n"
+ *     + "}");</pre>
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class JEditTextArea extends JComponent
+{
+  /**
+   * Adding components with this name to the text area will place
+   * them left of the horizontal scroll bar. In jEdit, the status
+   * bar is added this way.
+   */
+  public static String LEFT_OF_SCROLLBAR = "los";
+
+  /**
+   * Creates a new JEditTextArea with the default settings.
+   */
+  /*
+  public JEditTextArea()
+  {
+    this(TextAreaDefaults.getDefaults());
+  }
+  */
+
+  /**
+   * Creates a new JEditTextArea with the specified settings.
+   * @param defaults The default settings
+   */
+  public JEditTextArea(TextAreaDefaults defaults)
+  {
+    // Enable the necessary events
+    enableEvents(AWTEvent.KEY_EVENT_MASK);
+
+    // Initialize some misc. stuff
+    painter = new TextAreaPainter(this,defaults);
+    documentHandler = new DocumentHandler();
+    eventListenerList = new EventListenerList();
+    caretEvent = new MutableCaretEvent();
+    lineSegment = new Segment();
+    bracketLine = bracketPosition = -1;
+    blink = true;
+
+    // Initialize the GUI
+    setLayout(new ScrollLayout());
+    add(CENTER, painter);
+    add(RIGHT, vertical = new JScrollBar(JScrollBar.VERTICAL));
+    add(BOTTOM, horizontal = new JScrollBar(JScrollBar.HORIZONTAL));
+
+    // Add some event listeners
+    vertical.addAdjustmentListener(new AdjustHandler());
+    horizontal.addAdjustmentListener(new AdjustHandler());
+    painter.addComponentListener(new ComponentHandler());
+    painter.addMouseListener(new MouseHandler());
+    painter.addMouseMotionListener(new DragHandler());
+    addFocusListener(new FocusHandler());
+
+    // Load the defaults
+    setInputHandler(defaults.inputHandler);
+    setDocument(defaults.document);
+    editable = defaults.editable;
+    caretVisible = defaults.caretVisible;
+    caretBlinks = defaults.caretBlinks;
+    electricScroll = defaults.electricScroll;
+
+    // We don't seem to get the initial focus event?
+    focusedComponent = this;
+
+    // no more need for reflection, pde requires use of java 1.4
+    /*
+    if (System.getProperty("java.version").startsWith("1.4")) {
+    try {
+        Class kWheelHandler =
+          Class.forName("processing.app.syntax.WheelHandler");
+        java.lang.reflect.Constructor konstructor =
+          kWheelHandler.getConstructor(new Class[] { getClass() });
+        konstructor.newInstance(new Object[] { this });
+      } catch (Exception e) {
+        System.err.println(e);
+      }
+    }
+    */
+    //new WheelHandler(this);
+    addMouseWheelListener(new MouseWheelListener() {
+        public void mouseWheelMoved(MouseWheelEvent e) {
+          if (!scrollBarsInitialized) return;
+          int amt = e.getWheelRotation();
+          vertical.setValue(vertical.getValue() + amt * 3);
+        }
+      });
+  }
+
+  /**
+   * Returns if this component can be traversed by pressing
+   * the Tab key. This returns false.
+   */
+  public final boolean isManagingFocus()
+  {
+    return true;
+  }
+
+  /**
+   * Returns the object responsible for painting this text area.
+   */
+  public final TextAreaPainter getPainter()
+  {
+    return painter;
+  }
+
+  /**
+   * Returns the input handler.
+   */
+  public final InputHandler getInputHandler()
+  {
+    return inputHandler;
+  }
+
+  /**
+   * Sets the input handler.
+   * @param inputHandler The new input handler
+   */
+  public void setInputHandler(InputHandler inputHandler)
+  {
+    this.inputHandler = inputHandler;
+  }
+
+  /**
+   * Returns true if the caret is blinking, false otherwise.
+   */
+  public final boolean isCaretBlinkEnabled()
+  {
+    return caretBlinks;
+  }
+
+  /**
+   * Toggles caret blinking.
+   * @param caretBlinks True if the caret should blink, false otherwise
+   */
+  public void setCaretBlinkEnabled(boolean caretBlinks)
+  {
+    this.caretBlinks = caretBlinks;
+    if(!caretBlinks)
+      blink = false;
+
+    painter.invalidateSelectedLines();
+  }
+
+  /**
+   * Returns true if the caret is visible, false otherwise.
+   */
+  public final boolean isCaretVisible()
+  {
+    return (!caretBlinks || blink) && caretVisible;
+  }
+
+  /**
+   * Sets if the caret should be visible.
+   * @param caretVisible True if the caret should be visible, false
+   * otherwise
+   */
+  public void setCaretVisible(boolean caretVisible)
+  {
+    this.caretVisible = caretVisible;
+    blink = true;
+
+    painter.invalidateSelectedLines();
+  }
+
+  /**
+   * Blinks the caret.
+   */
+  public final void blinkCaret()
+  {
+    if(caretBlinks)
+      {
+        blink = !blink;
+        painter.invalidateSelectedLines();
+      }
+    else
+      blink = true;
+  }
+
+  /**
+   * Returns the number of lines from the top and button of the
+   * text area that are always visible.
+   */
+  public final int getElectricScroll()
+  {
+    return electricScroll;
+  }
+
+  /**
+   * Sets the number of lines from the top and bottom of the text
+   * area that are always visible
+   * @param electricScroll The number of lines always visible from
+   * the top or bottom
+   */
+  public final void setElectricScroll(int electricScroll)
+  {
+    this.electricScroll = electricScroll;
+  }
+
+
+  /**
+   * Updates the state of the scroll bars. This should be called
+   * if the number of lines in the document changes, or when the
+   * size of the text are changes.
+   */
+  public void updateScrollBars() {
+    if (vertical != null && visibleLines != 0) {
+      vertical.setValues(firstLine,visibleLines,0,getLineCount());
+      vertical.setUnitIncrement(2);
+      vertical.setBlockIncrement(visibleLines);
+    }
+
+    //if (horizontal != null && width != 0) {
+    if ((horizontal != null) && (painter.getWidth() != 0)) {
+      int value = horizontal.getValue();
+      //System.out.println("updateScrollBars");
+      //int width = painter.getWidth();
+      int lineCount = getLineCount();
+      int maxLineLength = 0;
+      for (int i = 0; i < lineCount; i++) {
+        int lineLength = getLineLength(i);
+        if (lineLength > maxLineLength) {
+          maxLineLength = lineLength;
+        }
+      }
+      int charWidth = painter.getFontMetrics().charWidth('w');
+      int width = maxLineLength * charWidth;
+      int painterWidth = painter.getWidth();
+      //System.out.println("max line len " + maxLineLength);
+      //System.out.println("width " + width);
+      //System.out.println("text area width " + painter.getWidth());
+
+      // this was the default, but it's enormous
+      //horizontal.setValues(-horizontalOffset,width,0,width * 5);
+
+      // something more reasonable, though this is a bad solution
+      //horizontal.setValues(-horizontalOffset,width,0,width * 2);
+
+      // in general.. time to start looking at that other syntax pkg
+      // since most code should fit the window horizontally, just use
+      // the default settings for the width, this is a nicer solution
+      // until a better update mechanism can be implemented [fry]
+
+      //horizontal.setValues(0, width, 0, width);
+                           //0, width - horizontalOffset);
+      // works, from pre-75 versions of p5
+      //horizontal.setValues(-horizontalOffset, width, 0, width);
+
+      // gets weird when writing to the end of lines
+      //horizontal.setValues(value, painterWidth, 0, width);
+
+      // seems to work, implemented for 0075
+      horizontal.setValues(-horizontalOffset, painterWidth, 0, width);
+
+      //horizontal.setUnitIncrement(painter.getFontMetrics().charWidth('w'));
+      horizontal.setUnitIncrement(charWidth);
+      horizontal.setBlockIncrement(width / 2);
+    }
+  }
+
+
+  /**
+   * Returns the line displayed at the text area's origin.
+   */
+  public final int getFirstLine()
+  {
+    return firstLine;
+  }
+
+  /**
+   * Sets the line displayed at the text area's origin without
+   * updating the scroll bars.
+   */
+  public void setFirstLine(int firstLine)
+  {
+    if(firstLine == this.firstLine)
+      return;
+    int oldFirstLine = this.firstLine;
+    this.firstLine = firstLine;
+    if(firstLine != vertical.getValue())
+      updateScrollBars();
+    painter.repaint();
+  }
+
+  /**
+   * Returns the number of lines visible in this text area.
+   */
+  public final int getVisibleLines()
+  {
+    return visibleLines;
+  }
+
+  /**
+   * Recalculates the number of visible lines. This should not
+   * be called directly.
+   */
+  public final void recalculateVisibleLines()
+  {
+    if(painter == null)
+      return;
+    int height = painter.getHeight();
+    int lineHeight = painter.getFontMetrics().getHeight();
+    int oldVisibleLines = visibleLines;
+    visibleLines = height / lineHeight;
+    updateScrollBars();
+  }
+
+  /**
+   * Returns the horizontal offset of drawn lines.
+   */
+  public final int getHorizontalOffset()
+  {
+    return horizontalOffset;
+  }
+
+  /**
+   * Sets the horizontal offset of drawn lines. This can be used to
+   * implement horizontal scrolling.
+   * @param horizontalOffset offset The new horizontal offset
+   */
+  public void setHorizontalOffset(int horizontalOffset)
+  {
+    if(horizontalOffset == this.horizontalOffset)
+      return;
+    this.horizontalOffset = horizontalOffset;
+    if(horizontalOffset != horizontal.getValue())
+      updateScrollBars();
+    painter.repaint();
+  }
+
+  /**
+   * A fast way of changing both the first line and horizontal
+   * offset.
+   * @param firstLine The new first line
+   * @param horizontalOffset The new horizontal offset
+   * @return True if any of the values were changed, false otherwise
+   */
+  public boolean setOrigin(int firstLine, int horizontalOffset)
+  {
+    boolean changed = false;
+    int oldFirstLine = this.firstLine;
+
+    if(horizontalOffset != this.horizontalOffset)
+      {
+        this.horizontalOffset = horizontalOffset;
+        changed = true;
+      }
+
+    if(firstLine != this.firstLine)
+      {
+        this.firstLine = firstLine;
+        changed = true;
+      }
+
+    if(changed)
+      {
+        updateScrollBars();
+        painter.repaint();
+      }
+
+    return changed;
+  }
+
+  /**
+   * Ensures that the caret is visible by scrolling the text area if
+   * necessary.
+   * @return True if scrolling was actually performed, false if the
+   * caret was already visible
+   */
+  public boolean scrollToCaret()
+  {
+    int line = getCaretLine();
+    int lineStart = getLineStartOffset(line);
+    int offset = Math.max(0,Math.min(getLineLength(line) - 1,
+                                     getCaretPosition() - lineStart));
+
+    return scrollTo(line,offset);
+  }
+
+  /**
+   * Ensures that the specified line and offset is visible by scrolling
+   * the text area if necessary.
+   * @param line The line to scroll to
+   * @param offset The offset in the line to scroll to
+   * @return True if scrolling was actually performed, false if the
+   * line and offset was already visible
+   */
+  public boolean scrollTo(int line, int offset)
+  {
+    // visibleLines == 0 before the component is realized
+    // we can't do any proper scrolling then, so we have
+    // this hack...
+    if (visibleLines == 0) {
+      setFirstLine(Math.max(0,line - electricScroll));
+      return true;
+    }
+
+    int newFirstLine = firstLine;
+    int newHorizontalOffset = horizontalOffset;
+
+    if(line < firstLine + electricScroll) {
+      newFirstLine = Math.max(0,line - electricScroll);
+
+    } else if(line + electricScroll >= firstLine + visibleLines) {
+      newFirstLine = (line - visibleLines) + electricScroll + 1;
+      if(newFirstLine + visibleLines >= getLineCount())
+        newFirstLine = getLineCount() - visibleLines;
+      if(newFirstLine < 0)
+        newFirstLine = 0;
+    }
+
+    int x = _offsetToX(line,offset);
+    int width = painter.getFontMetrics().charWidth('w');
+
+    if(x < 0) {
+      newHorizontalOffset = Math.min(0,horizontalOffset - x + width + 5);
+    } else if(x + width >= painter.getWidth()) {
+      newHorizontalOffset = horizontalOffset +
+        (painter.getWidth() - x) - width - 5;
+    }
+
+    return setOrigin(newFirstLine,newHorizontalOffset);
+  }
+
+  /**
+   * Converts a line index to a y co-ordinate.
+   * @param line The line
+   */
+  public int lineToY(int line)
+  {
+    FontMetrics fm = painter.getFontMetrics();
+    return (line - firstLine) * fm.getHeight()
+      - (fm.getLeading() + fm.getMaxDescent());
+  }
+
+  /**
+   * Converts a y co-ordinate to a line index.
+   * @param y The y co-ordinate
+   */
+  public int yToLine(int y)
+  {
+    FontMetrics fm = painter.getFontMetrics();
+    int height = fm.getHeight();
+    return Math.max(0,Math.min(getLineCount() - 1,
+                               y / height + firstLine));
+  }
+
+  /**
+   * Converts an offset in a line into an x co-ordinate. This is a
+   * slow version that can be used any time.
+   * @param line The line
+   * @param offset The offset, from the start of the line
+   */
+  public final int offsetToX(int line, int offset)
+  {
+    // don't use cached tokens
+    painter.currentLineTokens = null;
+    return _offsetToX(line,offset);
+  }
+
+  /**
+   * Converts an offset in a line into an x co-ordinate. This is a
+   * fast version that should only be used if no changes were made
+   * to the text since the last repaint.
+   * @param line The line
+   * @param offset The offset, from the start of the line
+   */
+  public int _offsetToX(int line, int offset)
+  {
+    TokenMarker tokenMarker = getTokenMarker();
+
+    /* Use painter's cached info for speed */
+    FontMetrics fm = painter.getFontMetrics();
+
+    getLineText(line,lineSegment);
+
+    int segmentOffset = lineSegment.offset;
+    int x = horizontalOffset;
+
+    /* If syntax coloring is disabled, do simple translation */
+    if(tokenMarker == null)
+      {
+        lineSegment.count = offset;
+        return x + Utilities.getTabbedTextWidth(lineSegment,
+                                                fm,x,painter,0);
+      }
+    /* If syntax coloring is enabled, we have to do this because
+     * tokens can vary in width */
+    else
+      {
+        Token tokens;
+        if(painter.currentLineIndex == line
+           && painter.currentLineTokens != null)
+          tokens = painter.currentLineTokens;
+        else
+          {
+            painter.currentLineIndex = line;
+            tokens = painter.currentLineTokens
+              = tokenMarker.markTokens(lineSegment,line);
+          }
+
+        Toolkit toolkit = painter.getToolkit();
+        Font defaultFont = painter.getFont();
+        SyntaxStyle[] styles = painter.getStyles();
+
+        for(;;)
+          {
+            byte id = tokens.id;
+            if(id == Token.END)
+              {
+                return x;
+              }
+
+            if(id == Token.NULL)
+              fm = painter.getFontMetrics();
+            else
+              fm = styles[id].getFontMetrics(defaultFont);
+
+            int length = tokens.length;
+
+            if(offset + segmentOffset < lineSegment.offset + length)
+              {
+                lineSegment.count = offset - (lineSegment.offset - segmentOffset);
+                return x + Utilities.getTabbedTextWidth(
+                                                        lineSegment,fm,x,painter,0);
+              }
+            else
+              {
+                lineSegment.count = length;
+                x += Utilities.getTabbedTextWidth(
+                                                  lineSegment,fm,x,painter,0);
+                lineSegment.offset += length;
+              }
+            tokens = tokens.next;
+          }
+      }
+  }
+
+  /**
+         * Converts an x co-ordinate to an offset within a line.
+         * @param line The line
+         * @param x The x co-ordinate
+         */
+  public int xToOffset(int line, int x)
+  {
+    TokenMarker tokenMarker = getTokenMarker();
+
+    /* Use painter's cached info for speed */
+    FontMetrics fm = painter.getFontMetrics();
+
+    getLineText(line,lineSegment);
+
+    char[] segmentArray = lineSegment.array;
+    int segmentOffset = lineSegment.offset;
+    int segmentCount = lineSegment.count;
+
+    int width = horizontalOffset;
+
+    if(tokenMarker == null)
+      {
+        for(int i = 0; i < segmentCount; i++)
+          {
+            char c = segmentArray[i + segmentOffset];
+            int charWidth;
+            if(c == '\t')
+              charWidth = (int)painter.nextTabStop(width,i)
+                - width;
+            else
+              charWidth = fm.charWidth(c);
+
+            if(painter.isBlockCaretEnabled())
+              {
+                if(x - charWidth <= width)
+                  return i;
+              }
+            else
+              {
+                if(x - charWidth / 2 <= width)
+                  return i;
+              }
+
+            width += charWidth;
+          }
+
+        return segmentCount;
+      }
+    else
+      {
+        Token tokens;
+        if(painter.currentLineIndex == line && painter
+           .currentLineTokens != null)
+          tokens = painter.currentLineTokens;
+        else
+          {
+            painter.currentLineIndex = line;
+            tokens = painter.currentLineTokens
+              = tokenMarker.markTokens(lineSegment,line);
+          }
+
+        int offset = 0;
+        Toolkit toolkit = painter.getToolkit();
+        Font defaultFont = painter.getFont();
+        SyntaxStyle[] styles = painter.getStyles();
+
+        for(;;)
+          {
+            byte id = tokens.id;
+            if(id == Token.END)
+              return offset;
+
+            if(id == Token.NULL)
+              fm = painter.getFontMetrics();
+            else
+              fm = styles[id].getFontMetrics(defaultFont);
+
+            int length = tokens.length;
+
+            for(int i = 0; i < length; i++)
+              {
+                char c = segmentArray[segmentOffset + offset + i];
+                int charWidth;
+                if(c == '\t')
+                  charWidth = (int)painter.nextTabStop(width,offset + i)
+                    - width;
+                else
+                  charWidth = fm.charWidth(c);
+
+                if(painter.isBlockCaretEnabled())
+                  {
+                    if(x - charWidth <= width)
+                      return offset + i;
+                  }
+                else
+                  {
+                    if(x - charWidth / 2 <= width)
+                      return offset + i;
+                  }
+
+                width += charWidth;
+              }
+
+            offset += length;
+            tokens = tokens.next;
+          }
+      }
+  }
+
+  /**
+         * Converts a point to an offset, from the start of the text.
+         * @param x The x co-ordinate of the point
+         * @param y The y co-ordinate of the point
+         */
+  public int xyToOffset(int x, int y)
+  {
+    int line = yToLine(y);
+    int start = getLineStartOffset(line);
+    return start + xToOffset(line,x);
+  }
+
+  /**
+         * Returns the document this text area is editing.
+         */
+  public final SyntaxDocument getDocument()
+  {
+    return document;
+  }
+
+  /**
+         * Sets the document this text area is editing.
+         * @param document The document
+         */
+  public void setDocument(SyntaxDocument document)
+  {
+    if(this.document == document)
+      return;
+    if(this.document != null)
+      this.document.removeDocumentListener(documentHandler);
+    this.document = document;
+
+    document.addDocumentListener(documentHandler);
+
+    select(0,0);
+    updateScrollBars();
+    painter.repaint();
+  }
+
+  /**
+         * Returns the document's token marker. Equivalent to calling
+         * <code>getDocument().getTokenMarker()</code>.
+         */
+  public final TokenMarker getTokenMarker()
+  {
+    return document.getTokenMarker();
+  }
+
+  /**
+         * Sets the document's token marker. Equivalent to caling
+         * <code>getDocument().setTokenMarker()</code>.
+         * @param tokenMarker The token marker
+         */
+  public final void setTokenMarker(TokenMarker tokenMarker)
+  {
+    document.setTokenMarker(tokenMarker);
+  }
+
+  /**
+         * Returns the length of the document. Equivalent to calling
+         * <code>getDocument().getLength()</code>.
+         */
+  public final int getDocumentLength()
+  {
+    return document.getLength();
+  }
+
+  /**
+         * Returns the number of lines in the document.
+         */
+  public final int getLineCount()
+  {
+    return document.getDefaultRootElement().getElementCount();
+  }
+
+  /**
+         * Returns the line containing the specified offset.
+         * @param offset The offset
+         */
+  public final int getLineOfOffset(int offset)
+  {
+    return document.getDefaultRootElement().getElementIndex(offset);
+  }
+
+  /**
+         * Returns the start offset of the specified line.
+         * @param line The line
+         * @return The start offset of the specified line, or -1 if the line is
+         * invalid
+         */
+  public int getLineStartOffset(int line)
+  {
+    Element lineElement = document.getDefaultRootElement()
+      .getElement(line);
+    if(lineElement == null)
+      return -1;
+    else
+      return lineElement.getStartOffset();
+  }
+
+  /**
+         * Returns the end offset of the specified line.
+         * @param line The line
+         * @return The end offset of the specified line, or -1 if the line is
+         * invalid.
+         */
+  public int getLineEndOffset(int line)
+  {
+    Element lineElement = document.getDefaultRootElement()
+      .getElement(line);
+    if(lineElement == null)
+      return -1;
+    else
+      return lineElement.getEndOffset();
+  }
+
+  /**
+         * Returns the length of the specified line.
+         * @param line The line
+         */
+  public int getLineLength(int line)
+  {
+    Element lineElement = document.getDefaultRootElement()
+      .getElement(line);
+    if(lineElement == null)
+      return -1;
+    else
+      return lineElement.getEndOffset()
+        - lineElement.getStartOffset() - 1;
+  }
+
+  /**
+         * Returns the entire text of this text area.
+         */
+  public String getText()
+  {
+    try
+      {
+        return document.getText(0,document.getLength());
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+        return null;
+      }
+  }
+
+  /**
+   * Sets the entire text of this text area.
+   */
+  public void setText(String text)
+  {
+    try
+      {
+        document.beginCompoundEdit();
+        document.remove(0,document.getLength());
+        document.insertString(0,text,null);
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+      }
+    finally
+      {
+        document.endCompoundEdit();
+      }
+  }
+
+  /**
+         * Returns the specified substring of the document.
+         * @param start The start offset
+         * @param len The length of the substring
+         * @return The substring, or null if the offsets are invalid
+         */
+  public final String getText(int start, int len)
+  {
+    try
+      {
+        return document.getText(start,len);
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+        return null;
+      }
+  }
+
+  /**
+         * Copies the specified substring of the document into a segment.
+         * If the offsets are invalid, the segment will contain a null string.
+         * @param start The start offset
+         * @param len The length of the substring
+         * @param segment The segment
+         */
+  public final void getText(int start, int len, Segment segment)
+  {
+    try
+      {
+        document.getText(start,len,segment);
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+        segment.offset = segment.count = 0;
+      }
+  }
+
+  /**
+         * Returns the text on the specified line.
+         * @param lineIndex The line
+         * @return The text, or null if the line is invalid
+         */
+  public final String getLineText(int lineIndex)
+  {
+    int start = getLineStartOffset(lineIndex);
+    return getText(start,getLineEndOffset(lineIndex) - start - 1);
+  }
+
+  /**
+         * Copies the text on the specified line into a segment. If the line
+         * is invalid, the segment will contain a null string.
+         * @param lineIndex The line
+         */
+  public final void getLineText(int lineIndex, Segment segment)
+  {
+    int start = getLineStartOffset(lineIndex);
+    getText(start,getLineEndOffset(lineIndex) - start - 1,segment);
+  }
+
+  /**
+         * Returns the selection start offset.
+         */
+  public final int getSelectionStart()
+  {
+    return selectionStart;
+  }
+
+  /**
+         * Returns the offset where the selection starts on the specified
+         * line.
+         */
+  public int getSelectionStart(int line)
+  {
+    if(line == selectionStartLine)
+      return selectionStart;
+    else if(rectSelect)
+      {
+        Element map = document.getDefaultRootElement();
+        int start = selectionStart - map.getElement(selectionStartLine)
+          .getStartOffset();
+
+        Element lineElement = map.getElement(line);
+        int lineStart = lineElement.getStartOffset();
+        int lineEnd = lineElement.getEndOffset() - 1;
+        return Math.min(lineEnd,lineStart + start);
+      }
+    else
+      return getLineStartOffset(line);
+  }
+
+  /**
+         * Returns the selection start line.
+         */
+  public final int getSelectionStartLine()
+  {
+    return selectionStartLine;
+  }
+
+  /**
+         * Sets the selection start. The new selection will be the new
+         * selection start and the old selection end.
+         * @param selectionStart The selection start
+         * @see #select(int,int)
+         */
+  public final void setSelectionStart(int selectionStart)
+  {
+    select(selectionStart,selectionEnd);
+  }
+
+  /**
+         * Returns the selection end offset.
+         */
+  public final int getSelectionEnd()
+  {
+    return selectionEnd;
+  }
+
+  /**
+         * Returns the offset where the selection ends on the specified
+         * line.
+         */
+  public int getSelectionEnd(int line)
+  {
+    if(line == selectionEndLine)
+      return selectionEnd;
+    else if(rectSelect)
+      {
+        Element map = document.getDefaultRootElement();
+        int end = selectionEnd - map.getElement(selectionEndLine)
+          .getStartOffset();
+
+        Element lineElement = map.getElement(line);
+        int lineStart = lineElement.getStartOffset();
+        int lineEnd = lineElement.getEndOffset() - 1;
+        return Math.min(lineEnd,lineStart + end);
+      }
+    else
+      return getLineEndOffset(line) - 1;
+  }
+
+  /**
+         * Returns the selection end line.
+         */
+  public final int getSelectionEndLine()
+  {
+    return selectionEndLine;
+  }
+
+  /**
+         * Sets the selection end. The new selection will be the old
+         * selection start and the bew selection end.
+         * @param selectionEnd The selection end
+         * @see #select(int,int)
+         */
+  public final void setSelectionEnd(int selectionEnd)
+  {
+    select(selectionStart,selectionEnd);
+  }
+
+  public final boolean isSelectionActive()
+  {
+    return(selectionStart != selectionEnd);
+  }
+
+  /**
+         * Returns the caret position. This will either be the selection
+         * start or the selection end, depending on which direction the
+         * selection was made in.
+         */
+  public final int getCaretPosition()
+  {
+    return (biasLeft ? selectionStart : selectionEnd);
+  }
+
+  /**
+         * Returns the caret line.
+         */
+  public final int getCaretLine()
+  {
+    return (biasLeft ? selectionStartLine : selectionEndLine);
+  }
+
+  /**
+         * Returns the mark position. This will be the opposite selection
+         * bound to the caret position.
+         * @see #getCaretPosition()
+         */
+  public final int getMarkPosition()
+  {
+    return (biasLeft ? selectionEnd : selectionStart);
+  }
+
+  /**
+         * Returns the mark line.
+         */
+  public final int getMarkLine()
+  {
+    return (biasLeft ? selectionEndLine : selectionStartLine);
+  }
+
+  /**
+         * Sets the caret position. The new selection will consist of the
+         * caret position only (hence no text will be selected)
+         * @param caret The caret position
+         * @see #select(int,int)
+         */
+  public final void setCaretPosition(int caret)
+  {
+    select(caret,caret);
+  }
+
+  /**
+         * Selects all text in the document.
+         */
+  public final void selectAll()
+  {
+    select(0,getDocumentLength());
+  }
+
+  /**
+         * Moves the mark to the caret position.
+         */
+  public final void selectNone()
+  {
+    select(getCaretPosition(),getCaretPosition());
+  }
+
+  /**
+         * Selects from the start offset to the end offset. This is the
+         * general selection method used by all other selecting methods.
+         * The caret position will be start if start &lt; end, and end
+         * if end &gt; start.
+         * @param start The start offset
+         * @param end The end offset
+         */
+  public void select(int start, int end)
+  {
+    int newStart, newEnd;
+    boolean newBias;
+    if(start <= end)
+      {
+        newStart = start;
+        newEnd = end;
+        newBias = false;
+      }
+    else
+      {
+        newStart = end;
+        newEnd = start;
+        newBias = true;
+      }
+
+    if(newStart < 0 || newEnd > getDocumentLength())
+      {
+        throw new IllegalArgumentException("Bounds out of"
+                                           + " range: " + newStart + "," +
+                                           newEnd);
+      }
+
+    // If the new position is the same as the old, we don't
+    // do all this crap, however we still do the stuff at
+    // the end (clearing magic position, scrolling)
+    if(newStart != selectionStart || newEnd != selectionEnd
+       || newBias != biasLeft)
+      {
+        int newStartLine = getLineOfOffset(newStart);
+        int newEndLine = getLineOfOffset(newEnd);
+
+        if(painter.isBracketHighlightEnabled())
+          {
+            if(bracketLine != -1)
+              painter.invalidateLine(bracketLine);
+            updateBracketHighlight(end);
+            if(bracketLine != -1)
+              painter.invalidateLine(bracketLine);
+          }
+
+        painter.invalidateLineRange(selectionStartLine,selectionEndLine);
+        painter.invalidateLineRange(newStartLine,newEndLine);
+
+        document.addUndoableEdit(new CaretUndo(
+                                               selectionStart,selectionEnd));
+
+        selectionStart = newStart;
+        selectionEnd = newEnd;
+        selectionStartLine = newStartLine;
+        selectionEndLine = newEndLine;
+        biasLeft = newBias;
+
+        fireCaretEvent();
+      }
+
+    // When the user is typing, etc, we don't want the caret
+    // to blink
+    blink = true;
+    caretTimer.restart();
+
+    // Disable rectangle select if selection start = selection end
+    if(selectionStart == selectionEnd)
+      rectSelect = false;
+
+    // Clear the `magic' caret position used by up/down
+    magicCaret = -1;
+
+    scrollToCaret();
+
+    // notify the line number feller
+    if (editorLineStatus != null) {
+      editorLineStatus.set(selectionStartLine, selectionEndLine);
+      //System.out.println("why " + selectionStartLine + " " + selectionEndLine);
+      //System.out.println(getLineOfOffset(start) + " " +
+      //                 getLineOfOffset(end));
+    }
+  }
+
+
+  /**
+         * Returns the selected text, or null if no selection is active.
+         */
+  public final String getSelectedText()
+  {
+    if(selectionStart == selectionEnd)
+      return null;
+
+    if(rectSelect)
+      {
+        // Return each row of the selection on a new line
+
+        Element map = document.getDefaultRootElement();
+
+        int start = selectionStart - map.getElement(selectionStartLine)
+          .getStartOffset();
+        int end = selectionEnd - map.getElement(selectionEndLine)
+          .getStartOffset();
+
+        // Certain rectangles satisfy this condition...
+        if(end < start)
+          {
+            int tmp = end;
+            end = start;
+            start = tmp;
+          }
+
+        StringBuffer buf = new StringBuffer();
+        Segment seg = new Segment();
+
+        for(int i = selectionStartLine; i <= selectionEndLine; i++)
+          {
+            Element lineElement = map.getElement(i);
+            int lineStart = lineElement.getStartOffset();
+            int lineEnd = lineElement.getEndOffset() - 1;
+            int lineLen = lineEnd - lineStart;
+
+            lineStart = Math.min(lineStart + start,lineEnd);
+            lineLen = Math.min(end - start,lineEnd - lineStart);
+
+            getText(lineStart,lineLen,seg);
+            buf.append(seg.array,seg.offset,seg.count);
+
+            if(i != selectionEndLine)
+              buf.append('\n');
+          }
+
+        return buf.toString();
+      }
+    else
+      {
+        return getText(selectionStart,
+                       selectionEnd - selectionStart);
+      }
+  }
+
+  /**
+   * Replaces the selection with the specified text.
+   * @param selectedText The replacement text for the selection
+   */
+  public void setSelectedText(String selectedText)
+  {
+    if(!editable)
+      {
+        throw new InternalError("Text component"
+                                + " read only");
+      }
+
+    document.beginCompoundEdit();
+
+    try
+      {
+        if(rectSelect)
+          {
+            Element map = document.getDefaultRootElement();
+
+            int start = selectionStart - map.getElement(selectionStartLine)
+              .getStartOffset();
+            int end = selectionEnd - map.getElement(selectionEndLine)
+              .getStartOffset();
+
+                                // Certain rectangles satisfy this condition...
+            if(end < start)
+              {
+                int tmp = end;
+                end = start;
+                start = tmp;
+              }
+
+            int lastNewline = 0;
+            int currNewline = 0;
+
+            for(int i = selectionStartLine; i <= selectionEndLine; i++)
+              {
+                Element lineElement = map.getElement(i);
+                int lineStart = lineElement.getStartOffset();
+                int lineEnd = lineElement.getEndOffset() - 1;
+                int rectStart = Math.min(lineEnd,lineStart + start);
+
+                document.remove(rectStart,Math.min(lineEnd - rectStart,
+                                                   end - start));
+
+                if(selectedText == null)
+                  continue;
+
+                currNewline = selectedText.indexOf('\n',lastNewline);
+                if(currNewline == -1)
+                  currNewline = selectedText.length();
+
+                document.insertString(rectStart,selectedText
+                                      .substring(lastNewline,currNewline),null);
+
+                lastNewline = Math.min(selectedText.length(),
+                                       currNewline + 1);
+              }
+
+            if(selectedText != null &&
+               currNewline != selectedText.length())
+              {
+                int offset = map.getElement(selectionEndLine)
+                  .getEndOffset() - 1;
+                document.insertString(offset,"\n",null);
+                document.insertString(offset + 1,selectedText
+                                      .substring(currNewline + 1),null);
+              }
+          }
+        else
+          {
+            document.remove(selectionStart,
+                            selectionEnd - selectionStart);
+            if(selectedText != null)
+              {
+                document.insertString(selectionStart,
+                                      selectedText,null);
+              }
+          }
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+        throw new InternalError("Cannot replace"
+                                + " selection");
+      }
+    // No matter what happends... stops us from leaving document
+    // in a bad state
+    finally
+      {
+        document.endCompoundEdit();
+      }
+
+    setCaretPosition(selectionEnd);
+  }
+
+  /**
+         * Returns true if this text area is editable, false otherwise.
+         */
+  public final boolean isEditable()
+  {
+    return editable;
+  }
+
+  /**
+         * Sets if this component is editable.
+         * @param editable True if this text area should be editable,
+         * false otherwise
+         */
+  public final void setEditable(boolean editable)
+  {
+    this.editable = editable;
+  }
+
+  /**
+         * Returns the right click popup menu.
+         */
+  public final JPopupMenu getRightClickPopup()
+  {
+    return popup;
+  }
+
+  /**
+         * Sets the right click popup menu.
+         * @param popup The popup
+         */
+  //public final void setRightClickPopup(EditPopupMenu popup)
+  public final void setRightClickPopup(JPopupMenu popup)
+  {
+    this.popup = popup;
+  }
+
+
+  /**
+   * Returns the `magic' caret position. This can be used to preserve
+   * the column position when moving up and down lines.
+   */
+  public final int getMagicCaretPosition()
+  {
+    return magicCaret;
+  }
+
+  /**
+         * Sets the `magic' caret position. This can be used to preserve
+         * the column position when moving up and down lines.
+         * @param magicCaret The magic caret position
+         */
+  public final void setMagicCaretPosition(int magicCaret)
+  {
+    this.magicCaret = magicCaret;
+  }
+
+  /**
+         * Similar to <code>setSelectedText()</code>, but overstrikes the
+         * appropriate number of characters if overwrite mode is enabled.
+         * @param str The string
+         * @see #setSelectedText(String)
+         * @see #isOverwriteEnabled()
+         */
+  public void overwriteSetSelectedText(String str)
+  {
+    // Don't overstrike if there is a selection
+    if(!overwrite || selectionStart != selectionEnd)
+      {
+        setSelectedText(str);
+        return;
+      }
+
+    // Don't overstrike if we're on the end of
+    // the line
+    int caret = getCaretPosition();
+    int caretLineEnd = getLineEndOffset(getCaretLine());
+    if(caretLineEnd - caret <= str.length())
+      {
+        setSelectedText(str);
+        return;
+      }
+
+    document.beginCompoundEdit();
+
+    try
+      {
+        document.remove(caret,str.length());
+        document.insertString(caret,str,null);
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+      }
+    finally
+      {
+        document.endCompoundEdit();
+      }
+  }
+
+  /**
+         * Returns true if overwrite mode is enabled, false otherwise.
+         */
+  public final boolean isOverwriteEnabled()
+  {
+    return overwrite;
+  }
+
+  /**
+         * Sets if overwrite mode should be enabled.
+         * @param overwrite True if overwrite mode should be enabled,
+         * false otherwise.
+         */
+  public final void setOverwriteEnabled(boolean overwrite)
+  {
+    this.overwrite = overwrite;
+    painter.invalidateSelectedLines();
+  }
+
+  /**
+         * Returns true if the selection is rectangular, false otherwise.
+         */
+  public final boolean isSelectionRectangular()
+  {
+    return rectSelect;
+  }
+
+  /**
+         * Sets if the selection should be rectangular.
+         * @param overwrite True if the selection should be rectangular,
+         * false otherwise.
+         */
+  public final void setSelectionRectangular(boolean rectSelect)
+  {
+    this.rectSelect = rectSelect;
+    painter.invalidateSelectedLines();
+  }
+
+  /**
+         * Returns the position of the highlighted bracket (the bracket
+         * matching the one before the caret)
+         */
+  public final int getBracketPosition()
+  {
+    return bracketPosition;
+  }
+
+  /**
+         * Returns the line of the highlighted bracket (the bracket
+         * matching the one before the caret)
+         */
+  public final int getBracketLine()
+  {
+    return bracketLine;
+  }
+
+  /**
+         * Adds a caret change listener to this text area.
+         * @param listener The listener
+         */
+  public final void addCaretListener(CaretListener listener)
+  {
+    eventListenerList.add(CaretListener.class,listener);
+  }
+
+  /**
+         * Removes a caret change listener from this text area.
+         * @param listener The listener
+         */
+  public final void removeCaretListener(CaretListener listener)
+  {
+    eventListenerList.remove(CaretListener.class,listener);
+  }
+
+  /**
+         * Deletes the selected text from the text area and places it
+         * into the clipboard.
+         */
+  public void cut()
+  {
+    if(editable)
+      {
+        copy();
+        setSelectedText("");
+      }
+  }
+
+  /**
+         * Places the selected text into the clipboard.
+         */
+  public void copy()
+  {
+    if(selectionStart != selectionEnd)
+      {
+        Clipboard clipboard = getToolkit().getSystemClipboard();
+
+        String selection = getSelectedText();
+
+        int repeatCount = inputHandler.getRepeatCount();
+        StringBuffer buf = new StringBuffer();
+        for(int i = 0; i < repeatCount; i++)
+          buf.append(selection);
+
+        clipboard.setContents(new StringSelection(buf.toString()),null);
+      }
+  }
+
+  /**
+   * Inserts the clipboard contents into the text.
+   */
+  public void paste() {
+    if (editable) {
+      Clipboard clipboard = getToolkit().getSystemClipboard();
+      try {
+        // The MacOS MRJ doesn't convert \r to \n, so do it here
+        String selection = ((String)clipboard.getContents(this).getTransferData(DataFlavor.stringFlavor)).replace('\r','\n');
+
+        // particularly on macosx when pasting from safari,
+        // replace unicode x00A0 (non-breaking space)
+        // with just a plain space. [fry 030929]
+        selection = selection.replace('\u00A0', ' ');
+
+        int repeatCount = inputHandler.getRepeatCount();
+        StringBuffer buf = new StringBuffer();
+        for (int i = 0; i < repeatCount; i++)
+          buf.append(selection);
+        selection = buf.toString();
+        setSelectedText(selection);
+
+      } catch(Exception e) {
+        getToolkit().beep();
+        System.err.println("Clipboard does not contain a string");
+      }
+    }
+  }
+
+  /**
+         * Called by the AWT when this component is removed from it's parent.
+         * This stops clears the currently focused component.
+         */
+  public void removeNotify()
+  {
+    super.removeNotify();
+    if(focusedComponent == this)
+      focusedComponent = null;
+  }
+
+  /**
+   * Forwards key events directly to the input handler.
+   * This is slightly faster than using a KeyListener
+   * because some Swing overhead is avoided.
+   */
+  public PdeEditorListener editorListener;
+
+  /**
+   * The component that tracks the current line number.
+   */
+  public PdeEditorLineStatus editorLineStatus;
+
+
+  public void processKeyEvent(KeyEvent evt) {
+    // this had to be added in Processing 007X, because the menu key
+    // events weren't making it up to the frame.
+    super.processKeyEvent(evt);
+
+    //System.out.println("jedittextarea: " + evt);
+    //System.out.println();
+    if (inputHandler == null) return;
+
+    switch(evt.getID()) {
+    case KeyEvent.KEY_TYPED:
+      inputHandler.keyTyped(evt);
+      break;
+    case KeyEvent.KEY_PRESSED:
+      if (!editorListener.keyPressed(evt)) {
+        inputHandler.keyPressed(evt);
+      }
+      break;
+    case KeyEvent.KEY_RELEASED:
+      inputHandler.keyReleased(evt);
+      break;
+    }
+  }
+
+  // protected members
+  protected static String CENTER = "center";
+  protected static String RIGHT = "right";
+  protected static String BOTTOM = "bottom";
+
+  protected static JEditTextArea focusedComponent;
+  protected static Timer caretTimer;
+
+  protected TextAreaPainter painter;
+
+  //protected EditPopupMenu popup;
+  protected JPopupMenu popup;
+
+  protected EventListenerList eventListenerList;
+  protected MutableCaretEvent caretEvent;
+
+  protected boolean caretBlinks;
+  protected boolean caretVisible;
+  protected boolean blink;
+
+  protected boolean editable;
+
+  protected int firstLine;
+  protected int visibleLines;
+  protected int electricScroll;
+
+  protected int horizontalOffset;
+
+  protected JScrollBar vertical;
+  protected JScrollBar horizontal;
+  protected boolean scrollBarsInitialized;
+
+  protected InputHandler inputHandler;
+  protected SyntaxDocument document;
+  protected DocumentHandler documentHandler;
+
+  protected Segment lineSegment;
+
+  protected int selectionStart;
+  protected int selectionStartLine;
+  protected int selectionEnd;
+  protected int selectionEndLine;
+  protected boolean biasLeft;
+
+  protected int bracketPosition;
+  protected int bracketLine;
+
+  protected int magicCaret;
+  protected boolean overwrite;
+  protected boolean rectSelect;
+
+
+  protected void fireCaretEvent()
+  {
+    Object[] listeners = eventListenerList.getListenerList();
+    for(int i = listeners.length - 2; i >= 0; i--)
+      {
+        if(listeners[i] == CaretListener.class)
+          {
+            ((CaretListener)listeners[i+1]).caretUpdate(caretEvent);
+          }
+      }
+  }
+
+  protected void updateBracketHighlight(int newCaretPosition)
+  {
+    if(newCaretPosition == 0)
+      {
+        bracketPosition = bracketLine = -1;
+        return;
+      }
+
+    try
+      {
+        int offset = TextUtilities.findMatchingBracket(
+                                                       document,newCaretPosition - 1);
+        if(offset != -1)
+          {
+            bracketLine = getLineOfOffset(offset);
+            bracketPosition = offset - getLineStartOffset(bracketLine);
+            return;
+          }
+      }
+    catch(BadLocationException bl)
+      {
+        bl.printStackTrace();
+      }
+
+    bracketLine = bracketPosition = -1;
+  }
+
+  protected void documentChanged(DocumentEvent evt)
+  {
+    DocumentEvent.ElementChange ch =
+      evt.getChange(document.getDefaultRootElement());
+
+    int count;
+    if(ch == null)
+      count = 0;
+    else
+      count = ch.getChildrenAdded().length -
+        ch.getChildrenRemoved().length;
+
+    int line = getLineOfOffset(evt.getOffset());
+    if(count == 0)
+      {
+        painter.invalidateLine(line);
+      }
+    // do magic stuff
+    else if(line < firstLine)
+      {
+        setFirstLine(firstLine + count);
+      }
+    // end of magic stuff
+    else
+      {
+        painter.invalidateLineRange(line,firstLine + visibleLines);
+        updateScrollBars();
+      }
+  }
+
+  class ScrollLayout implements LayoutManager
+  {
+    //final int LEFT_EXTRA = 5;
+
+    public void addLayoutComponent(String name, Component comp)
+    {
+      if(name.equals(CENTER))
+        center = comp;
+      else if(name.equals(RIGHT))
+        right = comp;
+      else if(name.equals(BOTTOM))
+        bottom = comp;
+      else if(name.equals(LEFT_OF_SCROLLBAR))
+        leftOfScrollBar.addElement(comp);
+    }
+
+    public void removeLayoutComponent(Component comp)
+    {
+      if(center == comp)
+        center = null;
+      if(right == comp)
+        right = null;
+      if(bottom == comp)
+        bottom = null;
+      else
+        leftOfScrollBar.removeElement(comp);
+    }
+
+    public Dimension preferredLayoutSize(Container parent)
+    {
+      Dimension dim = new Dimension();
+      Insets insets = getInsets();
+      dim.width = insets.left + insets.right;
+      dim.height = insets.top + insets.bottom;
+
+      Dimension centerPref = center.getPreferredSize();
+      dim.width += centerPref.width;
+      dim.height += centerPref.height;
+      Dimension rightPref = right.getPreferredSize();
+      dim.width += rightPref.width;
+      Dimension bottomPref = bottom.getPreferredSize();
+      dim.height += bottomPref.height;
+
+      return dim;
+    }
+
+    public Dimension minimumLayoutSize(Container parent)
+    {
+      Dimension dim = new Dimension();
+      Insets insets = getInsets();
+      dim.width = insets.left + insets.right;
+      dim.height = insets.top + insets.bottom;
+
+      Dimension centerPref = center.getMinimumSize();
+      dim.width += centerPref.width;
+      dim.height += centerPref.height;
+      Dimension rightPref = right.getMinimumSize();
+      dim.width += rightPref.width;
+      Dimension bottomPref = bottom.getMinimumSize();
+      dim.height += bottomPref.height;
+
+      dim.height += 5;
+
+      return dim;
+    }
+
+    public void layoutContainer(Container parent)
+    {
+      Dimension size = parent.getSize();
+      Insets insets = parent.getInsets();
+      int itop = insets.top;
+      int ileft = insets.left;
+      int ibottom = insets.bottom;
+      int iright = insets.right;
+
+      int rightWidth = right.getPreferredSize().width;
+      int bottomHeight = bottom.getPreferredSize().height;
+      int centerWidth = size.width - rightWidth - ileft - iright;
+      int centerHeight = size.height - bottomHeight - itop - ibottom;
+
+      center.setBounds(ileft, // + LEFT_EXTRA,
+                       itop,
+                       centerWidth, // - LEFT_EXTRA,
+                       centerHeight);
+
+      right.setBounds(ileft + centerWidth,
+                      itop,
+                      rightWidth,
+                      centerHeight);
+
+      // Lay out all status components, in order
+      Enumeration status = leftOfScrollBar.elements();
+      while (status.hasMoreElements()) {
+        Component comp = (Component)status.nextElement();
+        Dimension dim = comp.getPreferredSize();
+        comp.setBounds(ileft,
+                       itop + centerHeight,
+                       dim.width,
+                       bottomHeight);
+        ileft += dim.width;
+      }
+
+      bottom.setBounds(ileft,
+                       itop + centerHeight,
+                       size.width - rightWidth - ileft - iright,
+                       bottomHeight);
+    }
+
+    // private members
+    private Component center;
+    private Component right;
+    private Component bottom;
+    private Vector leftOfScrollBar = new Vector();
+  }
+
+  static class CaretBlinker implements ActionListener
+  {
+    public void actionPerformed(ActionEvent evt)
+    {
+      if(focusedComponent != null
+         && focusedComponent.hasFocus())
+        focusedComponent.blinkCaret();
+    }
+  }
+
+  class MutableCaretEvent extends CaretEvent
+  {
+    MutableCaretEvent()
+    {
+      super(JEditTextArea.this);
+    }
+
+    public int getDot()
+    {
+      return getCaretPosition();
+    }
+
+    public int getMark()
+    {
+      return getMarkPosition();
+    }
+  }
+
+/*
+#ifdef JDK14
+  class WheelHandler implements MouseWheelListener {
+
+    public void mouseWheelMoved(MouseWheelEvent e) {
+      if (!scrollBarsInitialized) return;
+
+      int amt = e.getWheelRotation();
+      //System.out.println(amt);
+      vertical.setValue(vertical.getValue() + amt * wheelMultiplier);
+    }
+  }
+#endif
+*/
+
+  class AdjustHandler implements AdjustmentListener
+  {
+    public void adjustmentValueChanged(final AdjustmentEvent evt)
+    {
+      if(!scrollBarsInitialized)
+        return;
+
+      // If this is not done, mousePressed events accumilate
+      // and the result is that scrolling doesn't stop after
+      // the mouse is released
+      SwingUtilities.invokeLater(new Runnable() {
+          public void run()
+          {
+            if(evt.getAdjustable() == vertical)
+              setFirstLine(vertical.getValue());
+            else
+              setHorizontalOffset(-horizontal.getValue());
+          }
+        });
+    }
+  }
+
+  class ComponentHandler extends ComponentAdapter
+  {
+    public void componentResized(ComponentEvent evt)
+    {
+      recalculateVisibleLines();
+      scrollBarsInitialized = true;
+    }
+  }
+
+  class DocumentHandler implements DocumentListener
+  {
+    public void insertUpdate(DocumentEvent evt)
+    {
+      documentChanged(evt);
+
+      int offset = evt.getOffset();
+      int length = evt.getLength();
+
+      int newStart;
+      int newEnd;
+
+      if (selectionStart > offset ||
+          (selectionStart == selectionEnd && selectionStart == offset))
+        newStart = selectionStart + length;
+      else
+        newStart = selectionStart;
+
+      if(selectionEnd >= offset)
+        newEnd = selectionEnd + length;
+      else
+        newEnd = selectionEnd;
+
+      select(newStart,newEnd);
+    }
+
+    public void removeUpdate(DocumentEvent evt)
+    {
+      documentChanged(evt);
+
+      int offset = evt.getOffset();
+      int length = evt.getLength();
+
+      int newStart;
+      int newEnd;
+
+      if(selectionStart > offset)
+        {
+          if(selectionStart > offset + length)
+            newStart = selectionStart - length;
+          else
+            newStart = offset;
+        }
+      else
+        newStart = selectionStart;
+
+      if(selectionEnd > offset)
+        {
+          if(selectionEnd > offset + length)
+            newEnd = selectionEnd - length;
+          else
+            newEnd = offset;
+        }
+      else
+        newEnd = selectionEnd;
+
+      select(newStart,newEnd);
+    }
+
+    public void changedUpdate(DocumentEvent evt)
+    {
+    }
+  }
+
+  class DragHandler implements MouseMotionListener
+  {
+    public void mouseDragged(MouseEvent evt)
+    {
+      if (popup != null && popup.isVisible()) return;
+
+      setSelectionRectangular((evt.getModifiers()
+                               & InputEvent.CTRL_MASK) != 0);
+      select(getMarkPosition(),xyToOffset(evt.getX(),evt.getY()));
+    }
+
+    public void mouseMoved(MouseEvent evt) {}
+  }
+
+  class FocusHandler implements FocusListener
+  {
+    public void focusGained(FocusEvent evt)
+    {
+      //System.out.println("JEditTextArea: focusGained");
+      setCaretVisible(true);
+      focusedComponent = JEditTextArea.this;
+    }
+
+    public void focusLost(FocusEvent evt)
+    {
+      //System.out.println("JEditTextArea: focusLost");
+      setCaretVisible(false);
+      focusedComponent = null;
+    }
+  }
+
+  class MouseHandler extends MouseAdapter
+  {
+    public void mousePressed(MouseEvent evt)
+    {
+      requestFocus();
+
+      // Focus events not fired sometimes?
+      setCaretVisible(true);
+      focusedComponent = JEditTextArea.this;
+
+      // isPopupTrigger wasn't working for danh on windows
+      boolean trigger = (evt.getModifiers() & InputEvent.BUTTON3_MASK) != 0;
+      // but it's required for macosx, since control-click does
+      // the same thing as a right-mouse click
+      if (!trigger && evt.isPopupTrigger()) trigger = true;
+
+      if (trigger && (popup != null)) {
+        popup.show(painter,evt.getX(),evt.getY());
+        return;
+      }
+
+      int line = yToLine(evt.getY());
+      int offset = xToOffset(line,evt.getX());
+      int dot = getLineStartOffset(line) + offset;
+
+      switch(evt.getClickCount()) {
+
+      case 1:
+        doSingleClick(evt,line,offset,dot);
+        break;
+
+      case 2:
+        // It uses the bracket matching stuff, so
+        // it can throw a BLE
+        try {
+          doDoubleClick(evt,line,offset,dot);
+        } catch(BadLocationException bl) {
+          bl.printStackTrace();
+        }
+        break;
+
+      case 3:
+        doTripleClick(evt,line,offset,dot);
+        break;
+      }
+    }
+
+
+    private void doSingleClick(MouseEvent evt, int line,
+                               int offset, int dot) {
+      if ((evt.getModifiers() & InputEvent.SHIFT_MASK) != 0) {
+        rectSelect = (evt.getModifiers() & InputEvent.CTRL_MASK) != 0;
+        select(getMarkPosition(),dot);
+      } else {
+        setCaretPosition(dot);
+      }
+    }
+
+
+    private void doDoubleClick(MouseEvent evt, int line,
+                               int offset, int dot) throws BadLocationException
+    {
+      // Ignore empty lines
+      if (getLineLength(line) == 0)
+        return;
+
+      try {
+        int bracket = TextUtilities.findMatchingBracket(document,
+                                                        Math.max(0,dot - 1));
+        if (bracket != -1) {
+          int mark = getMarkPosition();
+          // Hack
+          if (bracket > mark) {
+            bracket++;
+            mark--;
+          }
+          select(mark,bracket);
+          return;
+        }
+      } catch(BadLocationException bl) {
+        bl.printStackTrace();
+      }
+
+      // Ok, it's not a bracket... select the word
+      String lineText = getLineText(line);
+      char ch = lineText.charAt(Math.max(0,offset - 1));
+
+      String noWordSep = (String)document.getProperty("noWordSep");
+      if(noWordSep == null)
+        noWordSep = "";
+
+      // If the user clicked on a non-letter char,
+      // we select the surrounding non-letters
+      boolean selectNoLetter = (!Character
+                                .isLetterOrDigit(ch)
+                                && noWordSep.indexOf(ch) == -1);
+
+      int wordStart = 0;
+
+      for(int i = offset - 1; i >= 0; i--) {
+        ch = lineText.charAt(i);
+        if (selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
+                              noWordSep.indexOf(ch) == -1)) {
+          wordStart = i + 1;
+          break;
+        }
+      }
+
+      int wordEnd = lineText.length();
+      for(int i = offset; i < lineText.length(); i++)
+        {
+          ch = lineText.charAt(i);
+          if(selectNoLetter ^ (!Character
+                               .isLetterOrDigit(ch) &&
+                               noWordSep.indexOf(ch) == -1))
+            {
+              wordEnd = i;
+              break;
+            }
+        }
+
+      int lineStart = getLineStartOffset(line);
+      select(lineStart + wordStart,lineStart + wordEnd);
+
+      /*
+        String lineText = getLineText(line);
+        String noWordSep = (String)document.getProperty("noWordSep");
+        int wordStart = TextUtilities.findWordStart(lineText,offset,noWordSep);
+        int wordEnd = TextUtilities.findWordEnd(lineText,offset,noWordSep);
+
+        int lineStart = getLineStartOffset(line);
+        select(lineStart + wordStart,lineStart + wordEnd);
+      */
+    }
+
+    private void doTripleClick(MouseEvent evt, int line,
+                               int offset, int dot)
+    {
+      select(getLineStartOffset(line),getLineEndOffset(line)-1);
+    }
+  }
+
+  class CaretUndo extends AbstractUndoableEdit
+  {
+    private int start;
+    private int end;
+
+    CaretUndo(int start, int end)
+    {
+      this.start = start;
+      this.end = end;
+    }
+
+    public boolean isSignificant()
+    {
+      return false;
+    }
+
+    public String getPresentationName()
+    {
+      return "caret move";
+    }
+
+    public void undo() throws CannotUndoException
+    {
+      super.undo();
+
+      select(start,end);
+    }
+
+    public void redo() throws CannotRedoException
+    {
+      super.redo();
+
+      select(start,end);
+    }
+
+    public boolean addEdit(UndoableEdit edit)
+    {
+      if(edit instanceof CaretUndo)
+        {
+          CaretUndo cedit = (CaretUndo)edit;
+          start = cedit.start;
+          end = cedit.end;
+          cedit.die();
+
+          return true;
+        }
+      else
+        return false;
+    }
+  }
+
+  static
+  {
+    caretTimer = new Timer(500,new CaretBlinker());
+    caretTimer.setInitialDelay(500);
+    caretTimer.start();
+  }
+}
diff --git a/app/syntax/KeywordMap.java b/app/syntax/KeywordMap.java
new file mode 100644
index 000000000..c19b4a777
--- /dev/null
+++ b/app/syntax/KeywordMap.java
@@ -0,0 +1,140 @@
+/*
+ * KeywordMap.java - Fast keyword->id map
+ * Copyright (C) 1998, 1999 Slava Pestov
+ * Copyright (C) 1999 Mike Dillon
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.text.Segment;
+
+/**
+ * A <code>KeywordMap</code> is similar to a hashtable in that it maps keys
+ * to values. However, the `keys' are Swing segments. This allows lookups of
+ * text substrings without the overhead of creating a new string object.
+ * <p>
+ * This class is used by <code>CTokenMarker</code> to map keywords to ids.
+ *
+ * @author Slava Pestov, Mike Dillon
+ * @version $Id$
+ */
+public class KeywordMap
+{
+        /**
+         * Creates a new <code>KeywordMap</code>.
+         * @param ignoreCase True if keys are case insensitive
+         */
+        public KeywordMap(boolean ignoreCase)
+        {
+                this(ignoreCase, 52);
+                this.ignoreCase = ignoreCase;
+        }
+
+        /**
+         * Creates a new <code>KeywordMap</code>.
+         * @param ignoreCase True if the keys are case insensitive
+         * @param mapLength The number of `buckets' to create.
+         * A value of 52 will give good performance for most maps.
+         */
+        public KeywordMap(boolean ignoreCase, int mapLength)
+        {
+                this.mapLength = mapLength;
+                this.ignoreCase = ignoreCase;
+                map = new Keyword[mapLength];
+        }
+
+        /**
+         * Looks up a key.
+         * @param text The text segment
+         * @param offset The offset of the substring within the text segment
+         * @param length The length of the substring
+         */
+        public byte lookup(Segment text, int offset, int length)
+        {
+                if(length == 0)
+                        return Token.NULL;
+                Keyword k = map[getSegmentMapKey(text, offset, length)];
+                while(k != null)
+                {
+                        if(length != k.keyword.length)
+                        {
+                                k = k.next;
+                                continue;
+                        }
+                        if(SyntaxUtilities.regionMatches(ignoreCase,text,offset,
+                                k.keyword))
+                                return k.id;
+                        k = k.next;
+                }
+                return Token.NULL;
+        }
+
+        /**
+         * Adds a key-value mapping.
+         * @param keyword The key
+         * @Param id The value
+         */
+        public void add(String keyword, byte id)
+        {
+                int key = getStringMapKey(keyword);
+                map[key] = new Keyword(keyword.toCharArray(),id,map[key]);
+        }
+
+        /**
+         * Returns true if the keyword map is set to be case insensitive,
+         * false otherwise.
+         */
+        public boolean getIgnoreCase()
+        {
+                return ignoreCase;
+        }
+
+        /**
+         * Sets if the keyword map should be case insensitive.
+         * @param ignoreCase True if the keyword map should be case
+         * insensitive, false otherwise
+         */
+        public void setIgnoreCase(boolean ignoreCase)
+        {
+                this.ignoreCase = ignoreCase;
+        }
+
+        // protected members
+        protected int mapLength;
+
+        protected int getStringMapKey(String s)
+        {
+                return (Character.toUpperCase(s.charAt(0)) +
+                                Character.toUpperCase(s.charAt(s.length()-1)))
+                                % mapLength;
+        }
+
+        protected int getSegmentMapKey(Segment s, int off, int len)
+        {
+                return (Character.toUpperCase(s.array[off]) +
+                                Character.toUpperCase(s.array[off + len - 1]))
+                                % mapLength;
+        }
+
+        // private members
+        class Keyword
+        {
+                public Keyword(char[] keyword, byte id, Keyword next)
+                {
+                        this.keyword = keyword;
+                        this.id = id;
+                        this.next = next;
+                }
+
+                public char[] keyword;
+                public byte id;
+                public Keyword next;
+        }
+
+        private Keyword[] map;
+        private boolean ignoreCase;
+}
diff --git a/app/syntax/PdeEditorListener.java b/app/syntax/PdeEditorListener.java
new file mode 100644
index 000000000..6019a5663
--- /dev/null
+++ b/app/syntax/PdeEditorListener.java
@@ -0,0 +1,170 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  PdeEditorListener - filter key events for tab expansion/indent/etc
+  Part of the Processing project - http://processing.org
+
+  Except where noted, code is written by Ben Fry and
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software Foundation,
+  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+package processing.app.syntax;
+
+import processing.app.*;
+
+import java.awt.*;
+import java.awt.event.*;
+
+import javax.swing.*;
+import javax.swing.text.*;
+import javax.swing.event.*;
+
+
+public class PdeEditorListener {
+  PdeEditor editor;
+  JEditTextArea textarea;
+
+  boolean externalEditor;
+  boolean expandTabs;
+  String tabString;
+  boolean autoIndent;
+
+  int selectionStart, selectionEnd;
+  int position;
+
+
+  public PdeEditorListener(PdeEditor editor, JEditTextArea textarea) {
+    this.editor = editor;
+    this.textarea = textarea;
+
+    // let him know that i'm leechin'
+    textarea.editorListener = this;
+
+    applyPreferences();
+  }
+
+
+  public void applyPreferences() {
+    expandTabs = PdePreferences.getBoolean("editor.tabs.expand");
+    int tabSize = PdePreferences.getInteger("editor.tabs.size");
+    tabString = PdeEditor.EMPTY.substring(0, tabSize);
+    autoIndent = PdePreferences.getBoolean("editor.indent");
+    externalEditor = PdePreferences.getBoolean("editor.external");
+  }
+
+
+  //public void setExternalEditor(boolean externalEditor) {
+  //this.externalEditor = externalEditor;
+  //}
+
+
+  // called by JEditTextArea inside processKeyEvent
+  public boolean keyPressed(KeyEvent event) {
+    // don't do things if the textarea isn't editable
+    if (externalEditor) return false;
+
+    //deselect();  // this is for paren balancing
+    char c = event.getKeyChar();
+    int code = event.getKeyCode();
+
+    //System.out.println(c + " " + code + " " + event);
+    //System.out.println();
+
+    if ((event.getModifiers() & KeyEvent.META_MASK) != 0) {
+      //event.consume();  // does nothing
+      return false;
+    }
+
+    // TODO i don't like these accessors. clean em up later.
+    if (!editor.sketch.current.modified) {
+      if ((code == KeyEvent.VK_BACK_SPACE) || (code == KeyEvent.VK_TAB) ||
+          (code == KeyEvent.VK_ENTER) || ((c >= 32) && (c < 128))) {
+        editor.sketch.setModified();
+      }
+    }
+
+    switch ((int) c) {
+
+    case 9:  // expand tabs
+      if (expandTabs) {
+        //tc.replaceSelection(tabString);
+        textarea.setSelectedText(tabString);
+        event.consume();
+        return true;
+      }
+      break;
+
+    case 10:  // auto-indent
+    case 13:
+      if (autoIndent) {
+        char contents[] = textarea.getText().toCharArray();
+
+        // this is the position of the caret, if the textarea
+        // only used a single kind of line ending
+        int origIndex = textarea.getCaretPosition() - 1;
+
+        // walk through the array to the current caret position,
+        // and count how many weirdo windows line endings there are,
+        // which would be throwing off the caret position number
+        int offset = 0;
+        int realIndex = origIndex;
+        for (int i = 0; i < realIndex-1; i++) {
+          if ((contents[i] == 13) && (contents[i+1] == 10)) {
+            offset++;
+            realIndex++;
+          }
+        }
+
+        // back up until \r \r\n or \n.. @#($* cross platform
+
+        //System.out.println(origIndex + " offset = " + offset);
+        origIndex += offset; // ARGH!#(* WINDOWS#@($*
+
+        int index = origIndex;
+        int spaceCount = 0;
+        boolean finished = false;
+        while ((index != -1) && (!finished)) {
+          if ((contents[index] == 10) ||
+              (contents[index] == 13)) {
+            finished = true;
+            index++; // maybe ?
+          } else {
+            index--;  // new
+          }
+        }
+        while ((index < contents.length) && (index >= 0) &&
+               (contents[index++] == ' ')) {
+          spaceCount++;
+        }
+
+        // seems that \r is being inserted anyway
+        // so no need to insert the platform's line separator
+        String insertion = "\n" + PdeEditor.EMPTY.substring(0, spaceCount);
+        //tc.replaceSelection(insertion);
+        textarea.setSelectedText(insertion);
+        // microsoft vm version:
+        //tc.setCaretPosition(oldCarrot + insertion.length() - 1);
+        // sun vm version:
+        //      tc.setCaretPosition(oldCarrot + insertion.length());
+        event.consume();
+        return true;
+      }
+      break;
+    }
+    return false;
+  }
+}
diff --git a/app/PdeKeywords.java b/app/syntax/PdeKeywords.java
similarity index 94%
rename from app/PdeKeywords.java
rename to app/syntax/PdeKeywords.java
index bc7e6a410..29ed76b2f 100644
--- a/app/PdeKeywords.java
+++ b/app/syntax/PdeKeywords.java
@@ -2,10 +2,10 @@
 
 /*
   PdeKeywords - handles text coloring and links to html reference
-  Part of the Processing project - http://Proce55ing.net
+  Part of the Processing project - http://processing.org
 
-  Except where noted, code is written by Ben Fry and
-  Copyright (c) 2001-03 Massachusetts Institute of Technology
+  Copyright (c) 2004-05 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -22,6 +22,10 @@
   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
+package processing.app.syntax;
+
+import processing.app.*;
+
 import java.io.*;
 import java.util.*;
 
diff --git a/app/syntax/PdeTextAreaDefaults.java b/app/syntax/PdeTextAreaDefaults.java
new file mode 100644
index 000000000..afce340c4
--- /dev/null
+++ b/app/syntax/PdeTextAreaDefaults.java
@@ -0,0 +1,106 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+  PdeTextAreaDefaults - grabs font/color settings for the editor
+  Part of the Processing project - http://Proce55ing.net
+
+  Except where noted, code is written by Ben Fry
+  Copyright (c) 2001-03 Massachusetts Institute of Technology
+
+  This program is free software; you can redistribute it and/or modify
+  it under the terms of the GNU General Public License as published by
+  the Free Software Foundation; either version 2 of the License, or
+  (at your option) any later version.
+
+  This program is distributed in the hope that it will be useful,
+  but WITHOUT ANY WARRANTY; without even the implied warranty of
+  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+  GNU General Public License for more details.
+
+  You should have received a copy of the GNU General Public License
+  along with this program; if not, write to the Free Software Foundation,
+  Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
+*/
+
+package processing.app.syntax;
+
+import processing.app.*;
+
+
+public class PdeTextAreaDefaults extends TextAreaDefaults {
+
+  public PdeTextAreaDefaults() {
+
+    inputHandler = new DefaultInputHandler();
+    inputHandler.addDefaultKeyBindings();
+    document = new SyntaxDocument();
+    editable = true;
+    electricScroll = 3;
+
+    cols = 80;
+    rows = 15;
+
+
+    // moved from SyntaxUtilities
+    //DEFAULTS.styles = SyntaxUtilities.getDefaultSyntaxStyles();
+
+    styles = new SyntaxStyle[Token.ID_COUNT];
+
+    // comments
+    styles[Token.COMMENT1] = PdePreferences.getStyle("comment1");
+    styles[Token.COMMENT2] = PdePreferences.getStyle("comment2");
+
+    // abstract, final, private
+    styles[Token.KEYWORD1] = PdePreferences.getStyle("keyword1");
+
+    // beginShape, point, line
+    styles[Token.KEYWORD2] = PdePreferences.getStyle("keyword2");
+
+    // byte, char, short, color
+    styles[Token.KEYWORD3] = PdePreferences.getStyle("keyword3");
+
+    // constants: null, true, this, RGB, TWO_PI
+    styles[Token.LITERAL1] = PdePreferences.getStyle("literal1");
+
+    // p5 built in variables: mouseX, width, pixels
+    styles[Token.LITERAL2] = PdePreferences.getStyle("literal2");
+
+    // ??
+    styles[Token.LABEL] = PdePreferences.getStyle("label");
+
+    // + - = /
+    styles[Token.OPERATOR] = PdePreferences.getStyle("operator");
+
+    // area that's not in use by the text (replaced with tildes)
+    styles[Token.INVALID] = PdePreferences.getStyle("invalid");
+
+
+    // moved from TextAreaPainter
+
+    font = PdePreferences.getFont("editor.font");
+
+    fgcolor = PdePreferences.getColor("editor.fgcolor");
+    bgcolor = PdePreferences.getColor("editor.bgcolor");
+
+    caretVisible = true;
+    caretBlinks = PdePreferences.getBoolean("editor.caret.blink");
+    caretColor = PdePreferences.getColor("editor.caret.color");
+
+    selectionColor = PdePreferences.getColor("editor.selection.color");
+
+    lineHighlight =
+      PdePreferences.getBoolean("editor.linehighlight");
+    lineHighlightColor =
+      PdePreferences.getColor("editor.linehighlight.color");
+
+    bracketHighlight =
+      PdePreferences.getBoolean("editor.brackethighlight");
+    bracketHighlightColor =
+      PdePreferences.getColor("editor.brackethighlight.color");
+
+    eolMarkers = PdePreferences.getBoolean("editor.eolmarkers");
+    eolMarkerColor = PdePreferences.getColor("editor.eolmarkers.color");
+
+    paintInvalid = PdePreferences.getBoolean("editor.invalid");
+  }
+}
diff --git a/app/syntax/SyntaxDocument.java b/app/syntax/SyntaxDocument.java
new file mode 100644
index 000000000..25b50d69a
--- /dev/null
+++ b/app/syntax/SyntaxDocument.java
@@ -0,0 +1,166 @@
+/*
+ * SyntaxDocument.java - Document that can be tokenized
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.event.*;
+import javax.swing.text.*;
+import javax.swing.undo.UndoableEdit;
+
+/**
+ * A document implementation that can be tokenized by the syntax highlighting
+ * system.
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class SyntaxDocument extends PlainDocument
+{
+        /**
+         * Returns the token marker that is to be used to split lines
+         * of this document up into tokens. May return null if this
+         * document is not to be colorized.
+         */
+        public TokenMarker getTokenMarker()
+        {
+                return tokenMarker;
+        }
+
+        /**
+         * Sets the token marker that is to be used to split lines of
+         * this document up into tokens. May throw an exception if
+         * this is not supported for this type of document.
+         * @param tm The new token marker
+         */
+        public void setTokenMarker(TokenMarker tm)
+        {
+                tokenMarker = tm;
+                if(tm == null)
+                        return;
+                tokenMarker.insertLines(0,getDefaultRootElement()
+                        .getElementCount());
+                tokenizeLines();
+        }
+
+        /**
+         * Reparses the document, by passing all lines to the token
+         * marker. This should be called after the document is first
+         * loaded.
+         */
+        public void tokenizeLines()
+        {
+                tokenizeLines(0,getDefaultRootElement().getElementCount());
+        }
+
+        /**
+         * Reparses the document, by passing the specified lines to the
+         * token marker. This should be called after a large quantity of
+         * text is first inserted.
+         * @param start The first line to parse
+         * @param len The number of lines, after the first one to parse
+         */
+        public void tokenizeLines(int start, int len)
+        {
+                if(tokenMarker == null || !tokenMarker.supportsMultilineTokens())
+                        return;
+
+                Segment lineSegment = new Segment();
+                Element map = getDefaultRootElement();
+
+                len += start;
+
+                try
+                {
+                        for(int i = start; i < len; i++)
+                        {
+                                Element lineElement = map.getElement(i);
+                                int lineStart = lineElement.getStartOffset();
+                                getText(lineStart,lineElement.getEndOffset()
+                                        - lineStart - 1,lineSegment);
+                                tokenMarker.markTokens(lineSegment,i);
+                        }
+                }
+                catch(BadLocationException bl)
+                {
+                        bl.printStackTrace();
+                }
+        }
+
+        /**
+         * Starts a compound edit that can be undone in one operation.
+         * Subclasses that implement undo should override this method;
+         * this class has no undo functionality so this method is
+         * empty.
+         */
+        public void beginCompoundEdit() {}
+
+        /**
+         * Ends a compound edit that can be undone in one operation.
+         * Subclasses that implement undo should override this method;
+         * this class has no undo functionality so this method is
+         * empty.
+         */
+        public void endCompoundEdit() {}
+
+        /**
+         * Adds an undoable edit to this document's undo list. The edit
+         * should be ignored if something is currently being undone.
+         * @param edit The undoable edit
+         *
+         * @since jEdit 2.2pre1
+         */
+        public void addUndoableEdit(UndoableEdit edit) {}
+
+        // protected members
+        protected TokenMarker tokenMarker;
+
+        /**
+         * We overwrite this method to update the token marker
+         * state immediately so that any event listeners get a
+         * consistent token marker.
+         */
+        protected void fireInsertUpdate(DocumentEvent evt)
+        {
+                if(tokenMarker != null)
+                {
+                        DocumentEvent.ElementChange ch = evt.getChange(
+                                getDefaultRootElement());
+                        if(ch != null)
+                        {
+                                tokenMarker.insertLines(ch.getIndex() + 1,
+                                        ch.getChildrenAdded().length -
+                                        ch.getChildrenRemoved().length);
+                        }
+                }
+
+                super.fireInsertUpdate(evt);
+        }
+
+        /**
+         * We overwrite this method to update the token marker
+         * state immediately so that any event listeners get a
+         * consistent token marker.
+         */
+        protected void fireRemoveUpdate(DocumentEvent evt)
+        {
+                if(tokenMarker != null)
+                {
+                        DocumentEvent.ElementChange ch = evt.getChange(
+                                getDefaultRootElement());
+                        if(ch != null)
+                        {
+                                tokenMarker.deleteLines(ch.getIndex() + 1,
+                                        ch.getChildrenRemoved().length -
+                                        ch.getChildrenAdded().length);
+                        }
+                }
+
+                super.fireRemoveUpdate(evt);
+        }
+}
diff --git a/app/syntax/SyntaxStyle.java b/app/syntax/SyntaxStyle.java
new file mode 100644
index 000000000..000b40aef
--- /dev/null
+++ b/app/syntax/SyntaxStyle.java
@@ -0,0 +1,137 @@
+/*
+ * SyntaxStyle.java - A simple text style class
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import java.awt.*;
+import java.util.StringTokenizer;
+
+/**
+ * A simple text style class. It can specify the color, italic flag,
+ * and bold flag of a run of text.
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class SyntaxStyle
+{
+  /**
+   * Creates a new SyntaxStyle.
+   * @param color The text color
+   * @param italic True if the text should be italics
+   * @param bold True if the text should be bold
+   */
+  public SyntaxStyle(Color color, boolean italic, boolean bold)
+  {
+    this.color = color;
+    this.italic = italic;
+    this.bold = bold;
+  }
+
+  /**
+   * Returns the color specified in this style.
+   */
+  public Color getColor()
+  {
+    return color;
+  }
+
+  /**
+   * Returns true if no font styles are enabled.
+   */
+  public boolean isPlain()
+  {
+    return !(bold || italic);
+  }
+
+  /**
+   * Returns true if italics is enabled for this style.
+   */
+  public boolean isItalic()
+  {
+    return italic;
+  }
+
+  /**
+   * Returns true if boldface is enabled for this style.
+   */
+  public boolean isBold()
+  {
+    return bold;
+  }
+
+  /**
+   * Returns the specified font, but with the style's bold and
+   * italic flags applied.
+   */
+  public Font getStyledFont(Font font)
+  {
+    if(font == null)
+      throw new NullPointerException("font param must not"
+                                     + " be null");
+    if(font.equals(lastFont))
+      return lastStyledFont;
+    lastFont = font;
+    lastStyledFont = new Font(font.getFamily(),
+                              (bold ? Font.BOLD : 0)
+                              | (italic ? Font.ITALIC : 0),
+                              font.getSize());
+    return lastStyledFont;
+  }
+
+  /**
+   * Returns the font metrics for the styled font.
+   */
+  public FontMetrics getFontMetrics(Font font)
+  {
+    if(font == null)
+      throw new NullPointerException("font param must not"
+                                     + " be null");
+    if(font.equals(lastFont) && fontMetrics != null)
+      return fontMetrics;
+    lastFont = font;
+    lastStyledFont = new Font(font.getFamily(),
+                              (bold ? Font.BOLD : 0)
+                              | (italic ? Font.ITALIC : 0),
+                              font.getSize());
+    fontMetrics = Toolkit.getDefaultToolkit().getFontMetrics(
+                                                             lastStyledFont);
+    return fontMetrics;
+  }
+
+  /**
+   * Sets the foreground color and font of the specified graphics
+   * context to that specified in this style.
+   * @param gfx The graphics context
+   * @param font The font to add the styles to
+   */
+  public void setGraphicsFlags(Graphics gfx, Font font)
+  {
+    Font _font = getStyledFont(font);
+    gfx.setFont(_font);
+    gfx.setColor(color);
+  }
+
+  /**
+   * Returns a string representation of this object.
+   */
+  public String toString()
+  {
+    return getClass().getName() + "[color=" + color +
+      (italic ? ",italic" : "") +
+      (bold ? ",bold" : "") + "]";
+  }
+
+  // private members
+  private Color color;
+  private boolean italic;
+  private boolean bold;
+  private Font lastFont;
+  private Font lastStyledFont;
+  private FontMetrics fontMetrics;
+}
diff --git a/app/syntax/SyntaxUtilities.java b/app/syntax/SyntaxUtilities.java
new file mode 100644
index 000000000..6da021b52
--- /dev/null
+++ b/app/syntax/SyntaxUtilities.java
@@ -0,0 +1,163 @@
+/*
+ * SyntaxUtilities.java - Utility functions used by syntax colorizing
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.text.*;
+import java.awt.*;
+
+
+/**
+ * Class with several utility functions used by jEdit's syntax colorizing
+ * subsystem.
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class SyntaxUtilities
+{
+  /**
+   * Checks if a subregion of a <code>Segment</code> is equal to a
+   * string.
+   * @param ignoreCase True if case should be ignored, false otherwise
+   * @param text The segment
+   * @param offset The offset into the segment
+   * @param match The string to match
+   */
+  public static boolean regionMatches(boolean ignoreCase, Segment text,
+                                      int offset, String match)
+  {
+    int length = offset + match.length();
+    char[] textArray = text.array;
+    if(length > text.offset + text.count)
+      return false;
+    for(int i = offset, j = 0; i < length; i++, j++)
+      {
+        char c1 = textArray[i];
+        char c2 = match.charAt(j);
+        if(ignoreCase)
+          {
+            c1 = Character.toUpperCase(c1);
+            c2 = Character.toUpperCase(c2);
+          }
+        if(c1 != c2)
+          return false;
+      }
+    return true;
+  }
+
+
+  /**
+   * Checks if a subregion of a <code>Segment</code> is equal to a
+   * character array.
+   * @param ignoreCase True if case should be ignored, false otherwise
+   * @param text The segment
+   * @param offset The offset into the segment
+   * @param match The character array to match
+   */
+  public static boolean regionMatches(boolean ignoreCase, Segment text,
+                                      int offset, char[] match)
+  {
+    int length = offset + match.length;
+    char[] textArray = text.array;
+    if(length > text.offset + text.count)
+      return false;
+    for(int i = offset, j = 0; i < length; i++, j++)
+      {
+        char c1 = textArray[i];
+        char c2 = match[j];
+        if(ignoreCase)
+          {
+            c1 = Character.toUpperCase(c1);
+            c2 = Character.toUpperCase(c2);
+          }
+        if(c1 != c2)
+          return false;
+      }
+    return true;
+  }
+
+
+  /**
+   * Returns the default style table. This can be passed to the
+   * <code>setStyles()</code> method of <code>SyntaxDocument</code>
+   * to use the default syntax styles.
+   */
+  public static SyntaxStyle[] getDefaultSyntaxStyles()
+  {
+    SyntaxStyle[] styles = new SyntaxStyle[Token.ID_COUNT];
+
+    styles[Token.COMMENT1] = new SyntaxStyle(Color.black,true,false);
+    styles[Token.COMMENT2] = new SyntaxStyle(new Color(0x990033),true,false);
+    styles[Token.KEYWORD1] = new SyntaxStyle(Color.black,false,true);
+    styles[Token.KEYWORD2] = new SyntaxStyle(Color.magenta,false,false);
+    styles[Token.KEYWORD3] = new SyntaxStyle(new Color(0x009600),false,false);
+    styles[Token.LITERAL1] = new SyntaxStyle(new Color(0x650099),false,false);
+    styles[Token.LITERAL2] = new SyntaxStyle(new Color(0x650099),false,true);
+    styles[Token.LABEL] = new SyntaxStyle(new Color(0x990033),false,true);
+    styles[Token.OPERATOR] = new SyntaxStyle(Color.black,false,true);
+    styles[Token.INVALID] = new SyntaxStyle(Color.red,false,true);
+
+    return styles;
+  }
+
+
+  /**
+   * Paints the specified line onto the graphics context. Note that this
+   * method munges the offset and count values of the segment.
+   * @param line The line segment
+   * @param tokens The token list for the line
+   * @param styles The syntax style list
+   * @param expander The tab expander used to determine tab stops. May
+   * be null
+   * @param gfx The graphics context
+   * @param x The x co-ordinate
+   * @param y The y co-ordinate
+   * @return The x co-ordinate, plus the width of the painted string
+   */
+  public static int paintSyntaxLine(Segment line, Token tokens,
+                                    SyntaxStyle[] styles,
+                                    TabExpander expander, Graphics gfx,
+                                    int x, int y)
+  {
+    Font defaultFont = gfx.getFont();
+    Color defaultColor = gfx.getColor();
+
+    int offset = 0;
+    for(;;)
+      {
+        byte id = tokens.id;
+        if(id == Token.END)
+          break;
+
+        int length = tokens.length;
+        if(id == Token.NULL)
+          {
+            if(!defaultColor.equals(gfx.getColor()))
+              gfx.setColor(defaultColor);
+            if(!defaultFont.equals(gfx.getFont()))
+              gfx.setFont(defaultFont);
+          }
+        else
+          styles[id].setGraphicsFlags(gfx,defaultFont);
+
+        line.count = length;
+        x = Utilities.drawTabbedText(line,x,y,gfx,expander,0);
+        line.offset += length;
+        offset += length;
+
+        tokens = tokens.next;
+      }
+
+    return x;
+  }
+
+  // private members
+  private SyntaxUtilities() {}
+}
diff --git a/app/syntax/TextAreaDefaults.java b/app/syntax/TextAreaDefaults.java
new file mode 100644
index 000000000..c2e878578
--- /dev/null
+++ b/app/syntax/TextAreaDefaults.java
@@ -0,0 +1,90 @@
+/*
+ * TextAreaDefaults.java - Encapsulates default values for various settings
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import java.awt.*;
+//import javax.swing.JPopupMenu;
+
+/**
+ * Encapsulates default settings for a text area. This can be passed
+ * to the constructor once the necessary fields have been filled out.
+ * The advantage of doing this over calling lots of set() methods after
+ * creating the text area is that this method is faster.
+ */
+public class TextAreaDefaults
+{
+  private static TextAreaDefaults DEFAULTS;
+
+  public InputHandler inputHandler;
+  public SyntaxDocument document;
+  public boolean editable;
+
+  public boolean caretVisible;
+  public boolean caretBlinks;
+  public boolean blockCaret;
+  public int electricScroll;
+
+  public int cols;
+  public int rows;
+  public SyntaxStyle[] styles;
+  public Color caretColor;
+  public Color selectionColor;
+  public Color lineHighlightColor;
+  public boolean lineHighlight;
+  public Color bracketHighlightColor;
+  public boolean bracketHighlight;
+  public Color eolMarkerColor;
+  public boolean eolMarkers;
+  public boolean paintInvalid;
+
+
+  // moved from TextAreaPainter [fry]
+  public Font font;
+  public Color fgcolor;
+  public Color bgcolor;
+
+  //public JPopupMenu popup;
+
+
+  /**
+   * Returns a new TextAreaDefaults object with the default values filled
+   * in.
+   */
+  public static TextAreaDefaults getDefaults()
+  {
+    if (DEFAULTS == null) {
+      DEFAULTS = new TextAreaDefaults();
+
+      DEFAULTS.inputHandler = new DefaultInputHandler();
+      DEFAULTS.inputHandler.addDefaultKeyBindings();
+      DEFAULTS.document = new SyntaxDocument();
+      DEFAULTS.editable = true;
+
+      DEFAULTS.caretVisible = true;
+      DEFAULTS.caretBlinks = true;
+      DEFAULTS.electricScroll = 3;
+
+      DEFAULTS.cols = 80;
+      DEFAULTS.rows = 25;
+      DEFAULTS.styles = SyntaxUtilities.getDefaultSyntaxStyles();
+      DEFAULTS.caretColor = Color.red;
+      DEFAULTS.selectionColor = new Color(0xccccff);
+      DEFAULTS.lineHighlightColor = new Color(0xe0e0e0);
+      DEFAULTS.lineHighlight = true;
+      DEFAULTS.bracketHighlightColor = Color.black;
+      DEFAULTS.bracketHighlight = true;
+      DEFAULTS.eolMarkerColor = new Color(0x009999);
+      DEFAULTS.eolMarkers = true;
+      DEFAULTS.paintInvalid = true;
+    }
+
+    return DEFAULTS;
+  }
+}
diff --git a/app/syntax/TextAreaPainter.java b/app/syntax/TextAreaPainter.java
new file mode 100644
index 000000000..4fe91e8e9
--- /dev/null
+++ b/app/syntax/TextAreaPainter.java
@@ -0,0 +1,680 @@
+/* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
+
+/*
+ * TextAreaPainter.java - Paints the text area
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import processing.app.*;
+
+import javax.swing.ToolTipManager;
+import javax.swing.text.*;
+import javax.swing.JComponent;
+import java.awt.event.MouseEvent;
+import java.awt.*;
+
+/**
+ * The text area repaint manager. It performs double buffering and paints
+ * lines of text.
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class TextAreaPainter extends JComponent implements TabExpander
+{
+  /**
+   * Creates a new repaint manager. This should be not be called
+   * directly.
+   */
+  public TextAreaPainter(JEditTextArea textArea, TextAreaDefaults defaults)
+  {
+    this.textArea = textArea;
+
+    setAutoscrolls(true);
+    setDoubleBuffered(true);
+    setOpaque(true);
+
+    ToolTipManager.sharedInstance().registerComponent(this);
+
+    currentLine = new Segment();
+    currentLineIndex = -1;
+
+    setCursor(Cursor.getPredefinedCursor(Cursor.TEXT_CURSOR));
+
+    setFont(defaults.font);
+    setForeground(defaults.fgcolor);
+    setBackground(defaults.bgcolor);
+
+    blockCaret = defaults.blockCaret;
+    styles = defaults.styles;
+    cols = defaults.cols;
+    rows = defaults.rows;
+    caretColor = defaults.caretColor;
+    selectionColor = defaults.selectionColor;
+    lineHighlightColor = defaults.lineHighlightColor;
+    lineHighlight = defaults.lineHighlight;
+    bracketHighlightColor = defaults.bracketHighlightColor;
+    bracketHighlight = defaults.bracketHighlight;
+    paintInvalid = defaults.paintInvalid;
+    eolMarkerColor = defaults.eolMarkerColor;
+    eolMarkers = defaults.eolMarkers;
+  }
+
+  /**
+   * Returns if this component can be traversed by pressing the
+   * Tab key. This returns false.
+   */
+  public final boolean isManagingFocus()
+  {
+    return false;
+  }
+
+  /**
+   * Returns the syntax styles used to paint colorized text. Entry <i>n</i>
+   * will be used to paint tokens with id = <i>n</i>.
+   * @see org.gjt.sp.jedit.syntax.Token
+   */
+  public final SyntaxStyle[] getStyles()
+  {
+    return styles;
+  }
+
+  /**
+   * Sets the syntax styles used to paint colorized text. Entry <i>n</i>
+   * will be used to paint tokens with id = <i>n</i>.
+   * @param styles The syntax styles
+   * @see org.gjt.sp.jedit.syntax.Token
+   */
+  public final void setStyles(SyntaxStyle[] styles)
+  {
+    this.styles = styles;
+    repaint();
+  }
+
+  /**
+   * Returns the caret color.
+   */
+  public final Color getCaretColor()
+  {
+    return caretColor;
+  }
+
+  /**
+   * Sets the caret color.
+   * @param caretColor The caret color
+   */
+  public final void setCaretColor(Color caretColor)
+  {
+    this.caretColor = caretColor;
+    invalidateSelectedLines();
+  }
+
+  /**
+   * Returns the selection color.
+   */
+  public final Color getSelectionColor()
+  {
+    return selectionColor;
+  }
+
+  /**
+   * Sets the selection color.
+   * @param selectionColor The selection color
+   */
+  public final void setSelectionColor(Color selectionColor)
+  {
+    this.selectionColor = selectionColor;
+    invalidateSelectedLines();
+  }
+
+  /**
+   * Returns the line highlight color.
+   */
+  public final Color getLineHighlightColor()
+  {
+    return lineHighlightColor;
+  }
+
+  /**
+   * Sets the line highlight color.
+   * @param lineHighlightColor The line highlight color
+   */
+  public final void setLineHighlightColor(Color lineHighlightColor)
+  {
+    this.lineHighlightColor = lineHighlightColor;
+    invalidateSelectedLines();
+  }
+
+  /**
+   * Returns true if line highlight is enabled, false otherwise.
+   */
+  public final boolean isLineHighlightEnabled()
+  {
+    return lineHighlight;
+  }
+
+  /**
+   * Enables or disables current line highlighting.
+   * @param lineHighlight True if current line highlight
+   * should be enabled, false otherwise
+   */
+  public final void setLineHighlightEnabled(boolean lineHighlight)
+  {
+    this.lineHighlight = lineHighlight;
+    invalidateSelectedLines();
+  }
+
+  /**
+   * Returns the bracket highlight color.
+   */
+  public final Color getBracketHighlightColor()
+  {
+    return bracketHighlightColor;
+  }
+
+  /**
+   * Sets the bracket highlight color.
+   * @param bracketHighlightColor The bracket highlight color
+   */
+  public final void setBracketHighlightColor(Color bracketHighlightColor)
+  {
+    this.bracketHighlightColor = bracketHighlightColor;
+    invalidateLine(textArea.getBracketLine());
+  }
+
+  /**
+   * Returns true if bracket highlighting is enabled, false otherwise.
+   * When bracket highlighting is enabled, the bracket matching the
+   * one before the caret (if any) is highlighted.
+   */
+  public final boolean isBracketHighlightEnabled()
+  {
+    return bracketHighlight;
+  }
+
+  /**
+   * Enables or disables bracket highlighting.
+   * When bracket highlighting is enabled, the bracket matching the
+   * one before the caret (if any) is highlighted.
+   * @param bracketHighlight True if bracket highlighting should be
+   * enabled, false otherwise
+   */
+  public final void setBracketHighlightEnabled(boolean bracketHighlight)
+  {
+    this.bracketHighlight = bracketHighlight;
+    invalidateLine(textArea.getBracketLine());
+  }
+
+  /**
+   * Returns true if the caret should be drawn as a block, false otherwise.
+   */
+  public final boolean isBlockCaretEnabled()
+  {
+    return blockCaret;
+  }
+
+  /**
+   * Sets if the caret should be drawn as a block, false otherwise.
+   * @param blockCaret True if the caret should be drawn as a block,
+   * false otherwise.
+   */
+  public final void setBlockCaretEnabled(boolean blockCaret)
+  {
+    this.blockCaret = blockCaret;
+    invalidateSelectedLines();
+  }
+
+  /**
+   * Returns the EOL marker color.
+   */
+  public final Color getEOLMarkerColor()
+  {
+    return eolMarkerColor;
+  }
+
+  /**
+   * Sets the EOL marker color.
+   * @param eolMarkerColor The EOL marker color
+   */
+  public final void setEOLMarkerColor(Color eolMarkerColor)
+  {
+    this.eolMarkerColor = eolMarkerColor;
+    repaint();
+  }
+
+  /**
+   * Returns true if EOL markers are drawn, false otherwise.
+   */
+  public final boolean getEOLMarkersPainted()
+  {
+    return eolMarkers;
+  }
+
+  /**
+   * Sets if EOL markers are to be drawn.
+   * @param eolMarkers True if EOL markers should be drawn, false otherwise
+   */
+  public final void setEOLMarkersPainted(boolean eolMarkers)
+  {
+    this.eolMarkers = eolMarkers;
+    repaint();
+  }
+
+  /**
+   * Returns true if invalid lines are painted as red tildes (~),
+   * false otherwise.
+   */
+  public boolean getInvalidLinesPainted()
+  {
+    return paintInvalid;
+  }
+
+  /**
+   * Sets if invalid lines are to be painted as red tildes.
+   * @param paintInvalid True if invalid lines should be drawn, false otherwise
+   */
+  public void setInvalidLinesPainted(boolean paintInvalid)
+  {
+    this.paintInvalid = paintInvalid;
+  }
+
+  /**
+   * Adds a custom highlight painter.
+   * @param highlight The highlight
+   */
+  public void addCustomHighlight(Highlight highlight)
+  {
+    highlight.init(textArea,highlights);
+    highlights = highlight;
+  }
+
+  /**
+   * Highlight interface.
+   */
+  public interface Highlight
+  {
+    /**
+     * Called after the highlight painter has been added.
+     * @param textArea The text area
+     * @param next The painter this one should delegate to
+     */
+    void init(JEditTextArea textArea, Highlight next);
+
+    /**
+     * This should paint the highlight and delgate to the
+     * next highlight painter.
+     * @param gfx The graphics context
+     * @param line The line number
+     * @param y The y co-ordinate of the line
+     */
+    void paintHighlight(Graphics gfx, int line, int y);
+
+    /**
+     * Returns the tool tip to display at the specified
+     * location. If this highlighter doesn't know what to
+     * display, it should delegate to the next highlight
+     * painter.
+     * @param evt The mouse event
+     */
+    String getToolTipText(MouseEvent evt);
+  }
+
+  /**
+   * Returns the tool tip to display at the specified location.
+   * @param evt The mouse event
+   */
+  public String getToolTipText(MouseEvent evt)
+  {
+    if(highlights != null)
+      return highlights.getToolTipText(evt);
+    else
+      return null;
+  }
+
+  /**
+   * Returns the font metrics used by this component.
+   */
+  public FontMetrics getFontMetrics()
+  {
+    return fm;
+  }
+
+  /**
+   * Sets the font for this component. This is overridden to update the
+   * cached font metrics and to recalculate which lines are visible.
+   * @param font The font
+   */
+  public void setFont(Font font)
+  {
+    super.setFont(font);
+    fm = Toolkit.getDefaultToolkit().getFontMetrics(font);
+    textArea.recalculateVisibleLines();
+  }
+
+  /**
+   * Repaints the text.
+   * @param g The graphics context
+   */
+  public void paint(Graphics gfx)
+  {
+    if (PdeBase.isMacOS()) {
+      Graphics2D g2 = (Graphics2D) gfx;
+      g2.setRenderingHint(RenderingHints.KEY_TEXT_ANTIALIASING,
+                          RenderingHints.VALUE_TEXT_ANTIALIAS_OFF);
+    }
+
+    tabSize = fm.charWidth(' ') * ((Integer)textArea.getDocument().getProperty(PlainDocument.tabSizeAttribute)).intValue();
+
+    Rectangle clipRect = gfx.getClipBounds();
+
+    gfx.setColor(getBackground());
+    gfx.fillRect(clipRect.x,clipRect.y,clipRect.width,clipRect.height);
+
+    // We don't use yToLine() here because that method doesn't
+    // return lines past the end of the document
+    int height = fm.getHeight();
+    int firstLine = textArea.getFirstLine();
+    int firstInvalid = firstLine + clipRect.y / height;
+    // Because the clipRect's height is usually an even multiple
+    // of the font height, we subtract 1 from it, otherwise one
+    // too many lines will always be painted.
+    int lastInvalid = firstLine + (clipRect.y + clipRect.height - 1) / height;
+
+    try {
+      TokenMarker tokenMarker = textArea.getDocument().getTokenMarker();
+      int x = textArea.getHorizontalOffset();
+
+      for (int line = firstInvalid; line <= lastInvalid; line++) {
+        paintLine(gfx,tokenMarker,line,x);
+      }
+
+      if (tokenMarker != null && tokenMarker.isNextLineRequested()) {
+        int h = clipRect.y + clipRect.height;
+        repaint(0,h,getWidth(),getHeight() - h);
+      }
+    } catch (Exception e) {
+      System.err.println("Error repainting line"
+                         + " range {" + firstInvalid + ","
+                         + lastInvalid + "}:");
+      e.printStackTrace();
+    }
+  }
+
+  /**
+   * Marks a line as needing a repaint.
+   * @param line The line to invalidate
+   */
+  public final void invalidateLine(int line)
+  {
+    repaint(0,textArea.lineToY(line) + fm.getMaxDescent() + fm.getLeading(),
+            getWidth(),fm.getHeight());
+  }
+
+  /**
+   * Marks a range of lines as needing a repaint.
+   * @param firstLine The first line to invalidate
+   * @param lastLine The last line to invalidate
+   */
+  public final void invalidateLineRange(int firstLine, int lastLine)
+  {
+    repaint(0,textArea.lineToY(firstLine) +
+            fm.getMaxDescent() + fm.getLeading(),
+            getWidth(),(lastLine - firstLine + 1) * fm.getHeight());
+  }
+
+  /**
+   * Repaints the lines containing the selection.
+   */
+  public final void invalidateSelectedLines()
+  {
+    invalidateLineRange(textArea.getSelectionStartLine(),
+                        textArea.getSelectionEndLine());
+  }
+
+  /**
+   * Implementation of TabExpander interface. Returns next tab stop after
+   * a specified point.
+   * @param x The x co-ordinate
+   * @param tabOffset Ignored
+   * @return The next tab stop after <i>x</i>
+   */
+  public float nextTabStop(float x, int tabOffset)
+  {
+    int offset = textArea.getHorizontalOffset();
+    int ntabs = ((int)x - offset) / tabSize;
+    return (ntabs + 1) * tabSize + offset;
+  }
+
+  /**
+   * Returns the painter's preferred size.
+   */
+  public Dimension getPreferredSize()
+  {
+    Dimension dim = new Dimension();
+    dim.width = fm.charWidth('w') * cols;
+    dim.height = fm.getHeight() * rows;
+    return dim;
+  }
+
+
+  /**
+   * Returns the painter's minimum size.
+   */
+  public Dimension getMinimumSize()
+  {
+    return getPreferredSize();
+  }
+
+  // package-private members
+  int currentLineIndex;
+  Token currentLineTokens;
+  Segment currentLine;
+
+  // protected members
+  protected JEditTextArea textArea;
+
+  protected SyntaxStyle[] styles;
+  protected Color caretColor;
+  protected Color selectionColor;
+  protected Color lineHighlightColor;
+  protected Color bracketHighlightColor;
+  protected Color eolMarkerColor;
+
+  protected boolean blockCaret;
+  protected boolean lineHighlight;
+  protected boolean bracketHighlight;
+  protected boolean paintInvalid;
+  protected boolean eolMarkers;
+  protected int cols;
+  protected int rows;
+
+  protected int tabSize;
+  protected FontMetrics fm;
+
+  protected Highlight highlights;
+
+  protected void paintLine(Graphics gfx, TokenMarker tokenMarker,
+                           int line, int x)
+  {
+    Font defaultFont = getFont();
+    Color defaultColor = getForeground();
+
+    currentLineIndex = line;
+    int y = textArea.lineToY(line);
+
+    if (line < 0 || line >= textArea.getLineCount()) {
+      if (paintInvalid) {
+        paintHighlight(gfx,line,y);
+        styles[Token.INVALID].setGraphicsFlags(gfx,defaultFont);
+        gfx.drawString("~",0,y + fm.getHeight());
+      }
+    } else if(tokenMarker == null) {
+      paintPlainLine(gfx,line,defaultFont,defaultColor,x,y);
+    } else {
+      paintSyntaxLine(gfx,tokenMarker,line,defaultFont,
+                      defaultColor,x,y);
+    }
+  }
+
+  protected void paintPlainLine(Graphics gfx, int line, Font defaultFont,
+                                Color defaultColor, int x, int y)
+  {
+    paintHighlight(gfx,line,y);
+    textArea.getLineText(line,currentLine);
+
+    gfx.setFont(defaultFont);
+    gfx.setColor(defaultColor);
+
+    y += fm.getHeight();
+    x = Utilities.drawTabbedText(currentLine,x,y,gfx,this,0);
+
+    if (eolMarkers) {
+      gfx.setColor(eolMarkerColor);
+      gfx.drawString(".",x,y);
+    }
+  }
+
+  protected void paintSyntaxLine(Graphics gfx, TokenMarker tokenMarker,
+                                 int line, Font defaultFont,
+                                 Color defaultColor, int x, int y)
+  {
+    textArea.getLineText(currentLineIndex,currentLine);
+    currentLineTokens = tokenMarker.markTokens(currentLine,
+                                               currentLineIndex);
+
+    paintHighlight(gfx,line,y);
+
+    gfx.setFont(defaultFont);
+    gfx.setColor(defaultColor);
+    y += fm.getHeight();
+    x = SyntaxUtilities.paintSyntaxLine(currentLine,
+                                        currentLineTokens,
+                                        styles, this, gfx, x, y);
+
+    if (eolMarkers) {
+      gfx.setColor(eolMarkerColor);
+      gfx.drawString(".",x,y);
+    }
+  }
+
+  protected void paintHighlight(Graphics gfx, int line, int y)
+  {
+    if (line >= textArea.getSelectionStartLine()
+        && line <= textArea.getSelectionEndLine())
+      paintLineHighlight(gfx,line,y);
+
+    if (highlights != null)
+      highlights.paintHighlight(gfx,line,y);
+
+    if (bracketHighlight && line == textArea.getBracketLine())
+      paintBracketHighlight(gfx,line,y);
+
+    if (line == textArea.getCaretLine())
+      paintCaret(gfx,line,y);
+  }
+
+  protected void paintLineHighlight(Graphics gfx, int line, int y)
+  {
+    int height = fm.getHeight();
+    y += fm.getLeading() + fm.getMaxDescent();
+
+    int selectionStart = textArea.getSelectionStart();
+    int selectionEnd = textArea.getSelectionEnd();
+
+    if (selectionStart == selectionEnd) {
+      if (lineHighlight) {
+        gfx.setColor(lineHighlightColor);
+        gfx.fillRect(0,y,getWidth(),height);
+      }
+    } else {
+      gfx.setColor(selectionColor);
+
+      int selectionStartLine = textArea.getSelectionStartLine();
+      int selectionEndLine = textArea.getSelectionEndLine();
+      int lineStart = textArea.getLineStartOffset(line);
+
+      int x1, x2;
+      if (textArea.isSelectionRectangular()) {
+        int lineLen = textArea.getLineLength(line);
+        x1 = textArea._offsetToX(line,Math.min(lineLen, selectionStart - textArea.getLineStartOffset(selectionStartLine)));
+        x2 = textArea._offsetToX(line,Math.min(lineLen, selectionEnd - textArea.getLineStartOffset(selectionEndLine)));
+        if (x1 == x2)
+          x2++;
+      } else if(selectionStartLine == selectionEndLine) {
+        x1 = textArea._offsetToX(line, selectionStart - lineStart);
+        x2 = textArea._offsetToX(line, selectionEnd - lineStart);
+      } else if(line == selectionStartLine) {
+        x1 = textArea._offsetToX(line, selectionStart - lineStart);
+        x2 = getWidth();
+      } else if(line == selectionEndLine) {
+        x1 = 0;
+        x2 = textArea._offsetToX(line, selectionEnd - lineStart);
+      } else {
+        x1 = 0;
+        x2 = getWidth();
+      }
+
+      // "inlined" min/max()
+      gfx.fillRect(x1 > x2 ? x2 : x1,y,x1 > x2 ?
+                   (x1 - x2) : (x2 - x1),height);
+    }
+
+  }
+
+  protected void paintBracketHighlight(Graphics gfx, int line, int y)
+  {
+    int position = textArea.getBracketPosition();
+    if(position == -1)
+      return;
+    y += fm.getLeading() + fm.getMaxDescent();
+    int x = textArea._offsetToX(line,position);
+    gfx.setColor(bracketHighlightColor);
+    // Hack!!! Since there is no fast way to get the character
+    // from the bracket matching routine, we use ( since all
+    // brackets probably have the same width anyway
+    gfx.drawRect(x,y,fm.charWidth('(') - 1,
+                 fm.getHeight() - 1);
+  }
+
+  protected void paintCaret(Graphics gfx, int line, int y)
+  {
+    //System.out.println("painting caret " + line + " " + y);
+    if (textArea.isCaretVisible()) {
+      //System.out.println("caret is visible");
+      int offset =
+        textArea.getCaretPosition() - textArea.getLineStartOffset(line);
+      int caretX = textArea._offsetToX(line, offset);
+      int caretWidth = ((blockCaret ||
+                         textArea.isOverwriteEnabled()) ?
+                        fm.charWidth('w') : 1);
+      y += fm.getLeading() + fm.getMaxDescent();
+      int height = fm.getHeight();
+
+      //System.out.println("caretX, width = " + caretX + " " + caretWidth);
+
+      gfx.setColor(caretColor);
+
+      if (textArea.isOverwriteEnabled()) {
+        gfx.fillRect(caretX,y + height - 1, caretWidth,1);
+
+      } else {
+        // some machines don't like the drawRect for the single
+        // pixel caret.. this caused a lot of hell because on that
+        // minority of machines, the caret wouldn't show up past
+        // the first column. the fix is to use drawLine() in
+        // those cases, as a workaround.
+        if (caretWidth == 1) {
+          gfx.drawLine(caretX, y, caretX, y + height - 1);
+        } else {
+          gfx.drawRect(caretX, y, caretWidth - 1, height - 1);
+        }
+        //gfx.drawRect(caretX, y, caretWidth, height - 1);
+      }
+    }
+  }
+}
diff --git a/app/syntax/TextUtilities.java b/app/syntax/TextUtilities.java
new file mode 100644
index 000000000..29db67716
--- /dev/null
+++ b/app/syntax/TextUtilities.java
@@ -0,0 +1,184 @@
+/*
+ * TextUtilities.java - Utility functions used by the text area classes
+ * Copyright (C) 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.text.*;
+
+/**
+ * Class with several utility functions used by the text area component.
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class TextUtilities
+{
+        /**
+         * Returns the offset of the bracket matching the one at the
+         * specified offset of the document, or -1 if the bracket is
+         * unmatched (or if the character is not a bracket).
+         * @param doc The document
+         * @param offset The offset
+         * @exception BadLocationException If an out-of-bounds access
+         * was attempted on the document text
+         */
+        public static int findMatchingBracket(Document doc, int offset)
+                throws BadLocationException
+        {
+                if(doc.getLength() == 0)
+                        return -1;
+                char c = doc.getText(offset,1).charAt(0);
+                char cprime; // c` - corresponding character
+                boolean direction; // true = back, false = forward
+
+                switch(c)
+                {
+                case '(': cprime = ')'; direction = false; break;
+                case ')': cprime = '('; direction = true; break;
+                case '[': cprime = ']'; direction = false; break;
+                case ']': cprime = '['; direction = true; break;
+                case '{': cprime = '}'; direction = false; break;
+                case '}': cprime = '{'; direction = true; break;
+                default: return -1;
+                }
+
+                int count;
+
+                // How to merge these two cases is left as an exercise
+                // for the reader.
+
+                // Go back or forward
+                if(direction)
+                {
+                        // Count is 1 initially because we have already
+                        // `found' one closing bracket
+                        count = 1;
+
+                        // Get text[0,offset-1];
+                        String text = doc.getText(0,offset);
+
+                        // Scan backwards
+                        for(int i = offset - 1; i >= 0; i--)
+                        {
+                                // If text[i] == c, we have found another
+                                // closing bracket, therefore we will need
+                                // two opening brackets to complete the
+                                // match.
+                                char x = text.charAt(i);
+                                if(x == c)
+                                        count++;
+
+                                // If text[i] == cprime, we have found a
+                                // opening bracket, so we return i if
+                                // --count == 0
+                                else if(x == cprime)
+                                {
+                                        if(--count == 0)
+                                                return i;
+                                }
+                        }
+                }
+                else
+                {
+                        // Count is 1 initially because we have already
+                        // `found' one opening bracket
+                        count = 1;
+
+                        // So we don't have to + 1 in every loop
+                        offset++;
+
+                        // Number of characters to check
+                        int len = doc.getLength() - offset;
+
+                        // Get text[offset+1,len];
+                        String text = doc.getText(offset,len);
+
+                        // Scan forwards
+                        for(int i = 0; i < len; i++)
+                        {
+                                // If text[i] == c, we have found another
+                                // opening bracket, therefore we will need
+                                // two closing brackets to complete the
+                                // match.
+                                char x = text.charAt(i);
+
+                                if(x == c)
+                                        count++;
+
+                                // If text[i] == cprime, we have found an
+                                // closing bracket, so we return i if
+                                // --count == 0
+                                else if(x == cprime)
+                                {
+                                        if(--count == 0)
+                                                return i + offset;
+                                }
+                        }
+                }
+
+                // Nothing found
+                return -1;
+        }
+
+        /**
+         * Locates the start of the word at the specified position.
+         * @param line The text
+         * @param pos The position
+         */
+        public static int findWordStart(String line, int pos, String noWordSep)
+        {
+                char ch = line.charAt(pos - 1);
+
+                if(noWordSep == null)
+                        noWordSep = "";
+                boolean selectNoLetter = (!Character.isLetterOrDigit(ch)
+                        && noWordSep.indexOf(ch) == -1);
+
+                int wordStart = 0;
+                for(int i = pos - 1; i >= 0; i--)
+                {
+                        ch = line.charAt(i);
+                        if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
+                                noWordSep.indexOf(ch) == -1))
+                        {
+                                wordStart = i + 1;
+                                break;
+                        }
+                }
+
+                return wordStart;
+        }
+
+        /**
+         * Locates the end of the word at the specified position.
+         * @param line The text
+         * @param pos The position
+         */
+        public static int findWordEnd(String line, int pos, String noWordSep)
+        {
+                char ch = line.charAt(pos);
+
+                if(noWordSep == null)
+                        noWordSep = "";
+                boolean selectNoLetter = (!Character.isLetterOrDigit(ch)
+                        && noWordSep.indexOf(ch) == -1);
+
+                int wordEnd = line.length();
+                for(int i = pos; i < line.length(); i++)
+                {
+                        ch = line.charAt(i);
+                        if(selectNoLetter ^ (!Character.isLetterOrDigit(ch) &&
+                                noWordSep.indexOf(ch) == -1))
+                        {
+                                wordEnd = i;
+                                break;
+                        }
+                }
+                return wordEnd;
+        }
+}
diff --git a/app/syntax/Token.java b/app/syntax/Token.java
new file mode 100644
index 000000000..1873d50da
--- /dev/null
+++ b/app/syntax/Token.java
@@ -0,0 +1,149 @@
+/*
+ * Token.java - Generic token
+ * Copyright (C) 1998, 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+/**
+ * A linked list of tokens. Each token has three fields - a token
+ * identifier, which is a byte value that can be looked up in the
+ * array returned by <code>SyntaxDocument.getColors()</code>
+ * to get a color value, a length value which is the length of the
+ * token in the text, and a pointer to the next token in the list.
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ */
+public class Token
+{
+        /**
+         * Normal text token id. This should be used to mark
+         * normal text.
+         */
+        public static final byte NULL = 0;
+
+        /**
+         * Comment 1 token id. This can be used to mark a comment.
+         */
+        public static final byte COMMENT1 = 1;
+
+        /**
+         * Comment 2 token id. This can be used to mark a comment.
+         */
+        public static final byte COMMENT2 = 2;
+
+
+        /**
+         * Literal 1 token id. This can be used to mark a string
+         * literal (eg, C mode uses this to mark "..." literals)
+         */
+        public static final byte LITERAL1 = 3;
+
+        /**
+         * Literal 2 token id. This can be used to mark an object
+         * literal (eg, Java mode uses this to mark true, false, etc)
+         */
+        public static final byte LITERAL2 = 4;
+
+        /**
+         * Label token id. This can be used to mark labels
+         * (eg, C mode uses this to mark ...: sequences)
+         */
+        public static final byte LABEL = 5;
+
+        /**
+         * Keyword 1 token id. This can be used to mark a
+         * keyword. This should be used for general language
+         * constructs.
+         */
+        public static final byte KEYWORD1 = 6;
+
+        /**
+         * Keyword 2 token id. This can be used to mark a
+         * keyword. This should be used for preprocessor
+         * commands, or variables.
+         */
+        public static final byte KEYWORD2 = 7;
+
+        /**
+         * Keyword 3 token id. This can be used to mark a
+         * keyword. This should be used for data types.
+         */
+        public static final byte KEYWORD3 = 8;
+
+        /**
+         * Operator token id. This can be used to mark an
+         * operator. (eg, SQL mode marks +, -, etc with this
+         * token type)
+         */
+        public static final byte OPERATOR = 9;
+
+        /**
+         * Invalid token id. This can be used to mark invalid
+         * or incomplete tokens, so the user can easily spot
+         * syntax errors.
+         */
+        public static final byte INVALID = 10;
+
+        /**
+         * The total number of defined token ids.
+         */
+        public static final byte ID_COUNT = 11;
+
+        /**
+         * The first id that can be used for internal state
+         * in a token marker.
+         */
+        public static final byte INTERNAL_FIRST = 100;
+
+        /**
+         * The last id that can be used for internal state
+         * in a token marker.
+         */
+        public static final byte INTERNAL_LAST = 126;
+
+        /**
+         * The token type, that along with a length of 0
+         * marks the end of the token list.
+         */
+        public static final byte END = 127;
+
+        /**
+         * The length of this token.
+         */
+        public int length;
+
+        /**
+         * The id of this token.
+         */
+        public byte id;
+
+        /**
+         * The next token in the linked list.
+         */
+        public Token next;
+
+        /**
+         * Creates a new token.
+         * @param length The length of the token
+         * @param id The id of the token
+         */
+        public Token(int length, byte id)
+        {
+                this.length = length;
+                this.id = id;
+        }
+
+        /**
+         * Returns a string representation of this token.
+         */
+        public String toString()
+        {
+                return "[id=" + id + ",length=" + length + "]";
+        }
+}
diff --git a/app/syntax/TokenMarker.java b/app/syntax/TokenMarker.java
new file mode 100644
index 000000000..942568ab2
--- /dev/null
+++ b/app/syntax/TokenMarker.java
@@ -0,0 +1,345 @@
+/*
+ * TokenMarker.java - Generic token marker
+ * Copyright (C) 1998, 1999 Slava Pestov
+ *
+ * You may use and modify this package for any purpose. Redistribution is
+ * permitted, in both source and binary form, provided that this notice
+ * remains intact in all source distributions of this package.
+ */
+
+package processing.app.syntax;
+
+import javax.swing.text.Segment;
+import java.util.*;
+
+/**
+ * A token marker that splits lines of text into tokens. Each token carries
+ * a length field and an indentification tag that can be mapped to a color
+ * for painting that token.<p>
+ *
+ * For performance reasons, the linked list of tokens is reused after each
+ * line is tokenized. Therefore, the return value of <code>markTokens</code>
+ * should only be used for immediate painting. Notably, it cannot be
+ * cached.
+ *
+ * @author Slava Pestov
+ * @version $Id$
+ *
+ * @see org.gjt.sp.jedit.syntax.Token
+ */
+public abstract class TokenMarker
+{
+        /**
+         * A wrapper for the lower-level <code>markTokensImpl</code> method
+         * that is called to split a line up into tokens.
+         * @param line The line
+         * @param lineIndex The line number
+         */
+        public Token markTokens(Segment line, int lineIndex)
+        {
+                if(lineIndex >= length)
+                {
+                        throw new IllegalArgumentException("Tokenizing invalid line: "
+                                + lineIndex);
+                }
+
+                lastToken = null;
+
+                LineInfo info = lineInfo[lineIndex];
+                LineInfo prev;
+                if(lineIndex == 0)
+                        prev = null;
+                else
+                        prev = lineInfo[lineIndex - 1];
+
+                byte oldToken = info.token;
+                byte token = markTokensImpl(prev == null ?
+                        Token.NULL : prev.token,line,lineIndex);
+
+                info.token = token;
+
+                /*
+                 * This is a foul hack. It stops nextLineRequested
+                 * from being cleared if the same line is marked twice.
+                 *
+                 * Why is this necessary? It's all JEditTextArea's fault.
+                 * When something is inserted into the text, firing a
+                 * document event, the insertUpdate() method shifts the
+                 * caret (if necessary) by the amount inserted.
+                 *
+                 * All caret movement is handled by the select() method,
+                 * which eventually pipes the new position to scrollTo()
+                 * and calls repaint().
+                 *
+                 * Note that at this point in time, the new line hasn't
+                 * yet been painted; the caret is moved first.
+                 *
+                 * scrollTo() calls offsetToX(), which tokenizes the line
+                 * unless it is being called on the last line painted
+                 * (in which case it uses the text area's painter cached
+                 * token list). What scrollTo() does next is irrelevant.
+                 *
+                 * After scrollTo() has done it's job, repaint() is
+                 * called, and eventually we end up in paintLine(), whose
+                 * job is to paint the changed line. It, too, calls
+                 * markTokens().
+                 *
+                 * The problem was that if the line started a multiline
+                 * token, the first markTokens() (done in offsetToX())
+                 * would set nextLineRequested (because the line end
+                 * token had changed) but the second would clear it
+                 * (because the line was the same that time) and therefore
+                 * paintLine() would never know that it needed to repaint
+                 * subsequent lines.
+                 *
+                 * This bug took me ages to track down, that's why I wrote
+                 * all the relevant info down so that others wouldn't
+                 * duplicate it.
+                 */
+                 if(!(lastLine == lineIndex && nextLineRequested))
+                        nextLineRequested = (oldToken != token);
+
+                lastLine = lineIndex;
+
+                addToken(0,Token.END);
+
+                return firstToken;
+        }
+
+        /**
+         * An abstract method that splits a line up into tokens. It
+         * should parse the line, and call <code>addToken()</code> to
+         * add syntax tokens to the token list. Then, it should return
+         * the initial token type for the next line.<p>
+         *
+         * For example if the current line contains the start of a
+         * multiline comment that doesn't end on that line, this method
+         * should return the comment token type so that it continues on
+         * the next line.
+         *
+         * @param token The initial token type for this line
+         * @param line The line to be tokenized
+         * @param lineIndex The index of the line in the document,
+         * starting at 0
+         * @return The initial token type for the next line
+         */
+        protected abstract byte markTokensImpl(byte token, Segment line,
+                int lineIndex);
+
+        /**
+         * Returns if the token marker supports tokens that span multiple
+         * lines. If this is true, the object using this token marker is
+         * required to pass all lines in the document to the
+         * <code>markTokens()</code> method (in turn).<p>
+         *
+         * The default implementation returns true; it should be overridden
+         * to return false on simpler token markers for increased speed.
+         */
+        public boolean supportsMultilineTokens()
+        {
+                return true;
+        }
+
+        /**
+         * Informs the token marker that lines have been inserted into
+         * the document. This inserts a gap in the <code>lineInfo</code>
+         * array.
+         * @param index The first line number
+         * @param lines The number of lines
+         */
+        public void insertLines(int index, int lines)
+        {
+                if(lines <= 0)
+                        return;
+                length += lines;
+                ensureCapacity(length);
+                int len = index + lines;
+                System.arraycopy(lineInfo,index,lineInfo,len,
+                        lineInfo.length - len);
+
+                for(int i = index + lines - 1; i >= index; i--)
+                {
+                        lineInfo[i] = new LineInfo();
+                }
+        }
+
+        /**
+         * Informs the token marker that line have been deleted from
+         * the document. This removes the lines in question from the
+         * <code>lineInfo</code> array.
+         * @param index The first line number
+         * @param lines The number of lines
+         */
+        public void deleteLines(int index, int lines)
+        {
+                if (lines <= 0)
+                        return;
+                int len = index + lines;
+                length -= lines;
+                System.arraycopy(lineInfo,len,lineInfo,
+                        index,lineInfo.length - len);
+        }
+
+        /**
+         * Returns the number of lines in this token marker.
+         */
+        public int getLineCount()
+        {
+                return length;
+        }
+
+        /**
+         * Returns true if the next line should be repainted. This
+         * will return true after a line has been tokenized that starts
+         * a multiline token that continues onto the next line.
+         */
+        public boolean isNextLineRequested()
+        {
+                return nextLineRequested;
+        }
+
+        // protected members
+
+        /**
+         * The first token in the list. This should be used as the return
+         * value from <code>markTokens()</code>.
+         */
+        protected Token firstToken;
+
+        /**
+         * The last token in the list. New tokens are added here.
+         * This should be set to null before a new line is to be tokenized.
+         */
+        protected Token lastToken;
+
+        /**
+         * An array for storing information about lines. It is enlarged and
+         * shrunk automatically by the <code>insertLines()</code> and
+         * <code>deleteLines()</code> methods.
+         */
+        protected LineInfo[] lineInfo;
+
+        /**
+         * The number of lines in the model being tokenized. This can be
+         * less than the length of the <code>lineInfo</code> array.
+         */
+        protected int length;
+
+        /**
+         * The last tokenized line.
+         */
+        protected int lastLine;
+
+        /**
+         * True if the next line should be painted.
+         */
+        protected boolean nextLineRequested;
+
+        /**
+         * Creates a new <code>TokenMarker</code>. This DOES NOT create
+         * a lineInfo array; an initial call to <code>insertLines()</code>
+         * does that.
+         */
+        protected TokenMarker()
+        {
+                lastLine = -1;
+        }
+
+        /**
+         * Ensures that the <code>lineInfo</code> array can contain the
+         * specified index. This enlarges it if necessary. No action is
+         * taken if the array is large enough already.<p>
+         *
+         * It should be unnecessary to call this under normal
+         * circumstances; <code>insertLine()</code> should take care of
+         * enlarging the line info array automatically.
+         *
+         * @param index The array index
+         */
+        protected void ensureCapacity(int index)
+        {
+                if(lineInfo == null)
+                        lineInfo = new LineInfo[index + 1];
+                else if(lineInfo.length <= index)
+                {
+                        LineInfo[] lineInfoN = new LineInfo[(index + 1) * 2];
+                        System.arraycopy(lineInfo,0,lineInfoN,0,
+                                         lineInfo.length);
+                        lineInfo = lineInfoN;
+                }
+        }
+
+        /**
+         * Adds a token to the token list.
+         * @param length The length of the token
+         * @param id The id of the token
+         */
+        protected void addToken(int length, byte id)
+        {
+                if(id >= Token.INTERNAL_FIRST && id <= Token.INTERNAL_LAST)
+                        throw new InternalError("Invalid id: " + id);
+
+                if(length == 0 && id != Token.END)
+                        return;
+
+                if(firstToken == null)
+                {
+                        firstToken = new Token(length,id);
+                        lastToken = firstToken;
+                }
+                else if(lastToken == null)
+                {
+                        lastToken = firstToken;
+                        firstToken.length = length;
+                        firstToken.id = id;
+                }
+                else if(lastToken.next == null)
+                {
+                        lastToken.next = new Token(length,id);
+                        lastToken = lastToken.next;
+                }
+                else
+                {
+                        lastToken = lastToken.next;
+                        lastToken.length = length;
+                        lastToken.id = id;
+                }
+        }
+
+        /**
+         * Inner class for storing information about tokenized lines.
+         */
+        public class LineInfo
+        {
+                /**
+                 * Creates a new LineInfo object with token = Token.NULL
+                 * and obj = null.
+                 */
+                public LineInfo()
+                {
+                }
+
+                /**
+                 * Creates a new LineInfo object with the specified
+                 * parameters.
+                 */
+                public LineInfo(byte token, Object obj)
+                {
+                        this.token = token;
+                        this.obj = obj;
+                }
+
+                /**
+                 * The id of the last token of the line.
+                 */
+                public byte token;
+
+                /**
+                 * This is for use by the token marker implementations
+                 * themselves. It can be used to store anything that
+                 * is an object and that needs to exist on a per-line
+                 * basis.
+                 */
+                public Object obj;
+        }
+}
diff --git a/app/syntax/readme.txt b/app/syntax/readme.txt
new file mode 100644
index 000000000..07a825cd7
--- /dev/null
+++ b/app/syntax/readme.txt
@@ -0,0 +1,46 @@
+OLDSYNTAX PACKAGE README
+
+I am placing the jEdit 2.2.1 syntax highlighting package in the public
+domain. This means it can be integrated into commercial programs, etc.
+
+This package requires at least Java 1.1 and Swing 1.1. Syntax
+highlighting for the following file types is supported:
+
+- C++, C
+- CORBA IDL
+- Eiffel
+- HTML
+- Java
+- Java properties
+- JavaScript
+- MS-DOS INI
+- MS-DOS batch files
+- Makefile
+- PHP
+- Perl
+- Python
+- TeX
+- Transact-SQL
+- Unix patch/diff
+- Unix shell script
+- XML
+
+This package is undocumented; read the source (start by taking a look at
+JEditTextArea.java) to find out how to use it; it's really simple. Feel
+free to e-mail questions, queries, etc. to me, but keep in mind that
+this code is very old and I no longer maintain it. So if you find a bug,
+don't bother me about it; fix it yourself.
+
+* Copyright
+
+The jEdit 2.2.1 syntax highlighting package contains code that is
+Copyright 1998-1999 Slava Pestov, Artur Biesiadowski, Clancy Malcolm,
+Jonathan Revusky, Juha Lindfors and Mike Dillon.
+
+You may use and modify this package for any purpose. Redistribution is
+permitted, in both source and binary form, provided that this notice
+remains intact in all source distributions of this package.
+
+-- Slava Pestov
+25 September 2000
+<sp@gjt.org>
diff --git a/app/PdeFontBuilder.java b/app/tools/CreateFont.java
similarity index 97%
rename from app/PdeFontBuilder.java
rename to app/tools/CreateFont.java
index c85cf5368..01a8a2d2f 100644
--- a/app/PdeFontBuilder.java
+++ b/app/tools/CreateFont.java
@@ -1,11 +1,11 @@
 /* -*- mode: jde; c-basic-offset: 2; indent-tabs-mode: nil -*- */
 
 /*
-  PdeFontBuilder - gui interface to font creation heaven/hell
+  CreateFont - gui interface to font creation heaven/hell
   Part of the Processing project - http://processing.org
 
-  Except where noted, code is written by Ben Fry and
-  Copyright (c) 2001-03 Massachusetts Institute of Technology
+  Copyright (c) 2004-05 Ben Fry and Casey Reas
+  Copyright (c) 2001-04 Massachusetts Institute of Technology
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
@@ -22,6 +22,9 @@
   Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
+package processing.app.tools;
+
+import processing.app.*;
 import processing.core.*;
 
 import java.awt.*;
@@ -34,7 +37,7 @@ import javax.swing.border.*;
 import javax.swing.event.*;
 
 
-public class PdeFontBuilder extends JFrame {
+public class CreateFont extends JFrame {
   File targetFolder;
 
   Dimension windowSize;
@@ -62,9 +65,11 @@ public class PdeFontBuilder extends JFrame {
   };
 
 
-  public PdeFontBuilder() {
+  public CreateFont(PdeEditor editor) {
     super("Create Font");
 
+    targetFolder = editor.sketch.dataFolder;
+
     Container paine = getContentPane();
     paine.setLayout(new BorderLayout()); //10, 10));
 
@@ -347,10 +352,12 @@ public class PdeFontBuilder extends JFrame {
   }
 
 
+  /*
   public void show(File targetFolder) {
     this.targetFolder = targetFolder;
     show();
   }
+  */
 
 
   public void update() {