Merge branch 'ide-1.5.x' into dev-ide-1.5.x-discovery

Conflicts:
	hardware/arduino/avr/cores/arduino/USBCore.cpp

Author: cmaglie

app/src/processing/app/helpers/StringReplacer.java

@@ -34,7 +34,7 @@ public static String[] formatAndSplit(String src, Map<String, String> dict,
     String res;
 
     // Recursive replace with a max depth of 10 levels.
-    for (int i=0; i<10; i++) {
+    for (int i = 0; i < 10; i++) {
       // Do a replace with dictionary
       res = StringReplacer.replaceFromMapping(src, dict);
       if (!recursive)
@@ -45,42 +45,45 @@ public static String[] formatAndSplit(String src, Map<String, String> dict,
     }
 
     // Split the resulting string in arguments
-    return quotedSplit(src, '"', false);
+    return quotedSplit(src, "\"'", false);
   }
 
-  public static String[] quotedSplit(String src, char escapeChar,
+  public static String[] quotedSplit(String src, String quoteChars,
                                      boolean acceptEmptyArguments)
       throws Exception {
-    String quote = "" + escapeChar;
     List<String> res = new ArrayList<String>();
     String escapedArg = null;
-    boolean escaping = false;
+    String escapingChar = null;
     for (String i : src.split(" ")) {
-      if (!escaping) {
-        if (!i.startsWith(quote)) {
+      if (escapingChar == null) {
+        // If the first char is not an escape char..
+        String first = null;
+        if (i.length() > 0)
+          first = i.substring(0, 1);
+        if (first == null || !quoteChars.contains(first)) {
           if (i.trim().length() != 0 || acceptEmptyArguments)
             res.add(i);
           continue;
         }
 
-        escaping = true;
+        escapingChar = first;
         i = i.substring(1);
         escapedArg = "";
       }
 
-      if (!i.endsWith(quote)) {
+      if (!i.endsWith(escapingChar)) {
         escapedArg += i + " ";
         continue;
       }
 
       escapedArg += i.substring(0, i.length() - 1);
       if (escapedArg.trim().length() != 0 || acceptEmptyArguments)
         res.add(escapedArg);
-      escaping = false;
+      escapingChar = null;
     }
-    if (escaping)
-      throw new Exception("Invalid quoting: no closing '" + escapeChar +
-          "' char found.");
+    if (escapingChar != null)
+      throw new Exception("Invalid quoting: no closing [" + escapingChar +
+          "] char found.");
     return res.toArray(new String[0]);
   }
 

app/test/processing/app/helpers/StringReplacerTest.java

@@ -0,0 +1,29 @@
+package processing.app.helpers;
+
+import static org.junit.Assert.assertArrayEquals;
+
+import org.junit.Test;
+
+public class StringReplacerTest {
+  
+  @Test
+  public void quotingCheck() throws Exception {
+    String in = "a\"bc ab'c   'abc abc' ";
+    in += "\"abc abc\" '\"abc abc\"' ";
+    in += "\"'abc abc'\"";
+    String[] res = StringReplacer.quotedSplit(in, "\"'", false);
+    assertArrayEquals(res, new String[] { "a\"bc", "ab'c", "abc abc",
+        "abc abc", "\"abc abc\"", "'abc abc'" });
+  }
+
+  @Test
+  public void quotingCheckWithEmptyStringsAccepted() throws Exception {
+    String in = "a\"bc ab'c   'abc abc' ";
+    in += "\"abc abc\" '\"abc abc\"' ";
+    in += "\"'abc abc'\"";
+    String[] res = StringReplacer.quotedSplit(in, "\"'", true);
+    assertArrayEquals(res, new String[] { "a\"bc", "ab'c", "", "", "abc abc",
+        "abc abc", "\"abc abc\"", "'abc abc'" });
+  }
+  
+}

hardware/arduino/avr/boards.txt

@@ -233,10 +233,11 @@ leonardo.build.mcu=atmega32u4
 leonardo.build.f_cpu=16000000L
 leonardo.build.vid=0x2341
 leonardo.build.pid=0x8036
+leonardo.build.usb_product="Arduino Leonardo"
 leonardo.build.board=AVR_LEONARDO
 leonardo.build.core=arduino
 leonardo.build.variant=leonardo
-leonardo.build.extra_flags=-DUSB_VID={build.vid} -DUSB_PID={build.pid}
+leonardo.build.extra_flags={build.usb_flags}
 
 ##############################################################
 
@@ -262,10 +263,11 @@ micro.build.mcu=atmega32u4
 micro.build.f_cpu=16000000L
 micro.build.vid=0x2341
 micro.build.pid=0x8037
+micro.build.usb_product="Arduino Micro"
 micro.build.board=AVR_MICRO
 micro.build.core=arduino
 micro.build.variant=micro
-micro.build.extra_flags=-DUSB_VID={build.vid} -DUSB_PID={build.pid}
+micro.build.extra_flags={build.usb_flags}
 
 ##############################################################
 
@@ -295,10 +297,11 @@ esplora.build.mcu=atmega32u4
 esplora.build.f_cpu=16000000L
 esplora.build.vid=0x2341
 esplora.build.pid=0x803c
+esplora.build.usb_product="Arduino Esplora"
 esplora.build.board=AVR_ESPLORA
 esplora.build.core=arduino
 esplora.build.variant=leonardo
-esplora.build.extra_flags=-DUSB_VID={build.vid} -DUSB_PID={build.pid}
+esplora.build.extra_flags={build.usb_flags}
 
 ##############################################################
 
@@ -456,15 +459,15 @@ LilyPadUSB.bootloader.extended_fuses=0xce
 LilyPadUSB.bootloader.file=caterina-LilyPadUSB/Caterina-LilyPadUSB.hex
 LilyPadUSB.bootloader.unlock_bits=0x3F
 LilyPadUSB.bootloader.lock_bits=0x2F
-
 LilyPadUSB.build.mcu=atmega32u4
 LilyPadUSB.build.f_cpu=8000000L
 LilyPadUSB.build.vid=0x1B4F
 LilyPadUSB.build.pid=0x9208
+LilyPadUSB.build.usb_product="LilyPad USB"
 LilyPadUSB.build.board=AVR_LILYPAD_USB
 LilyPadUSB.build.core=arduino
 LilyPadUSB.build.variant=leonardo
-LilyPadUSB.build.extra_flags=-DUSB_VID={build.vid} -DUSB_PID={build.pid}
+LilyPadUSB.build.extra_flags={build.usb_flags}
 
 ##############################################################
 

hardware/arduino/avr/cores/arduino/CDC.cpp

@@ -23,21 +23,6 @@
 #if defined(USBCON)
 #ifdef CDC_ENABLED
 
-#if (RAMEND < 1000)
-#define SERIAL_BUFFER_SIZE 16
-#else
-#define SERIAL_BUFFER_SIZE 64
-#endif
-
-struct ring_buffer
-{
-	unsigned char buffer[SERIAL_BUFFER_SIZE];
-	volatile int head;
-	volatile int tail;
-};
-
-ring_buffer cdc_rx_buffer = { { 0 }, 0, 0};
-
 typedef struct
 {
 	u32	dwDTERate;
@@ -140,51 +125,47 @@ void Serial_::end(void)
 
 void Serial_::accept(void) 
 {
-	ring_buffer *buffer = &cdc_rx_buffer;
-	int i = (unsigned int)(buffer->head+1) % SERIAL_BUFFER_SIZE;
+	int i = (unsigned int)(_rx_buffer_head+1) % SERIAL_BUFFER_SIZE;
 
 	// if we should be storing the received character into the location
 	// just before the tail (meaning that the head would advance to the
 	// current location of the tail), we're about to overflow the buffer
 	// and so we don't write the character or advance the head.
 
 	// while we have room to store a byte
-	while (i != buffer->tail) {
+	while (i != _rx_buffer_tail) {
 		int c = USB_Recv(CDC_RX);
 		if (c == -1)
 			break;	// no more data
-		buffer->buffer[buffer->head] = c;
-		buffer->head = i;
+		_rx_buffer[_rx_buffer_head] = c;
+		_rx_buffer_head = i;
 
-		i = (unsigned int)(buffer->head+1) % SERIAL_BUFFER_SIZE;
+		i = (unsigned int)(_rx_buffer_head+1) % SERIAL_BUFFER_SIZE;
 	}
 }
 
 int Serial_::available(void)
 {
-	ring_buffer *buffer = &cdc_rx_buffer;
-	return (unsigned int)(SERIAL_BUFFER_SIZE + buffer->head - buffer->tail) % SERIAL_BUFFER_SIZE;
+	return (unsigned int)(SERIAL_BUFFER_SIZE + _rx_buffer_head - _rx_buffer_tail) % SERIAL_BUFFER_SIZE;
 }
 
 int Serial_::peek(void)
 {
-	ring_buffer *buffer = &cdc_rx_buffer;
-	if (buffer->head == buffer->tail) {
+	if (_rx_buffer_head == _rx_buffer_tail) {
 		return -1;
 	} else {
-		return buffer->buffer[buffer->tail];
+		return _rx_buffer[_rx_buffer_tail];
 	}
 }
 
 int Serial_::read(void)
 {
-	ring_buffer *buffer = &cdc_rx_buffer;
 	// if the head isn't ahead of the tail, we don't have any characters
-	if (buffer->head == buffer->tail) {
+	if (_rx_buffer_head == _rx_buffer_tail) {
 		return -1;
 	} else {
-		unsigned char c = buffer->buffer[buffer->tail];
-		buffer->tail = (unsigned int)(buffer->tail + 1) % SERIAL_BUFFER_SIZE;
+		unsigned char c = _rx_buffer[_rx_buffer_tail];
+		_rx_buffer_tail = (unsigned int)(_rx_buffer_tail + 1) % SERIAL_BUFFER_SIZE;
 		return c;
 	}	
 }