From e009c5c6c61da7dcf2683a75e7b17ea4fb3c6e2d Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Tue, 1 Mar 2011 19:52:13 -0500
Subject: Renamed WProgram.h to Arduino.h.

---
 cores/arduino/WString.cpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index db5a441..5899798 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -18,7 +18,7 @@
 */
 
 #include <stdlib.h>
-#include "WProgram.h"
+#include "Arduino.h"
 #include "WString.h"
 
 
-- 
cgit v1.2.3-18-g5258


From 438bca3cb270b0d882b6b3b0bc42d57d72307c76 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Fri, 11 Mar 2011 17:56:10 -0500
Subject: Rewrite of the String class by Paul Stoffregen.

http://www.pjrc.com/teensy/string_class_experimental.html
---
 cores/arduino/WString.cpp | 783 ++++++++++++++++++++++++++++++----------------
 1 file changed, 519 insertions(+), 264 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index 5899798..c980e24 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -1,6 +1,8 @@
 /*
   WString.cpp - String library for Wiring & Arduino
+  ...mostly rewritten by Paul Stoffregen...
   Copyright (c) 2009-10 Hernando Barragan.  All rights reserved.
+  Copyright 2011, Paul Stoffregen, paul@pjrc.com
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Lesser General Public
@@ -17,427 +19,680 @@
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
-#include <stdlib.h>
-#include "Arduino.h"
 #include "WString.h"
 
 
-String::String( const char *value )
+/*********************************************/
+/*  Constructors                             */
+/*********************************************/
+
+String::String(const char *cstr)
 {
-  if ( value == NULL )
-    value = "";
-  getBuffer( _length = strlen( value ) );
-  if ( _buffer != NULL )
-    strcpy( _buffer, value );
+	init();
+	if (cstr) copy(cstr, strlen(cstr));
 }
 
-String::String( const String &value )
+String::String(const __FlashStringHelper *pgmstr)
 {
-  getBuffer( _length = value._length );
-  if ( _buffer != NULL )
-    strcpy( _buffer, value._buffer );
+	init();
+	*this = pgmstr;
 }
 
-String::String( const char value )
+String::String(const String &value)
 {
-  _length = 1;
-  getBuffer(1);
-  if ( _buffer != NULL ) {
-    _buffer[0] = value;
-    _buffer[1] = 0;
-  }
+	init();
+	*this = value;
 }
 
-String::String( const unsigned char value )
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+String::String(String &&rval)
 {
-  _length = 1;
-  getBuffer(1);
-  if ( _buffer != NULL) {
-    _buffer[0] = value;
-    _buffer[1] = 0;
-  }
+	init();
+	move(rval);
 }
-
-String::String( const int value, const int base )
+String::String(StringSumHelper &&rval)
 {
-  char buf[33];   
-  itoa((signed long)value, buf, base);
-  getBuffer( _length = strlen(buf) );
-  if ( _buffer != NULL )
-    strcpy( _buffer, buf );
+	init();
+	move(rval);
 }
+#endif
 
-String::String( const unsigned int value, const int base )
+String::String(char c)
 {
-  char buf[33];   
-  ultoa((unsigned long)value, buf, base);
-  getBuffer( _length = strlen(buf) );
-  if ( _buffer != NULL )
-    strcpy( _buffer, buf );
+	init();
+	*this = c;
 }
 
-String::String( const long value, const int base )
+String::String(unsigned char c)
 {
-  char buf[33];   
-  ltoa(value, buf, base);
-  getBuffer( _length = strlen(buf) );
-  if ( _buffer != NULL )
-    strcpy( _buffer, buf );
+	init();
+	*this = (char)c;
 }
 
-String::String( const unsigned long value, const int base )
+String::String(const int value, unsigned char base)
 {
-  char buf[33];   
-  ultoa(value, buf, 10);
-  getBuffer( _length = strlen(buf) );
-  if ( _buffer != NULL )
-    strcpy( _buffer, buf );
+	init();
+	char buf[18];
+	itoa(value, buf, base);
+	*this = buf;
 }
 
-char String::charAt( unsigned int loc ) const
+String::String(unsigned int value, unsigned char base)
 {
-  return operator[]( loc );
+	init();
+	char buf[17];
+  	utoa(value, buf, base);
+	*this = buf;
 }
 
-void String::setCharAt( unsigned int loc, const char aChar ) 
+String::String(long value, unsigned char base)
 {
-  if(_buffer == NULL) return;
-  if(_length > loc) {
-    _buffer[loc] = aChar;
-  }
+	init();
+	char buf[34];
+	ltoa(value, buf, base);
+	*this = buf;
 }
 
-int String::compareTo( const String &s2 ) const
+String::String(unsigned long value, unsigned char base)
 {
-  return strcmp( _buffer, s2._buffer );
+	init();
+	char buf[33];
+	ultoa(value, buf, base);
+	*this = buf;
 }
 
-const String & String::concat( const String &s2 )
+String::~String()
 {
-  return (*this) += s2;
+	free(buffer);
 }
 
