diff options
Diffstat (limited to 'cores')
| -rw-r--r-- | cores/arduino/WString.cpp | 666 |
1 files changed, 397 insertions, 269 deletions
diff --git a/cores/arduino/WString.cpp b/cores/arduino/WString.cpp index 5af89e3..b07edc3 100644 --- a/cores/arduino/WString.cpp +++ b/cores/arduino/WString.cpp @@ -1,396 +1,524 @@ /* - WString.cpp - String library for Wiring & Arduino - Copyright (c) 2009-10 Hernando Barragan. All rights reserved. - - This library is free software; you can redistribute it and/or - modify it under the terms of the GNU Lesser General Public - License as published by the Free Software Foundation; either - version 2.1 of the License, or (at your option) any later version. - - This library 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 - Lesser General Public License for more details. - - You should have received a copy of the GNU Lesser General Public - License along with this library; if not, write to the Free Software - Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA -*/ + WString.cpp - String library for Wiring & Arduino + Copyright (c) 2009-10 Hernando Barragan. All rights reserved. + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ #include <stdlib.h> #include "WProgram.h" #include "WString.h" - String::String( const char *value ) { - if ( value == NULL ) - value = ""; - getBuffer( _length = strlen( value ) ); - strcpy( _buffer, value ); + if ( value == NULL ) + value = ""; + getBuffer( _length = strlen( value ) ); + if(_buffer != NULL) //added + strcpy( _buffer, value ); } String::String( const String &value ) { - getBuffer( _length = value._length ); - strcpy( _buffer, value._buffer ); + getBuffer( _length = value._length ); + if(_buffer != NULL) //added + strcpy( _buffer, value._buffer ); } String::String( const char value ) { - _length = 1; - getBuffer(1); - _buffer[0] = value; - _buffer[1] = 0; + _length = 1; + getBuffer(1); + if(_buffer != NULL){ //added + _buffer[0] = value; + _buffer[1] = '\0'; //_buffer[1] = 0; + } } String::String( const unsigned char value ) { - _length = 1; - getBuffer(1); - _buffer[0] = value; - _buffer[1] = 0; + _length = 1; + getBuffer(1); + if(_buffer != NULL){ //added + _buffer[0] = value; + _buffer[1] = '\0'; //_buffer[1] = 0; + } } String::String( const int value, const int base ) { - char buf[33]; - itoa((signed long)value, buf, base); - getBuffer( _length = strlen(buf) ); - strcpy( _buffer, buf ); + //char buf[33]; + char* buf = (char *) malloc(33); + if(buf != NULL){ //added + itoa(value,buf,base); + getBuffer( _length = strlen(buf) ); + strcpy( _buffer, buf ); + free(buf); //added + } } String::String( const unsigned int value, const int base ) { - char buf[33]; - ultoa((unsigned long)value, buf, base); - getBuffer( _length = strlen(buf) ); - strcpy( _buffer, buf ); + //char buf[33]; + char* buf = (char *) malloc(33); + if(buf != NULL){ //added + ultoa((unsigned long)value, buf, base); + getBuffer( _length = strlen(buf) ); + strcpy( _buffer, buf ); + free(buf); //added + } } String::String( const long value, const int base ) { - char buf[33]; - ltoa(value, buf, base); - getBuffer( _length = strlen(buf) ); - strcpy( _buffer, buf ); + //char buf[33]; + char* buf = (char *) malloc(33); + if(buf != NULL){ //added + ltoa(value, buf, base); + getBuffer( _length = strlen(buf) ); + strcpy( _buffer, buf ); + free(buf); //added + } } String::String( const unsigned long value, const int base ) { - char buf[33]; - ultoa(value, buf, 10); - getBuffer( _length = strlen(buf) ); - strcpy( _buffer, buf ); -} - -char String::charAt( unsigned int loc ) const -{ - return operator[]( loc ); -} - -void String::setCharAt( unsigned int loc, const char aChar ) -{ - if(_length > loc) { - _buffer[loc] = aChar; - } -} - -int String::compareTo( const String &s2 ) const -{ - return strcmp( _buffer, s2._buffer ); -} - -const String & String::concat( const String &s2 ) -{ - return (*this) += s2; + //char buf[33]; + char* buf = (char *) malloc(33); + if(buf != NULL){ //added + ultoa(value, buf, 10); + getBuffer( _length = strlen(buf) ); + strcpy( _buffer, buf ); + free(buf); //added + } } const String & String::operator=( const String &rhs ) { - if ( this == &rhs ) - return *this; - - if ( rhs._length > _length ) - { - free(_buffer); - getBuffer( rhs._length ); - } - _length = rhs._length; - strcpy( _buffer, rhs._buffer ); - return *this; -} - -const String & String::operator+=( const char aChar ) -{ - if ( _length == _capacity ) - doubleBuffer(); - - _buffer[ _length++ ] = aChar; - _buffer[ _length ] = '\0'; - return *this; + if ( this == &rhs ) + return *this; + + if ( rhs._length > _length ) + { + free(_buffer); + getBuffer( rhs._length ); + } + _length = rhs._length; + strcpy( _buffer, rhs._buffer ); + return *this; +} + +const String & String::operator+=( const char ch ) +{ + if ( _length == _capacity ) + { //doubleBuffer(); //only place to use + char *temp = _buffer; + _length++; + getBuffer(_length); + if(_buffer == NULL) + return "/*NOT ENOUGH MEMORY*/"; + strcpy(_buffer,temp); + } + _buffer[ _length-1 ] = ch; + _buffer[ _length ] = '\0'; + return *this; +} +const String & String::operator+=( const String &rhs ) +{ + _length += rhs._length; + if ( _length > _capacity ) + { + char *temp = _buffer; + getBuffer( _length ); + strcpy( _buffer, temp ); + _buffer[_length] = '\0'; + free(temp); + } + strcat( _buffer, rhs._buffer ); + return *this; } -const String & String::operator+=( const String &other ) -{ - _length += other._length; - if ( _length > _capacity ) - { - char *temp = _buffer; - getBuffer( _length ); - strcpy( _buffer, temp ); - free(temp); - } - strcat( _buffer, other._buffer ); - return *this; -} - - int String::operator==( const String &rhs ) const { - return ( _length == rhs._length && strcmp( _buffer, rhs._buffer ) == 0 ); + return ( _length == rhs._length && strcmp( _buffer, rhs._buffer ) == 0 ); } int String::operator!=( const String &rhs ) const { - return ( _length != rhs.length() || strcmp( _buffer, rhs.toCharArray() ) != 0 ); + return ( _length != rhs._length || strcmp( _buffer, rhs._buffer ) != 0 ); + //return ( _length != rhs.length() || strcmp( _buffer, rhs.toCharArray() ) != 0 ); } int String::operator<( const String &rhs ) const { - return strcmp( _buffer, rhs._buffer ) < 0; + return strcmp( _buffer, rhs._buffer ) < 0; } int String::operator>( const String &rhs ) const { - return strcmp( _buffer, rhs._buffer ) > 0; + return strcmp( _buffer, rhs._buffer ) > 0; } int String::operator<=( const String &rhs ) const { - return strcmp( _buffer, rhs._buffer ) <= 0; + return strcmp( _buffer, rhs._buffer ) <= 0; } int String::operator>=( const String & rhs ) const { - return strcmp( _buffer, rhs._buffer ) >= 0; + return strcmp( _buffer, rhs._buffer ) >= 0; } char & String::operator[]( unsigned int index ) { - // need to check for valid index, to do later - return _buffer[ index ]; + if(index < 0 || index >= _length) exit(1); //added + return _buffer[ index ]; } char String::operator[]( unsigned int index ) const { - // need to check for valid index, to do later - return _buffer[ index ]; + if(index < 0 || index >= _length) exit(1); //added + return _buffer[ index ]; } -boolean String::endsWith( const String &s2 ) const +char String::charAt( unsigned int index ) const { - if ( _length < s2._length ) - return 0; - - return strcmp( &_buffer[ _length - s2._length], s2.toCharArray() ) == 0; + return operator[]( index ); } -boolean String::equals( const String &s2 ) const +void String::setCharAt( unsigned int index, const char ch ) { - return ( _length == s2._length && strcmp( _buffer,s2._buffer ) == 0 ); + if(_length > index) { + _buffer[index] = ch; + } + else{ + exit(1); //added + } } -boolean String::equalsIgnoreCase( const String &s2 ) const +boolean String::startsWith( const String &prefix ) const { - if ( this == &s2 ) - return true; //1; - else if ( _length != s2._length ) - return false; //0; - - return strcmp(toLowerCase().toCharArray(), s2.toLowerCase().toCharArray()) == 0; + if ( _length < prefix._length ) + return false; + + return startsWith( prefix, 0 ); } -String String::replace( char findChar, char replaceChar ) +boolean String::startsWith( const String &prefix, unsigned int offset ) const { - String theReturn = _buffer; - char* temp = theReturn._buffer; - while( (temp = strchr( temp, findChar )) != 0 ) - *temp = replaceChar; - - return theReturn; + if ( offset > _length - prefix._length ) + return false; + + return (strncmp( &_buffer[offset], prefix._buffer, prefix._length ) == 0); } -String String::replace( const String& match, const String& replace ) +boolean String::endsWith( const String &suffix ) const { - String temp = _buffer, newString; - - 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; + if ( _length < suffix._length ) + return false; + + return (strcmp( &_buffer[ _length - suffix._length], suffix._buffer ) == 0); } -int String::indexOf( char temp ) const +boolean String::contains( const String &str ) const { - return indexOf( temp, 0 ); + return (strstr(_buffer, str._buffer) != NULL ); } -int String::indexOf( char ch, unsigned int fromIndex ) const +boolean String::equals( const String &str ) const { - if ( fromIndex >= _length ) - return -1; - - const char* temp = strchr( &_buffer[fromIndex], ch ); - if ( temp == NULL ) - return -1; - - return temp - _buffer; + return ( _length == str._length && strcmp( _buffer,str._buffer ) == 0 ); } -int String::indexOf( const String &s2 ) const +boolean String::equalsIgnoreCase( const String &str ) const { - return indexOf( s2, 0 ); + if ( this == &str ) + return true; + else if ( _length != str._length ) + return false; + //return strcmp(toLowerCase().toCharArray(), s2.toLowerCase().toCharArray()) == 0; + for(unsigned int i = 0; i < _length; i++ ){ + if(tolower( _buffer[i]) != tolower(str._buffer[i])) + return false; + } + return true; } -int String::indexOf( const String &s2, unsigned int fromIndex ) const -{ - if ( fromIndex >= _length ) - return -1; - - const char *theFind = strstr( &_buffer[ fromIndex ], s2.toCharArray() ); - - if ( theFind == NULL ) - return -1; - - return theFind - _buffer; // pointer subtraction -} - -int String::lastIndexOf( char theChar ) const +String String::trim() const { - return lastIndexOf( theChar, _length - 1 ); + /* + String temp = _buffer; + unsigned int i,j; + + for ( i = 0; i < _length; i++ ) + { + if ( !isspace(_buffer[i]) ) + break; + } + + for ( j = temp._length - 1; j > i; j-- ) + { + if ( !isspace(_buffer[j]) ) + break; + } + + return temp.substring( i, j + 1); + */ + String temp = _buffer; + unsigned int index = 0; + unsigned int tempIndex = 0; + while( index < _length ) + { + if(_buffer[index] == '\t' || + _buffer[index] == '\r' || + _buffer[index] == '\n' || + _buffer[index] == ' ' || + _buffer[index] == 0x11) + { + memcpy(temp._buffer+tempIndex, _buffer+index+1, strlen(_buffer)-index-1); + temp._buffer[temp._length-1] = '\0'; + temp._length--; + } + else{ + tempIndex++; + } + index++; + } + return temp; } -int String::lastIndexOf( char ch, unsigned int fromIndex ) const +String String::toLowerCase() const { - if ( fromIndex >= _length ) - 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; + String temp = _buffer; + + for ( unsigned int i = 0; i < _length; i++ ) + temp._buffer[ i ] = (char)tolower( temp._buffer[ i ] ); + return temp; } -int String::lastIndexOf( const String &s2 ) const +String String::toUpperCase() const { - return lastIndexOf( s2, _length - s2._length ); + String temp = _buffer; + + for ( unsigned int i = 0; i < _length; i++ ) + temp._buffer[ i ] = (char)toupper( temp._buffer[ i ] ); + return temp; } -int String::lastIndexOf( const String &s2, unsigned int fromIndex ) const +String String::replace( char oldChar, char newChar ) { - // check for empty strings - if ( s2._length == 0 || s2._length - 1 > fromIndex || fromIndex >= _length ) - return -1; - - // matching first character - char temp = s2[ 0 ]; - - for ( int i = fromIndex; i >= 0; i-- ) - { - if ( _buffer[ i ] == temp && (*this).substring( i, i + s2._length ).equals( s2 ) ) - return i; - } - return -1; + String newString = _buffer; + char* temp = newString._buffer; + while( temp = strchr( temp, oldChar ) ) + *temp = newChar; + + return newString; } -boolean String::startsWith( const String &s2 ) const -{ - if ( _length < s2._length ) - return 0; - - return startsWith( s2, 0 ); -} - -boolean String::startsWith( const String &s2, unsigned int offset ) const +String String::replace( const String& match, const String& replace ) { - if ( offset > _length - s2._length ) - return 0; - - return strncmp( &_buffer[offset], s2.toCharArray(), s2._length ) == 0; + /* + String newString; + String temp = _buffer; + 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; + */ + + const char* temp = strstr( _buffer, match._buffer); + if(temp == NULL || match._length == 0){ + String newString = _buffer; + return newString; + } + else{ + //get new buffer + int count = 0; + int lastIndex = 0; + while(temp != NULL){ + count ++; + lastIndex = temp - _buffer; + temp = strstr( &_buffer[ lastIndex + match._length ], match._buffer ); + } + String newString; + newString._length = newString._capacity = _length + (replace._length - match._length)*count; + char* _buf = (char*)malloc(newString._length + 1); + if(_buf == NULL) + exit(1); + newString._buffer = _buf; + //string copy + int fromIndex = 0; + int tempLength = 0; + lastIndex = 0; + temp = strstr( &_buffer[ lastIndex ], match._buffer); + while (temp != NULL){ + fromIndex = temp - _buffer; + memcpy(newString._buffer+tempLength, _buffer+lastIndex, fromIndex-lastIndex); + memcpy(newString._buffer+tempLength+fromIndex-lastIndex, replace._buffer, replace._length); + tempLength += (fromIndex-lastIndex + replace._length); + lastIndex = fromIndex + match._length; + temp = strstr( &_buffer[ lastIndex ], match._buffer); + } + memcpy(newString._buffer+tempLength, _buffer+lastIndex, _length-lastIndex); + tempLength += (_length - lastIndex); + newString._buffer[tempLength] = '\0'; + newString._length = newString._capacity = strlen(newString._buffer); + return newString; + } +} + +String String::substring( unsigned int beginIndex ) const +{ + return substring( beginIndex, _length ); +} + +String String::substring( unsigned int beginIndex, unsigned int endIndex ) const +{ + if ( beginIndex > endIndex ) + { + int temp = endIndex; + endIndex = beginIndex; + beginIndex = temp; + } + if ( endIndex > _length ) + { + endIndex = _length; + } + + char temp = _buffer[ endIndex ]; // save the replaced character + _buffer[ endIndex ] = '\0'; + String outPut = ( _buffer + beginIndex ); // pointer arithmetic + _buffer[ endIndex ] = temp; //restore character + return outPut; +} + +const String & String::append( const String &str ) +{ + return (*this) += str; +} + +const String & String::append( const char ch) +{ + return (*this) += ch; +} + +int String::compareTo( const String &str ) const +{ + return strcmp( _buffer, str._buffer ); +} + +int String::compareTo( const char* str ) const +{ + return strcmp( _buffer, str ); +} + +int String::indexOf( char ch ) const +{ + return indexOf( ch, 0 ); } -String String::substring( unsigned int left ) const +int String::indexOf( char ch, unsigned int fromIndex ) const { - return substring( left, _length ); + if ( fromIndex >= _length ) + return -1; + + const char* temp = strchr( &_buffer[fromIndex], ch ); + if ( temp == NULL ) + return -1; + + return temp - _buffer; } -String String::substring( unsigned int left, unsigned int right ) const +int String::indexOf( const String &str ) const { - if ( left > right ) - { - int temp = right; - right = left; - left = temp; - } - - if ( right > _length ) - { - right = _length; - } - - char temp = _buffer[ right ]; // save the replaced character - _buffer[ right ] = '\0'; - String outPut = ( _buffer + left ); // pointer arithmetic - _buffer[ right ] = temp; //restore character - return outPut; + return indexOf( str, 0 ); } -String String::toLowerCase() const +int String::indexOf( const String &str, unsigned int fromIndex ) const { - String temp = _buffer; - - for ( unsigned int i = 0; i < _length; i++ ) - temp._buffer[ i ] = (char)tolower( temp._buffer[ i ] ); - return temp; + if ( fromIndex >= _length ) + return -1; + + const char *temp = strstr( &_buffer[ fromIndex ], str._buffer ); + + if ( temp == NULL ) + return -1; + + return temp - _buffer; // pointer subtraction } -String String::toUpperCase() const +int String::lastIndexOf( char ch ) const { - String temp = _buffer; - - for ( unsigned int i = 0; i < _length; i++ ) - temp._buffer[ i ] = (char)toupper( temp._buffer[ i ] ); - return temp; + return lastIndexOf( ch, _length - 1 ); } -String String::trim() const +int String::lastIndexOf( char ch, unsigned int fromIndex ) const { - String temp = _buffer; - unsigned int i,j; - - for ( i = 0; i < _length; i++ ) - { - if ( !isspace(_buffer[i]) ) - break; - } - - for ( j = temp._length - 1; j > i; j-- ) - { - if ( !isspace(_buffer[j]) ) - break; - } - - return temp.substring( i, j + 1); + if ( fromIndex >= _length ) + 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; +} + +int String::lastIndexOf( const String &str ) const +{ + return lastIndexOf( str, _length - str._length ); +} + +int String::lastIndexOf( const String &str, unsigned int fromIndex ) const +{ + // check for empty strings + if ( str._length == 0 || str._length - 1 > fromIndex || fromIndex >= _length ) + return -1; + /* + // matching first character + char temp = str[ 0 ]; + + for ( unsigned int i = fromIndex; i >= 0; i-- ) + { + if ( _buffer[ i ] == temp && (*this).substring( i, i + str._length ).equals( str ) ) + return i; + } + return -1; + */ + char *temp = strstr(&_buffer[_length-fromIndex], str._buffer); + if(temp == NULL) + return -1; + int index; + while( temp != NULL){ + index = temp - _buffer; + temp = strstr(&_buffer[index+1],str._buffer); + } + return index-_length+fromIndex; +} + +//version() returns the version of the library: +String String::version(void) +{ + return "1.0"; } - |