First integration of the Arduino code in Processing 5503: PreProcessor and Compiler have been integrated with changes to the Sketch.

Compilation still has problems (Thread error on success, and can't handle non-pde files in a sketch).
Modified the Mac OS X make.sh to copy the hardware, avr tools, and example over.
Removing some of the antlr stuff.  
Disabling the Commander (command-line execution) for now.
Added Library, LibraryManager, and Target.
Added support for prefixed preferences (e.g. for boards and programmers).

build/shared/examples/Analog/AnalogInput/AnalogInput.pde

@@ -0,0 +1,27 @@
+/*
+ * AnalogInput
+ * by DojoDave <http://www.0j0.org>
+ *
+ * Turns on and off a light emitting diode(LED) connected to digital  
+ * pin 13. The amount of time the LED will be on and off depends on
+ * the value obtained by analogRead(). In the easiest case we connect
+ * a potentiometer to analog pin 2.
+ *
+ * http://www.arduino.cc/en/Tutorial/AnalogInput
+ */
+
+int potPin = 2;    // select the input pin for the potentiometer
+int ledPin = 13;   // select the pin for the LED
+int val = 0;       // variable to store the value coming from the sensor
+
+void setup() {
+  pinMode(ledPin, OUTPUT);  // declare the ledPin as an OUTPUT
+}
+
+void loop() {
+  val = analogRead(potPin);    // read the value from the sensor
+  digitalWrite(ledPin, HIGH);  // turn the ledPin on
+  delay(val);                  // stop the program for some time
+  digitalWrite(ledPin, LOW);   // turn the ledPin off
+  delay(val);                  // stop the program for some time
+}

build/shared/examples/Analog/Calibration/Calibration.pde

@@ -0,0 +1,49 @@
+/*
+ * Calibration
+ *
+ * Demonstrates one techinque for calibrating sensor input.  The
+ * sensor readings during the first five seconds of the sketch
+ * execution define the minimum and maximum of expected values.
+ */
+
+int sensorPin = 2;
+int ledPin = 9;
+
+int val = 0;
+int sensorMin = 1023, sensorMax = 0;
+
+void setup() {
+  // signal the start of the calibration period
+  pinMode(13, OUTPUT);
+  digitalWrite(13, HIGH);
+  
+  // calibrate during the first five seconds 
+  while (millis() < 5000) {
+    val = analogRead(sensorPin);
+    
+    // record the maximum sensor value
+    if (val > sensorMax) {
+      sensorMax = val;
+    }
+    
+    // record the minimum sensor value
+    if (val < sensorMin) {
+      sensorMin = val;
+    }
+  }
+  
+  // signal the end of the calibration period
+  digitalWrite(13, LOW);
+}
+
+void loop() {
+  val = analogRead(sensorPin);
+  
+  // apply the calibration to the sensor reading
+  val = map(val, sensorMin, sensorMax, 0, 255);
+  
+  // in case the sensor value is outside the range seen during calibration
+  val = constrain(val, 0, 255);
+  
+  analogWrite(ledPin, val);
+}

build/shared/examples/Analog/Fading/Fading.pde

@@ -0,0 +1,24 @@
+// Fading LED 
+// by BARRAGAN <http://people.interaction-ivrea.it/h.barragan> 
+
+int value = 0;                            // variable to keep the actual value 
+int ledpin = 9;                           // light connected to digital pin 9
+ 
+void setup() 
+{ 
+  // nothing for setup 
+} 
+ 
+void loop() 
+{ 
+  for(value = 0 ; value <= 255; value+=5) // fade in (from min to max) 
+  { 
+    analogWrite(ledpin, value);           // sets the value (range from 0 to 255) 
+    delay(30);                            // waits for 30 milli seconds to see the dimming effect 
+  } 
+  for(value = 255; value >=0; value-=5)   // fade out (from max to min) 
+  { 
+    analogWrite(ledpin, value); 
+    delay(30); 
+  }  
+} 

build/shared/examples/Analog/Smoothing/Smoothing.pde

@@ -0,0 +1,43 @@
+/*
+ * Smoothing
+ * David A. Mellis <dam@mellis.org>
+ *
+ * Reads repeatedly from an analog input, calculating a running average
+ * and printing it to the computer. 
+ *
+ * http://www.arduino.cc/en/Tutorial/Smoothing
+ */
+
+// Define the number of samples to keep track of.  The higher the number,
+// the more the readings will be smoothed, but the slower the output will
+// respond to the input.  Using a #define rather than a normal variable lets
+// use this value to determine the size of the readings array.
+#define NUMREADINGS 10
+
+int readings[NUMREADINGS];                // the readings from the analog input
+int index = 0;                            // the index of the current reading
+int total = 0;                            // the running total
+int average = 0;                          // the average
+
+int inputPin = 0;
+
+void setup()
+{
+  Serial.begin(9600);                     // initialize serial communication with computer
+  for (int i = 0; i < NUMREADINGS; i++)
+    readings[i] = 0;                      // initialize all the readings to 0
+}
+
+void loop()
+{
+  total -= readings[index];               // subtract the last reading
+  readings[index] = analogRead(inputPin); // read from the sensor
+  total += readings[index];               // add the reading to the total
+  index = (index + 1);                    // advance to the next index
+  
+  if (index >= NUMREADINGS)               // if we're at the end of the array...
+    index = 0;                            // ...wrap around to the beginning
+  
+  average = total / NUMREADINGS;          // calculate the average
+  Serial.println(average);                // send it to the computer (as ASCII digits)
+}