-const String & String::operator=( const String &rhs )
-{
-  if ( this == &rhs )
-    return *this;
+/*********************************************/
+/*  Memory Management                        */
+/*********************************************/
 
-  if ( rhs._length > _length )
-  {
-    free(_buffer);
-    getBuffer( rhs._length );
-  }
-  
-  if ( _buffer != NULL ) {
-    _length = rhs._length;
-    strcpy( _buffer, rhs._buffer );
-  }
-  return *this;
+inline void String::init(void)
+{
+	buffer = NULL;
+	capacity = 0;
+	len = 0;
+	flags = 0;
 }
 
-//const String & String::operator+=( const char aChar )
-//{
-//  if ( _length == _capacity )
-//    doubleBuffer();
-//
-//  _buffer[ _length++ ] = aChar;
-//  _buffer[ _length ] = '\0';
-//  return *this;
-//}
+unsigned char String::reserve(unsigned int size)
+{
+	if (capacity >= size) return 1;
+	if (changeBuffer(size)) {
+		if (len == 0) buffer[0] = 0;
+		return 1;
+	}
+	return 0;
+}
 
-const String & String::operator+=( const String &other )
+unsigned char String::changeBuffer(unsigned int maxStrLen)
 {
-  _length += other._length;
-  if ( _length > _capacity )
-  {
-    char *temp = (char *)realloc(_buffer, _length + 1);
-    if ( temp != NULL ) {
-      _buffer = temp;
-      _capacity = _length;
-    } else {
-      _length -= other._length;
-      return *this;
-    }
-  }
-  strcat( _buffer, other._buffer );
-  return *this;
+	char *newbuffer = (char *)realloc(buffer, maxStrLen + 1);
+	if (newbuffer) {
+		buffer = newbuffer;
+		capacity = maxStrLen;
+		return 1;
+	}
+	return 0;
 }
 
+/*********************************************/
+/*  Copy and Move                            */
+/*********************************************/
 
-int String::operator==( const String &rhs ) const
+String & String::copy(const char *cstr, unsigned int length)
 {
-  return ( _length == rhs._length && strcmp( _buffer, rhs._buffer ) == 0 );
+	if (length == 0) {
+		if (buffer) buffer[0] = 0;
+		len = 0;
+		return *this;
+	}
+	if (!reserve(length)) {
+		if (buffer) {
+			free(buffer);
+			buffer = NULL;
+		}
+		len = capacity = 0;
+		return *this;
+	}
+	len = length;
+	strcpy(buffer, cstr);
+	return *this;
 }
 
-int String::operator!=( const String &rhs ) const
+String & String::copy(const __FlashStringHelper *pgmstr)
 {
-  return ( _length != rhs.length() || strcmp( _buffer, rhs._buffer ) != 0 );
+	unsigned int length = strlen_P((const prog_char *)pgmstr);
+	if (!reserve(length)) {
+		if (buffer) {
+			free(buffer);
+			buffer = NULL;
+		}
+		len = capacity = 0;
+		return *this;
+	}
+	len = length;
+	strcpy_P(buffer, (const prog_char *)pgmstr);
+	return *this;
 }
 
-int String::operator<( const String &rhs ) const
+void String::move(String &rhs)
 {
-  return strcmp( _buffer, rhs._buffer ) < 0;
+	if (buffer) {
+		if (capacity >= rhs.len) {
+			strcpy(buffer, rhs.buffer);
+			len = rhs.len;
+			rhs.len = 0;
+			return;
+		} else {
+			free(buffer);
+		}
+	}
+	buffer = rhs.buffer;
+	capacity = rhs.capacity;
+	len = rhs.len;
+	rhs.buffer = NULL;
+	rhs.capacity = 0;
+	rhs.len = 0;
 }
 
-int String::operator>( const String &rhs ) const
+String & String::operator = (const String &rhs)
 {
-  return strcmp( _buffer, rhs._buffer ) > 0;
+	if (this == &rhs) return *this;
+	return copy(rhs.buffer, rhs.len);
 }
 
-int String::operator<=( const String &rhs ) const
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
+String & String::operator = (String &&rval)
 {
-  return strcmp( _buffer, rhs._buffer ) <= 0;
+	if (this != &rval) move(rval);
+	return *this;
 }
 
-int String::operator>=( const String & rhs ) const
+String & String::operator = (StringSumHelper &&rval)
 {
-  return strcmp( _buffer, rhs._buffer ) >= 0;
+	if (this != &rval) move(rval);
+	return *this;
 }
+#endif
 
-char & String::operator[]( unsigned int index )
+String & String::operator = (const char *cstr)
 {
-  static char dummy_writable_char;
-  if (index >= _length || !_buffer) {
-    dummy_writable_char = 0;
-    return dummy_writable_char;
-  }
-  return _buffer[ index ];
+	if (cstr) {
+		copy(cstr, strlen(cstr));
+	} else {
+		len = 0;
+	}
+	return *this;
 }
 
-char String::operator[]( unsigned int index ) const
+String & String::operator = (const __FlashStringHelper *pgmstr)
 {
-  // need to check for valid index, to do later
-  return _buffer[ index ];
+	copy(pgmstr);
+	return *this;
 }
 
-boolean String::endsWith( const String &s2 ) const
+String & String::operator = (char c)
 {
-  if ( _length < s2._length )
-    return 0;
-
-  return strcmp( &_buffer[ _length - s2._length], s2._buffer ) == 0;
+	char buf[2];
+	buf[0] = c;
+	buf[1] = 0;
+	return copy(buf, 1);
 }
 
-boolean String::equals( const String &s2 ) const
+/*********************************************/
+/*  Append                                   */
+/*********************************************/
+
+String & String::append(const String &s)
 {
-  return ( _length == s2._length && strcmp( _buffer,s2._buffer ) == 0 );
+	return append(s.buffer, s.len);
 }
 
-boolean String::equalsIgnoreCase( const String &s2 ) const
+String & String::append(const char *cstr, unsigned int length)
 {
-  if ( this == &s2 )
-    return true; //1;
-  else if ( _length != s2._length )
-    return false; //0;
+	unsigned int newlen = len + length;
+	if (length == 0 || !reserve(newlen)) return *this;
+	strcpy(buffer + len, cstr);
+	len = newlen;
+	return *this;
+}
 
-  return strcmp(toLowerCase()._buffer, s2.toLowerCase()._buffer) == 0;
+String & String::append(const char *cstr)
+{
+	if (cstr) append(cstr, strlen(cstr));
+	return *this;
 }
 
-String String::replace( char findChar, char replaceChar )
+String & String::append(const __FlashStringHelper *pgmstr)
 {
-  if ( _buffer == NULL ) return *this;
-  String theReturn = _buffer;
-  char* temp = theReturn._buffer;
-  while( (temp = strchr( temp, findChar )) != 0 )
-    *temp = replaceChar;
+	unsigned int length = strlen_P((const prog_char *)pgmstr);
+	unsigned int newlen = len + length;
+	if (length == 0 || !reserve(newlen)) return *this;
+	strcpy_P(buffer + len, (const prog_char *)pgmstr);
+	len = newlen;
+	return *this;
+}
 
-  return theReturn;
+String & String::append(char c)
+{
+	char buf[2];
+	buf[0] = c;
+	buf[1] = 0;
+	append(buf, 1);
+	return *this;
 }
 
-String String::replace( const String& match, const String& replace )
+String & String::append(int num)
 {
-  if ( _buffer == NULL ) return *this;
-  String temp = _buffer, newString;
+	char buf[7];
+	itoa(num, buf, 10);
+	append(buf, strlen(buf));
+	return *this;
+}
 
-  int loc;
-  while ( (loc = temp.indexOf( match )) != -1 )
-  {
-    newString += temp.substring( 0, loc );
-    newString += replace;
-    temp = temp.substring( loc + match._length );
-  }
-  newString += temp;  
-  return newString;
+String & String::append(unsigned int num)
+{
+	char buf[6];
+	utoa(num, buf, 10);
+	append(buf, strlen(buf));
+	return *this;
 }
 
-int String::indexOf( char temp ) const
+String & String::append(long num)
 {
-  return indexOf( temp, 0 );
+	char buf[12];
+	ltoa(num, buf, 10);
+	append(buf, strlen(buf));
+	return *this;
 }
 
-int String::indexOf( char ch, unsigned int fromIndex ) const
+String & String::append(unsigned long num)
 {
-  if ( fromIndex >= _length )
-    return -1;
+	char buf[11];
+	ultoa(num, buf, 10);
+	append(buf, strlen(buf));
+	return *this;
+}
 
-  const char* temp = strchr( &_buffer[fromIndex], ch );
-  if ( temp == NULL )
-    return -1;
+/*********************************************/
+/*  Concatenate                              */
+/*********************************************/
 
-  return temp - _buffer;
+StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(rhs.buffer, rhs.len);
+	return a;
 }
 
-int String::indexOf( const String &s2 ) const
+StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 {
-  return indexOf( s2, 0 );
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (cstr) a.append(cstr, strlen(cstr));
+	return a;
 }
 
-int String::indexOf( const String &s2, unsigned int fromIndex ) const
+StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *pgmstr)
 {
-  if ( fromIndex >= _length )
-    return -1;
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(pgmstr);
+	return a;
+}
 
-  const char *theFind = strstr( &_buffer[ fromIndex ], s2._buffer );
+StringSumHelper & operator + (const StringSumHelper &lhs, char c)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(c);
+	return a;
+}
 
-  if ( theFind == NULL )
-    return -1;
+StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char c)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(c);
+	return a;
+}
 
-  return theFind - _buffer; // pointer subtraction
+StringSumHelper & operator + (const StringSumHelper &lhs, int num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(num);
+	return a;
 }
 
-int String::lastIndexOf( char theChar ) const
+StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
 {
-  return lastIndexOf( theChar, _length - 1 );
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(num);
+	return a;
 }
 
-int String::lastIndexOf( char ch, unsigned int fromIndex ) const
+StringSumHelper & operator + (const StringSumHelper &lhs, long num)
 {
-  if ( fromIndex >= _length )
-    return -1;
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(num);
+	return a;
+}
+
+StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	a.append(num);
+	return a;
+}
 
-  char tempchar = _buffer[fromIndex + 1];
-  _buffer[fromIndex + 1] = '\0';
-  char* temp = strrchr( _buffer, ch );
-  _buffer[fromIndex + 1] = tempchar;
+/*********************************************/
+/*  Comparison                               */
+/*********************************************/
 
-  if ( temp == NULL )
-    return -1;
+int String::compareTo(const String &s) const
+{
+	if (!buffer || !s.buffer) {
+		if (s.buffer && s.len > 0) return 0 - *(unsigned char *)s.buffer;
+		if (buffer && len > 0) return *(unsigned char *)buffer;
+		return 0;
+	}
+	return strcmp(buffer, s.buffer);
+}
 
-  return temp - _buffer;
+unsigned char String::equals(const String &s2) const
+{
+	return (len == s2.len && compareTo(s2) == 0);
 }
 
-int String::lastIndexOf( const String &s2 ) const
+unsigned char String::equals(const char *cstr) const
 {
-  return lastIndexOf( s2, _length - s2._length );
+	if (len == 0) return (cstr == NULL || *cstr == 0);
+	if (cstr == NULL) return buffer[0] == 0;
+	return strcmp(buffer, cstr) == 0;
 }
 
-int String::lastIndexOf( const String &s2, unsigned int fromIndex ) const
+unsigned char String::equals(const __FlashStringHelper *pgmstr) const
 {
-  // check for empty strings
-  if ( s2._length == 0 || s2._length - 1 > fromIndex || fromIndex >= _length )
-    return -1;
+	if (len == 0) return pgm_read_byte(pgmstr) == 0;
+	return strcmp_P(buffer, (const prog_char *)pgmstr) == 0;
+}
 
-  // matching first character
-  char temp = s2[ 0 ];
+unsigned char String::operator<(const String &rhs) const
+{
+	return compareTo(rhs) < 0;
+}
 
-  for ( int i = fromIndex; i >= 0; i-- )
-  {
-    if ( _buffer[ i ] == temp && (*this).substring( i, i + s2._length ).equals( s2 ) )
-    return i;
-  }
-  return -1;
+unsigned char String::operator>(const String &rhs) const
+{
+	return compareTo(rhs) > 0;
 }
 
-boolean String::startsWith( const String &s2 ) const
+unsigned char String::operator<=(const String &rhs) const
 {
-  if ( _length < s2._length )
-    return 0;
+	return compareTo(rhs) <= 0;
+}
 
-  return startsWith( s2, 0 );
+unsigned char String::operator>=(const String &rhs) const
+{
+	return compareTo(rhs) >= 0;
 }
 
-boolean String::startsWith( const String &s2, unsigned int offset ) const
+unsigned char String::equalsIgnoreCase( const String &s2 ) const
 {
-  if ( offset > _length - s2._length )
-    return 0;
+	if (this == &s2) return 1;
+	if (len != s2.len) return 0;
+	if (len == 0) return 1;
+	const char *p1 = buffer;
+	const char *p2 = s2.buffer;
+	while (*p1) {
+		if (tolower(*p1++) != tolower(*p2++)) return 0;
+	} 
+	return 1;
+}
 
-  return strncmp( &_buffer[offset], s2._buffer, s2._length ) == 0;
+unsigned char String::startsWith( const String &s2 ) const
+{
+	if (len < s2.len) return 0;
+	return startsWith(s2, 0);
 }
 
-String String::substring( unsigned int left ) const
+unsigned char String::startsWith( const String &s2, unsigned int offset ) const
 {
-  return substring( left, _length );
+	if (offset > len - s2.len || !buffer || !s2.buffer) return 0;
+	return strncmp( &buffer[offset], s2.buffer, s2.len ) == 0;
 }
 
-String String::substring( unsigned int left, unsigned int right ) const
+unsigned char String::endsWith( const String &s2 ) const
 {
-  if ( left > right )
-  {
-    int temp = right;
-    right = left;
-    left = temp;
-  }
+	if ( len < s2.len || !buffer || !s2.buffer) return 0;
+	return strcmp(&buffer[len - s2.len], s2.buffer) == 0;
+}
 
-  if ( right > _length )
-  {
-    right = _length;
-  } 
+/*********************************************/
+/*  Character Access                         */
+/*********************************************/
 
-  char temp = _buffer[ right ];  // save the replaced character
-  _buffer[ right ] = '\0';	
-  String outPut = ( _buffer + left );  // pointer arithmetic
-  _buffer[ right ] = temp;  //restore character
-  return outPut;
+char String::charAt(unsigned int loc) const
+{
+	return operator[](loc);
 }
 
-String String::toLowerCase() const
+void String::setCharAt(unsigned int loc, char c) 
 {
-  String temp = _buffer;
+	if (loc < len) buffer[loc] = c;
+}
 
-  for ( unsigned int i = 0; i < _length; i++ )
-    temp._buffer[ i ] = (char)tolower( temp._buffer[ i ] );
-  return temp;
+char & String::operator[](unsigned int index)
+{
+	static char dummy_writable_char;
+	if (index >= len || !buffer) {
+		dummy_writable_char = 0;
+		return dummy_writable_char;
+	}
+	return buffer[index];
 }
 
-String String::toUpperCase() const
+char String::operator[]( unsigned int index ) const
 {
-  String temp = _buffer;
+	if (index >= len || !buffer) return 0;
+	return buffer[index];
+}
 
-  for ( unsigned int i = 0; i < _length; i++ )
-    temp._buffer[ i ] = (char)toupper( temp._buffer[ i ] );
-  return temp;
+void String::getBytes(unsigned char *buf, unsigned int bufsize, unsigned int index) const
+{
+	if (!bufsize || !buf) return;
+	if (index >= len) {
+		buf[0] = 0;
+		return;
+	}
+	unsigned int n = bufsize - 1;
+	if (n > len - index) n = len - index;
+	strncpy((char *)buf, buffer + index, n);
+	buf[n] = 0;
 }
 
-String String::trim() const
+/*********************************************/
+/*  Search                                   */
+/*********************************************/
+
+int String::indexOf(char c) const
 {
-  if ( _buffer == NULL ) return *this;
-  String temp = _buffer;
-  unsigned int i,j;
+	return indexOf(c, 0);
+}
 
-  for ( i = 0; i < _length; i++ )
-  {
-    if ( !isspace(_buffer[i]) )
-      break;
-  }
+int String::indexOf( char ch, unsigned int fromIndex ) const
+{
+	if (fromIndex >= len) return -1;
+	const char* temp = strchr(buffer + fromIndex, ch);
+	if (temp == NULL) return -1;
+	return temp - buffer;
+}
+
+int String::indexOf(const String &s2) const
+{
+	return indexOf(s2, 0);
+}
 
-  for ( j = temp._length - 1; j > i; j-- )
-  {
-    if ( !isspace(_buffer[j]) )
-      break;
-  }
+int String::indexOf(const String &s2, unsigned int fromIndex) const
+{
+	if (fromIndex >= len) return -1;
+	const char *found = strstr(buffer + fromIndex, s2.buffer);
+	if (found == NULL) return -1;
+	return found - buffer;
+}
 
-  return temp.substring( i, j + 1);
+int String::lastIndexOf( char theChar ) const
+{
+	return lastIndexOf(theChar, len - 1);
 }
 
-void String::getBytes(unsigned char *buf, unsigned int bufsize)
+int String::lastIndexOf(char ch, int fromIndex) const
 {
-  if (!bufsize || !buf) return;
-  unsigned int len = bufsize - 1;
-  if (len > _length) len = _length;
-  strncpy((char *)buf, _buffer, len);
-  buf[len] = 0;
+	if (fromIndex >= len || fromIndex < 0) return -1;
+	char tempchar = buffer[fromIndex + 1];
+	buffer[fromIndex + 1] = '\0';
+	char* temp = strrchr( buffer, ch );
+	buffer[fromIndex + 1] = tempchar;
+	if (temp == NULL) return -1;
+	return temp - buffer;
 }
 
-void String::toCharArray(char *buf, unsigned int bufsize)
+int String::lastIndexOf(const String &s2) const
 {
-  if (!bufsize || !buf) return;
-  unsigned int len = bufsize - 1;
-  if (len > _length) len = _length;
-  strncpy(buf, _buffer, len);
-  buf[len] = 0;
+	return lastIndexOf(s2, len - s2.len);
 }
 
+int String::lastIndexOf(const String &s2, int fromIndex) const
+{
+  	if (s2.len == 0 || len == 0 || s2.len > len || fromIndex < 0) return -1;
+	if (fromIndex >= len) fromIndex = len - 1;
+	int found = -1;
+	for (char *p = buffer; p <= buffer + fromIndex; p++) {
+		p = strstr(p, s2.buffer);
+		if (!p) break;
+		if (p - buffer <= fromIndex) found = p - buffer;
+	}
+	return found;
+}
 
-long String::toInt() {
-  return atol(_buffer);
+String String::substring( unsigned int left ) const
+{
+	return substring(left, len);
+}
+
+String String::substring(unsigned int left, unsigned int right) const
+{
+	if (left > right) {
+		unsigned int temp = right;
+		right = left;
+		left = temp;
+	}
+	String out;
+	if (left > len) return out;
+	if (right > len) right = len;
+	char temp = buffer[right];  // save the replaced character
+	buffer[right] = '\0';	
+	out = buffer + left;  // pointer arithmetic
+	buffer[right] = temp;  //restore character
+	return out;
+}
+
+/*********************************************/
+/*  Modification                             */
+/*********************************************/
+
+String & String::replace(char find, char replace)
+{
+	if (!buffer) return *this;
+	for (char *p = buffer; *p; p++) {
+		if (*p == find) *p = replace;
+	}
+	return *this;
+}
+
+String & String::replace(const String& find, const String& replace)
+{
+	if (len == 0 || find.len == 0) return *this;
+	int diff = replace.len - find.len;
+	char *readFrom = buffer;
+	char *foundAt;
+	if (diff == 0) {
+		while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+			memcpy(foundAt, replace.buffer, replace.len);
+			readFrom = foundAt + replace.len;
+		}
+	} else if (diff < 0) {
+		char *writeTo = buffer;
+		while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+			unsigned int n = foundAt - readFrom;
+			memcpy(writeTo, readFrom, n);
+			writeTo += n;
+			memcpy(writeTo, replace.buffer, replace.len);
+			writeTo += replace.len;
+			readFrom = foundAt + find.len;
+			len += diff;
+		}
+		strcpy(writeTo, readFrom);
+	} else {
+		unsigned int size = len; // compute size needed for result
+		while ((foundAt = strstr(readFrom, find.buffer)) != NULL) {
+			readFrom = foundAt + find.len;
+			size += diff;
+		}
+		if (size == len) return *this;
+		if (size > capacity && !changeBuffer(size)) return *this;
+		int index = len - 1;
+		while ((index = lastIndexOf(find, index)) >= 0) {
+			readFrom = buffer + index + find.len;
+			memmove(readFrom + diff, readFrom, len - (readFrom - buffer));
+			len += diff;
+			buffer[len] = 0;
+			memcpy(buffer + index, replace.buffer, replace.len);
+			index--;
+		}
+	}
+	return *this;
+}
+
+String & String::toLowerCase(void)
+{
+	if (!buffer) return *this;
+	for (char *p = buffer; *p; p++) {
+		*p = tolower(*p);
+	}
+	return *this;
+}
+
+String & String::toUpperCase(void)
+{
+	if (!buffer) return *this;
+	for (char *p = buffer; *p; p++) {
+		*p = toupper(*p);
+	}
+	return *this;
+}
+
+String & String::trim(void)
+{
+	if (!buffer || len == 0) return *this;
+	char *begin = buffer;
+	while (isspace(*begin)) begin++;
+	char *end = buffer + len - 1;
+	while (isspace(*end) && end >= begin) end--;
+	len = end + 1 - begin;
+	if (begin > buffer) memcpy(buffer, begin, len);
+	buffer[len] = 0;
+	return *this;
+}
+
+/*********************************************/
+/*  Parsing / Conversion                     */
+/*********************************************/
+
+long String::toInt(void) const
+{
+	if (buffer) return atol(buffer);
+	return 0;
 }
+
+
-- 
cgit v1.2.3-18-g5258


From 22786eaed2494bf6fcd9b934f857dec1202b3148 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Fri, 11 Mar 2011 18:01:40 -0500
Subject: Removing F("string") syntax for now.

We should probably add something like this back in later, but I want to do one thing at a time.  This removes the __FlashStringHelper class as well.
---
 cores/arduino/WString.cpp | 51 -----------------------------------------------
 1 file changed, 51 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index c980e24..b988acc 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -32,12 +32,6 @@ String::String(const char *cstr)
 	if (cstr) copy(cstr, strlen(cstr));
 }
 
-String::String(const __FlashStringHelper *pgmstr)
-{
-	init();
-	*this = pgmstr;
-}
-
 String::String(const String &value)
 {
 	init();
@@ -163,22 +157,6 @@ String & String::copy(const char *cstr, unsigned int length)
 	return *this;
 }
 
-String & String::copy(const __FlashStringHelper *pgmstr)
-{
-	unsigned int length = strlen_P((const prog_char *)pgmstr);
-	if (!reserve(length)) {
-		if (buffer) {
-			free(buffer);
-			buffer = NULL;
-		}
-		len = capacity = 0;
-		return *this;
-	}
-	len = length;
-	strcpy_P(buffer, (const prog_char *)pgmstr);
-	return *this;
-}
-
 void String::move(String &rhs)
 {
 	if (buffer) {
@@ -229,12 +207,6 @@ String & String::operator = (const char *cstr)
 	return *this;
 }
 
-String & String::operator = (const __FlashStringHelper *pgmstr)
-{
-	copy(pgmstr);
-	return *this;
-}
-
 String & String::operator = (char c)
 {
 	char buf[2];
@@ -267,16 +239,6 @@ String & String::append(const char *cstr)
 	return *this;
 }
 
-String & String::append(const __FlashStringHelper *pgmstr)
-{
-	unsigned int length = strlen_P((const prog_char *)pgmstr);
-	unsigned int newlen = len + length;
-	if (length == 0 || !reserve(newlen)) return *this;
-	strcpy_P(buffer + len, (const prog_char *)pgmstr);
-	len = newlen;
-	return *this;
-}
-
 String & String::append(char c)
 {
 	char buf[2];
@@ -336,13 +298,6 @@ StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, const __FlashStringHelper *pgmstr)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(pgmstr);
-	return a;
-}
-
 StringSumHelper & operator + (const StringSumHelper &lhs, char c)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
@@ -411,12 +366,6 @@ unsigned char String::equals(const char *cstr) const
 	return strcmp(buffer, cstr) == 0;
 }
 
-unsigned char String::equals(const __FlashStringHelper *pgmstr) const
-{
-	if (len == 0) return pgm_read_byte(pgmstr) == 0;
-	return strcmp_P(buffer, (const prog_char *)pgmstr) == 0;
-}
-
 unsigned char String::operator<(const String &rhs) const
 {
 	return compareTo(rhs) < 0;
-- 
cgit v1.2.3-18-g5258


From 99e0c131fc0bc286e42e848d56beceb3add66e93 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Fri, 11 Mar 2011 18:04:31 -0500
Subject: Renaming append() back to concat().

---
 cores/arduino/WString.cpp | 48 +++++++++++++++++++++++------------------------
 1 file changed, 24 insertions(+), 24 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index b988acc..46efbf5 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -216,15 +216,15 @@ String & String::operator = (char c)
 }
 
 /*********************************************/
-/*  Append                                   */
+/*  concat                                   */
 /*********************************************/
 
-String & String::append(const String &s)
+String & String::concat(const String &s)
 {
-	return append(s.buffer, s.len);
+	return concat(s.buffer, s.len);
 }
 
-String & String::append(const char *cstr, unsigned int length)
+String & String::concat(const char *cstr, unsigned int length)
 {
 	unsigned int newlen = len + length;
 	if (length == 0 || !reserve(newlen)) return *this;
@@ -233,50 +233,50 @@ String & String::append(const char *cstr, unsigned int length)
 	return *this;
 }
 
-String & String::append(const char *cstr)
+String & String::concat(const char *cstr)
 {
-	if (cstr) append(cstr, strlen(cstr));
+	if (cstr) concat(cstr, strlen(cstr));
 	return *this;
 }
 
-String & String::append(char c)
+String & String::concat(char c)
 {
 	char buf[2];
 	buf[0] = c;
 	buf[1] = 0;
-	append(buf, 1);
+	concat(buf, 1);
 	return *this;
 }
 
-String & String::append(int num)
+String & String::concat(int num)
 {
 	char buf[7];
 	itoa(num, buf, 10);
-	append(buf, strlen(buf));
+	concat(buf, strlen(buf));
 	return *this;
 }
 
-String & String::append(unsigned int num)
+String & String::concat(unsigned int num)
 {
 	char buf[6];
 	utoa(num, buf, 10);
-	append(buf, strlen(buf));
+	concat(buf, strlen(buf));
 	return *this;
 }
 
-String & String::append(long num)
+String & String::concat(long num)
 {
 	char buf[12];
 	ltoa(num, buf, 10);
-	append(buf, strlen(buf));
+	concat(buf, strlen(buf));
 	return *this;
 }
 
-String & String::append(unsigned long num)
+String & String::concat(unsigned long num)
 {
 	char buf[11];
 	ultoa(num, buf, 10);
-	append(buf, strlen(buf));
+	concat(buf, strlen(buf));
 	return *this;
 }
 
@@ -287,56 +287,56 @@ String & String::append(unsigned long num)
 StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(rhs.buffer, rhs.len);
+	a.concat(rhs.buffer, rhs.len);
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (cstr) a.append(cstr, strlen(cstr));
+	if (cstr) a.concat(cstr, strlen(cstr));
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, char c)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(c);
+	a.concat(c);
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char c)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(c);
+	a.concat(c);
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, int num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(num);
+	a.concat(num);
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(num);
+	a.concat(num);
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, long num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(num);
+	a.concat(num);
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.append(num);
+	a.concat(num);
 	return a;
 }
 
-- 
cgit v1.2.3-18-g5258


From b4b32f60f1c156e76117dab69479c193a861be23 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Fri, 11 Mar 2011 18:54:58 -0500
Subject: Don't return the string when modifying its value.

Changing toLowerCase(), toUpperCase(), trim() and replace() to return void instead of a reference to the string that's just been changed.  That way, it's clear that the functions modify the string they've been called on.
---
 cores/arduino/WString.cpp | 29 ++++++++++++-----------------
 1 file changed, 12 insertions(+), 17 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index 46efbf5..e9f71d1 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -550,18 +550,17 @@ String String::substring(unsigned int left, unsigned int right) const
 /*  Modification                             */
 /*********************************************/
 
-String & String::replace(char find, char replace)
+void String::replace(char find, char replace)
 {
-	if (!buffer) return *this;
+	if (!buffer) return;
 	for (char *p = buffer; *p; p++) {
 		if (*p == find) *p = replace;
 	}
-	return *this;
 }
 
-String & String::replace(const String& find, const String& replace)
+void String::replace(const String& find, const String& replace)
 {
-	if (len == 0 || find.len == 0) return *this;
+	if (len == 0 || find.len == 0) return;
 	int diff = replace.len - find.len;
 	char *readFrom = buffer;
 	char *foundAt;
@@ -588,8 +587,8 @@ String & String::replace(const String& find, const String& replace)
 			readFrom = foundAt + find.len;
 			size += diff;
 		}
-		if (size == len) return *this;
-		if (size > capacity && !changeBuffer(size)) return *this;
+		if (size == len) return;
+		if (size > capacity && !changeBuffer(size)) return; // XXX: tell user!
 		int index = len - 1;
 		while ((index = lastIndexOf(find, index)) >= 0) {
 			readFrom = buffer + index + find.len;
@@ -600,30 +599,27 @@ String & String::replace(const String& find, const String& replace)
 			index--;
 		}
 	}
-	return *this;
 }
 
-String & String::toLowerCase(void)
+void String::toLowerCase(void)
 {
-	if (!buffer) return *this;
+	if (!buffer) return;
 	for (char *p = buffer; *p; p++) {
 		*p = tolower(*p);
 	}
-	return *this;
 }
 
-String & String::toUpperCase(void)
+void String::toUpperCase(void)
 {
-	if (!buffer) return *this;
+	if (!buffer) return;
 	for (char *p = buffer; *p; p++) {
 		*p = toupper(*p);
 	}
-	return *this;
 }
 
-String & String::trim(void)
+void String::trim(void)
 {
-	if (!buffer || len == 0) return *this;
+	if (!buffer || len == 0) return;
 	char *begin = buffer;
 	while (isspace(*begin)) begin++;
 	char *end = buffer + len - 1;
@@ -631,7 +627,6 @@ String & String::trim(void)
 	len = end + 1 - begin;
 	if (begin > buffer) memcpy(buffer, begin, len);
 	buffer[len] = 0;
-	return *this;
 }
 
 /*********************************************/
-- 
cgit v1.2.3-18-g5258


From 98b403114c3d9edcb6b74938f07c68dccc3c2489 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Sat, 12 Mar 2011 14:03:34 -0500
Subject: Modifying String.concat() to return success or failure, not this.

Which means you can't chain multiple concat() calls together, but you can check if they succeeded or not.
---
 cores/arduino/WString.cpp | 40 ++++++++++++++++++----------------------
 1 file changed, 18 insertions(+), 22 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index e9f71d1..5dcf585 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -219,65 +219,61 @@ String & String::operator = (char c)
 /*  concat                                   */
 /*********************************************/
 
-String & String::concat(const String &s)
+unsigned char String::concat(const String &s)
 {
 	return concat(s.buffer, s.len);
 }
 
-String & String::concat(const char *cstr, unsigned int length)
+unsigned char String::concat(const char *cstr, unsigned int length)
 {
 	unsigned int newlen = len + length;
-	if (length == 0 || !reserve(newlen)) return *this;
+	if (!cstr || length == 0) return 1; // nothing to append = success
+	if (!reserve(newlen)) return 0;
 	strcpy(buffer + len, cstr);
 	len = newlen;
-	return *this;
+	return 1;
 }
 
-String & String::concat(const char *cstr)
+unsigned char String::concat(const char *cstr)
 {
-	if (cstr) concat(cstr, strlen(cstr));
-	return *this;
+	if (!cstr) return 1; // nothing to append = success
+	return concat(cstr, strlen(cstr));
 }
 
-String & String::concat(char c)
+unsigned char String::concat(char c)
 {
 	char buf[2];
 	buf[0] = c;
 	buf[1] = 0;
-	concat(buf, 1);
-	return *this;
+	return concat(buf, 1);
 }
 
-String & String::concat(int num)
+unsigned char String::concat(int num)
 {
 	char buf[7];
 	itoa(num, buf, 10);
-	concat(buf, strlen(buf));
-	return *this;
+	return concat(buf, strlen(buf));
 }
 
-String & String::concat(unsigned int num)
+unsigned char String::concat(unsigned int num)
 {
 	char buf[6];
 	utoa(num, buf, 10);
-	concat(buf, strlen(buf));
-	return *this;
+	return concat(buf, strlen(buf));
 }
 
-String & String::concat(long num)
+unsigned char String::concat(long num)
 {
 	char buf[12];
 	ltoa(num, buf, 10);
-	concat(buf, strlen(buf));
-	return *this;
+	return concat(buf, strlen(buf));
 }
 
-String & String::concat(unsigned long num)
+unsigned char String::concat(unsigned long num)
 {
 	char buf[11];
 	ultoa(num, buf, 10);
-	concat(buf, strlen(buf));
-	return *this;
+	return concat(buf, strlen(buf));
 }
 
 /*********************************************/
-- 
cgit v1.2.3-18-g5258


From 76776e7a46b30ee84f48db146bf8dd642de2927a Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Sun, 13 Mar 2011 16:46:06 -0400
Subject: Moving move() to __GXX_EXPERIMENTAL_CXX0X__ only, adding operator
 bool().

---
 cores/arduino/WString.cpp | 7 +++++++
 1 file changed, 7 insertions(+)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index 5dcf585..41c80e8 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -157,6 +157,7 @@ String & String::copy(const char *cstr, unsigned int length)
 	return *this;
 }
 
+#ifdef __GXX_EXPERIMENTAL_CXX0X__
 void String::move(String &rhs)
 {
 	if (buffer) {
@@ -176,6 +177,7 @@ void String::move(String &rhs)
 	rhs.capacity = 0;
 	rhs.len = 0;
 }
+#endif
 
 String & String::operator = (const String &rhs)
 {
@@ -340,6 +342,11 @@ StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
 /*  Comparison                               */
 /*********************************************/
 
+String::operator bool() const
+{
+	return !!buffer;
+}
+
 int String::compareTo(const String &s) const
 {
 	if (!buffer || !s.buffer) {
-- 
cgit v1.2.3-18-g5258


From 7dea0522f48641106f92b1511b9e62ee46f8e2dc Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Fri, 18 Mar 2011 21:45:27 -0400
Subject: Starting to distinguish between empty strings and invalid (null)
 ones.

---
 cores/arduino/WString.cpp | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index 41c80e8..516bd20 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -114,7 +114,7 @@ inline void String::init(void)
 
 unsigned char String::reserve(unsigned int size)
 {
-	if (capacity >= size) return 1;
+	if (buffer && capacity >= size) return 1;
 	if (changeBuffer(size)) {
 		if (len == 0) buffer[0] = 0;
 		return 1;
@@ -139,11 +139,6 @@ unsigned char String::changeBuffer(unsigned int maxStrLen)
 
 String & String::copy(const char *cstr, unsigned int length)
 {
-	if (length == 0) {
-		if (buffer) buffer[0] = 0;
-		len = 0;
-		return *this;
-	}
 	if (!reserve(length)) {
 		if (buffer) {
 			free(buffer);
@@ -204,6 +199,11 @@ String & String::operator = (const char *cstr)
 	if (cstr) {
 		copy(cstr, strlen(cstr));
 	} else {
+		if (buffer) {
+			free(buffer);
+			capacity = 0;
+			buffer = NULL;
+		}
 		len = 0;
 	}
 	return *this;
-- 
cgit v1.2.3-18-g5258


From 58d04ab3a3a0b13524a862168bed1c3d0708766e Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Sat, 19 Mar 2011 11:14:17 -0400
Subject: Return an invalid string (not a partial one) when operator+() fails.

---
 cores/arduino/WString.cpp | 53 ++++++++++++++++++++++++-----------------------
 1 file changed, 27 insertions(+), 26 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index 516bd20..61ce375 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -112,6 +112,13 @@ inline void String::init(void)
 	flags = 0;
 }
 
+void String::invalidate(void)
+{
+	if (buffer) free(buffer);
+	buffer = NULL;
+	capacity = len = 0;
+}
+
 unsigned char String::reserve(unsigned int size)
 {
 	if (buffer && capacity >= size) return 1;
@@ -140,11 +147,7 @@ unsigned char String::changeBuffer(unsigned int maxStrLen)
 String & String::copy(const char *cstr, unsigned int length)
 {
 	if (!reserve(length)) {
-		if (buffer) {
-			free(buffer);
-			buffer = NULL;
-		}
-		len = capacity = 0;
+		invalidate();
 		return *this;
 	}
 	len = length;
@@ -177,7 +180,11 @@ void String::move(String &rhs)
 String & String::operator = (const String &rhs)
 {
 	if (this == &rhs) return *this;
-	return copy(rhs.buffer, rhs.len);
+	
+	if (rhs.buffer) copy(rhs.buffer, rhs.len);
+	else invalidate();
+	
+	return *this;
 }
 
 #ifdef __GXX_EXPERIMENTAL_CXX0X__
@@ -196,16 +203,9 @@ String & String::operator = (StringSumHelper &&rval)
 
 String & String::operator = (const char *cstr)
 {
-	if (cstr) {
-		copy(cstr, strlen(cstr));
-	} else {
-		if (buffer) {
-			free(buffer);
-			capacity = 0;
-			buffer = NULL;
-		}
-		len = 0;
-	}
+	if (cstr) copy(cstr, strlen(cstr));
+	else invalidate();
+	
 	return *this;
 }
 
@@ -229,7 +229,8 @@ unsigned char String::concat(const String &s)
 unsigned char String::concat(const char *cstr, unsigned int length)
 {
 	unsigned int newlen = len + length;
-	if (!cstr || length == 0) return 1; // nothing to append = success
+	if (!cstr) return 0;
+	if (length == 0) return 1;
 	if (!reserve(newlen)) return 0;
 	strcpy(buffer + len, cstr);
 	len = newlen;
@@ -238,7 +239,7 @@ unsigned char String::concat(const char *cstr, unsigned int length)
 
 unsigned char String::concat(const char *cstr)
 {
-	if (!cstr) return 1; // nothing to append = success
+	if (!cstr) return 0;
 	return concat(cstr, strlen(cstr));
 }
 
@@ -285,56 +286,56 @@ unsigned char String::concat(unsigned long num)
 StringSumHelper & operator + (const StringSumHelper &lhs, const String &rhs)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(rhs.buffer, rhs.len);
+	if (!a.concat(rhs.buffer, rhs.len)) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (cstr) a.concat(cstr, strlen(cstr));
+	if (!cstr || !a.concat(cstr, strlen(cstr))) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, char c)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(c);
+	if (!a.concat(c)) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char c)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(c);
+	if (!a.concat(c)) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, int num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(num);
+	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(num);
+	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, long num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(num);
+	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
 StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
 {
 	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	a.concat(num);
+	if (!a.concat(num)) a.invalidate();
 	return a;
 }
 
-- 
cgit v1.2.3-18-g5258


From 99e642a26dc2a406cdfa2d43665f45749b63d5c8 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Sat, 26 Mar 2011 18:52:54 -0400
Subject: String: removing implicit numeric conversions and new approach to "if
 (s)".

This makes explicit the String constructors that take numeric types and chars and removes the versions of concat() and operator=() and operator+() that accept numberic types.

It also replaces the operator bool() with a operator that converts to a function pointer.  This allows for uses like "if (s)" but not "s + 123".  See: http://www.artima.com/cppsource/safebool.html.  This allowed removing the disambiguating operator+() functions and relying solely on StringSumHelper and anonymous temporaries once again.

Also, now treating unsigned char's like int when constructing Strings from them, i.e. String(byte(65)) is now "65" not "A".  This is consistent with the new behavior of Serial.print(byte).
---
 cores/arduino/WString.cpp | 106 +++++-----------------------------------------
 1 file changed, 10 insertions(+), 96 deletions(-)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index 61ce375..d057849 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -54,16 +54,21 @@ String::String(StringSumHelper &&rval)
 String::String(char c)
 {
 	init();
-	*this = c;
+	char buf[2];
+	buf[0] = c;
+	buf[1] = 0;
+	*this = buf;
 }
 
-String::String(unsigned char c)
+String::String(unsigned char value, unsigned char base)
 {
 	init();
-	*this = (char)c;
+	char buf[9];
+	utoa(value, buf, base);
+	*this = buf;
 }
 
-String::String(const int value, unsigned char base)
+String::String(int value, unsigned char base)
 {
 	init();
 	char buf[18];
@@ -75,7 +80,7 @@ String::String(unsigned int value, unsigned char base)
 {
 	init();
 	char buf[17];
-  	utoa(value, buf, base);
+	utoa(value, buf, base);
 	*this = buf;
 }
 
@@ -209,14 +214,6 @@ String & String::operator = (const char *cstr)
 	return *this;
 }
 
-String & String::operator = (char c)
-{
-	char buf[2];
-	buf[0] = c;
-	buf[1] = 0;
-	return copy(buf, 1);
-}
-
 /*********************************************/
 /*  concat                                   */
 /*********************************************/
@@ -243,42 +240,6 @@ unsigned char String::concat(const char *cstr)
 	return concat(cstr, strlen(cstr));
 }
 
-unsigned char String::concat(char c)
-{
-	char buf[2];
-	buf[0] = c;
-	buf[1] = 0;
-	return concat(buf, 1);
-}
-
-unsigned char String::concat(int num)
-{
-	char buf[7];
-	itoa(num, buf, 10);
-	return concat(buf, strlen(buf));
-}
-
-unsigned char String::concat(unsigned int num)
-{
-	char buf[6];
-	utoa(num, buf, 10);
-	return concat(buf, strlen(buf));
-}
-
-unsigned char String::concat(long num)
-{
-	char buf[12];
-	ltoa(num, buf, 10);
-	return concat(buf, strlen(buf));
-}
-
-unsigned char String::concat(unsigned long num)
-{
-	char buf[11];
-	ultoa(num, buf, 10);
-	return concat(buf, strlen(buf));
-}
-
 /*********************************************/
 /*  Concatenate                              */
 /*********************************************/
@@ -297,57 +258,10 @@ StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 	return a;
 }
 
-StringSumHelper & operator + (const StringSumHelper &lhs, char c)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(c)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char c)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(c)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, int num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, long num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
-StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
-{
-	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
-	if (!a.concat(num)) a.invalidate();
-	return a;
-}
-
 /*********************************************/
 /*  Comparison                               */
 /*********************************************/
 
-String::operator bool() const
-{
-	return !!buffer;
-}
-
 int String::compareTo(const String &s) const
 {
 	if (!buffer || !s.buffer) {
-- 
cgit v1.2.3-18-g5258


From 1cac0f3eb738119f53b8fdd07bcd6d1158235476 Mon Sep 17 00:00:00 2001
From: "David A. Mellis" <d.mellis@arduino.cc>
Date: Thu, 31 Mar 2011 10:56:14 -0400
Subject: Restoring concatenation of built-in types with String.

---
 cores/arduino/WString.cpp | 85 +++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 85 insertions(+)

(limited to 'cores/arduino/WString.cpp')

diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp
index d057849..f90cef0 100644
--- a/cores/arduino/WString.cpp
+++ b/cores/arduino/WString.cpp
@@ -240,6 +240,49 @@ unsigned char String::concat(const char *cstr)
 	return concat(cstr, strlen(cstr));
 }
 
+unsigned char String::concat(char c)
+{
+	char buf[2];
+	buf[0] = c;
+	buf[1] = 0;
+	return concat(buf, 1);
+}
+
+unsigned char String::concat(unsigned char num)
+{
+	char buf[4];
+	itoa(num, buf, 10);
+	return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(int num)
+{
+	char buf[7];
+	itoa(num, buf, 10);
+	return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(unsigned int num)
+{
+	char buf[6];
+	utoa(num, buf, 10);
+	return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(long num)
+{
+	char buf[12];
+	ltoa(num, buf, 10);
+	return concat(buf, strlen(buf));
+}
+
+unsigned char String::concat(unsigned long num)
+{
+	char buf[11];
+	ultoa(num, buf, 10);
+	return concat(buf, strlen(buf));
+}
+
 /*********************************************/
 /*  Concatenate                              */
 /*********************************************/
@@ -258,6 +301,48 @@ StringSumHelper & operator + (const StringSumHelper &lhs, const char *cstr)
 	return a;
 }
 
+StringSumHelper & operator + (const StringSumHelper &lhs, char c)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (!a.concat(c)) a.invalidate();
+	return a;
+}
+
+StringSumHelper & operator + (const StringSumHelper &lhs, unsigned char num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (!a.concat(num)) a.invalidate();
+	return a;
+}
+
+StringSumHelper & operator + (const StringSumHelper &lhs, int num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (!a.concat(num)) a.invalidate();
+	return a;
+}
+
+StringSumHelper & operator + (const StringSumHelper &lhs, unsigned int num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (!a.concat(num)) a.invalidate();
+	return a;
+}
+
+StringSumHelper & operator + (const StringSumHelper &lhs, long num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (!a.concat(num)) a.invalidate();
+	return a;
+}
+
+StringSumHelper & operator + (const StringSumHelper &lhs, unsigned long num)
+{
+	StringSumHelper &a = const_cast<StringSumHelper&>(lhs);
+	if (!a.concat(num)) a.invalidate();
+	return a;
+}
+
 /*********************************************/
 /*  Comparison                               */
 /*********************************************/
-- 
cgit v1.2.3-18-g5258