Polaris: String.cc Source File

String.cc Go to the documentation of this file. /// #ifdef POLARIS_GNU_PRAGMAS #pragma implementation #endif /// #include <stdlib.h> #include <stream.h> #include <strstream.h> #include <string.h> #include <ctype.h> #include "String.h" #include "rotate.h" #include "p-assert.h" /// String dec(int i){ /// strstream s; /// s<<i<<'\0'; /// char* pc=s.str(); /// String toret(pc); /// delete pc; /// return toret; /// } /// String hex(int i){ /// strstream s; /// s.setf(ios::hex); /// s<<i<<'\0'; /// char* pc=s.str(); /// String toret(pc); /// delete pc; /// return toret; /// } static char * alloc_str(int size) { char *buf = new char[size]; p_assert( buf, "String: Out of memory" ); return buf; } char * upcase_ch(const char *string) { if(string == NULL) return NULL; /// ... Returns a copy of a string with all characters converted to upper case int len = strlen(string); char *buf = alloc_str(len + 1); for (int i = 0; i < len; i++) buf[i] = toupper(string[i]); buf[len] = '\0'; return buf; } int fortran_string_length(const char *string) /// ... Returns the length a char *string would be given in a Fortran program /// ... (this strips the enclosing quotes and any doubled internal quotes) { if(string == NULL) return 0; int len = strlen(string); int string_len = 0; for (int i = 1; i < (len - 1); i++) { if ((string[i] == '\'') && (string[i + 1] == '\'')) i++; string_len++; } return string_len; } String::~String() { #ifdef CLASS_INSTANCE_REGISTRY unregister_instance(STRING_CLASS, this); #endif if (_defined) { /// ... Before deleting the buffer, overwrite the current string with /// ... a distinctive footprint to help with debugging in the case /// ... where a string is deleted but a pointer remains to its internal /// ... buffer. const char *delete_msg = "*-*"; const int delete_msg_len = 3; if (_len >= delete_msg_len) strcpy(_ptr, delete_msg); else { /// ... If not enough room for the message, just truncate the /// ... string to zero length _ptr[0] = '\0'; } /// ... Now go ahead and delete the buffer delete [] _ptr; } _ptr = 0; _defined = 0; } void String::fillin_string(const int size, const char *chars) /// ... Fillin the values of the *this String structure { if (chars == 0) { /// ... NULL pointer _defined = 0; _ptr = ""; return; } _len = size >= 0 ? size : 0; _ptr = alloc_str(_len + 1); strncpy(_ptr, chars, (unsigned int) _len); _ptr[size] = '\000'; _defined = 1; } Boolean operator == (const char *str, const String & string) { return (string == str); } Boolean operator != (const char *str, const String & string) { return !(string == str); } Boolean operator < (const char *str, const String & string) { return (string < str); } String operator + (const char *str, const String & string) { if(str == NULL) return string; int str_len = strlen(str); String new_s; new_s._len = str_len + string._len; new_s._ptr = alloc_str(new_s._len + 1); strcpy(new_s._ptr, str); strcpy(new_s._ptr + str_len, string._ptr); new_s._defined = 1; return new_s; } String::String(const char *str) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(STRING_CLASS, sizeof(String), this); #endif _defined = 0; *this = str; } String::String(const String & other) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(STRING_CLASS, sizeof(String), this); #endif _defined = 0; *this = other.defined() ? other._ptr : 0; } String::String(const char *str, int max_len) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(STRING_CLASS, sizeof(String), this); #endif if (str == 0) { _defined = 0; _ptr = ""; return; } int len_to_use = max_len; /// Check to see if there is a terminating byte before str[max_len] const char *s = str; for (int i = 0; i < max_len; ++i, ++s) { if (!*s) { len_to_use = i; break; } } fillin_string(len_to_use, str); } String::String(const String & other, int first, int last) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(STRING_CLASS, sizeof(String), this); #endif /// ... Make a new string which is the substring of the given string /// ... starting at position "first", ending at position "last" if (((last - first) <= 0) || (first >= other._len)) { /// ... Return an empty string fillin_string(0, ""); } int end = (last < other._len ? last : other._len - 1); int size = end - first + 1; fillin_string(size, other._ptr + first); } String::String(const String & other, char *delim1, char *delim2) { #ifdef CLASS_INSTANCE_REGISTRY register_instance(STRING_CLASS, sizeof(String), this); #endif if ( ! other._defined) { _defined = 0; _ptr = ""; return; } /// ... Make a new string which is the substring of the given string /// ... starting at the position of the first char in "delim1" to be found /// ... and ending at the position of the first char in "delim2" to be found /// ... If delim1==NULL, then start at the beginning of the string /// ... If delim2==NULL, then end at the last char of the string int first = -1; int last = -1; if (!delim1) first = 0; else { int delim1_len = strlen(delim1); for (int i = 0; i < other._len; i++) { for (int j = 0; j < delim1_len; j++) { if (other._ptr[i] == delim1[j]) { first = i; break; } } if (first != -1) { /// ... found something in delim1 at i break; } } if (first == -1) { /// ... If we arrive here, then nothing in delim1 was found /// ... at any position in the string fillin_string(0, ""); return; } } if (!delim2) last = other._len - 1; else { int delim2_len = strlen(delim2); for (int i = first + 1; i < other._len; i++) { for (int j = 0; j < delim2_len; j++) { if (other._ptr[i] == delim2[j]) { last = i; break; } } if (last != -1) { /// ... found something in delim2 at i break; } } /// ... If we arrive here, then nothing in delim2 was found /// ... at any position in the string if (last == -1) { /// ... If we arrive here, then nothing in delim2 was found /// ... from after the "first" delimiter until the end fillin_string(other._len - first, other._ptr + first); return; } } fillin_string(last - first + 1, other._ptr + first); } String & String::operator = (const String & other) { *this = other._defined ? other._ptr : ""; return *this; } String & String::operator = (const String * other) { *this = (other && other->_defined) ? other->_ptr : ""; return *this; } String & String::operator = (const char *str) { p_assert((str != NULL), "Assign NULL value through String::operator ="); if (_defined) delete [] _ptr; fillin_string(strlen(str), str); return *this; } String String::operator + (const String & other) const { return *this + other._ptr; } String String::operator + (const char *str) const { if(str == NULL) return *this; int str_len = strlen(str); String new_s; new_s._len = str_len + _len; new_s._ptr = alloc_str(new_s._len + 1); strcpy(new_s._ptr, _ptr); strcpy(new_s._ptr + _len, str); new_s._defined = 1; return new_s; } String & String::operator += (const String & other) { *this += other._ptr; return *this; } String & String::operator += (const char *str) { p_assert((str != NULL), "NULL value for operand in String::operator ="); int new_len = strlen(str) + _len; char *buf = alloc_str(new_len + 1); strcpy(buf, _defined ? _ptr : ""); strcpy(buf + _len, str); if (_defined) delete [] _ptr; _ptr = buf; _len = new_len; _defined = 1; return *this; } /// Set the string to the value of allocated_str, without allocating new memory /// Note: allocated_str must have been allocated using new (not malloc) /// THIS MEMORY WILL BE DELETED UPON DESTROYING THE STRING!! void String::absorb(char *allocated_str) { if (_defined) delete [] _ptr; if (allocated_str == 0) { _defined = 0; _ptr = ""; return; } _ptr = allocated_str; _len = strlen(_ptr); _defined = 1; } unsigned String::hash_value() const { if (!_defined) return 0x12345654; /// ... Start with something besides 0 so that even short strings will be /// ... spread out across a fair spectrum of hash values unsigned val = 0xA65C5793; for (char *p = _ptr; *p; ++p) val = rotate_right(val) ^ *p; return val; } int String::index(const char *substring) const /// ... Return the index into a string where the given substring begins { if ( ! _defined ) return -1; char *subptr = strstr(_ptr, substring); return subptr ? (subptr - _ptr) : -1; } int String::index_case(const char *substring) const /// ... Return the index into a string where the given substring begins, /// ... ignoring the case of both strings { if ( ! _defined ) return -1; /// ... Make an upper-case copy of the *this String: char *upstring = alloc_str(_len + 1); upstring = upcase_ch(_ptr); upstring[_len] = '\0'; /// ... Make an upper-case version of substring int sublen = strlen(substring); char *upsubstring = alloc_str(sublen + 1); upsubstring = upcase_ch(substring); upsubstring[sublen] = '\0'; char *subptr = strstr(upstring, upsubstring); if (subptr == 0) { delete [] upstring; delete [] upsubstring; return -1; } else { int ret = subptr - upstring; delete [] upstring; delete [] upsubstring; return ret; } } String String::upcase() const { if (!_defined) return 0; /// ... Return an undefined String String str; str.fillin_string(_len, upcase_ch(_ptr)); return str; } int String::structures_OK() const { if (_ptr == 0) { cerr << "Error: String: structures_OK() found a string pointing " << "to NULL (which is bad even if the String is undefined)\n"; return 0; } if (!_defined) return 1; /// ... Make sure the length of the string matches _len int len = strlen(_ptr); if (len != _len) { cerr << "Error: String: structures_OK() found a string of length " << len << " but expected a length of " << _len << ". " << flush; if (len < 100) cerr << "String = \"" << *this << "\"\n"; else { cerr << "First 100 characters of string = \""; for (int i = 0; i<100; ++i) cerr << _ptr[i]; cerr << "\"\n"; } return 0; } return 1; }

© 1995-2005 University of Illinois, Urbana-Champaign. All rights reserved.  Fri Mar 25 23:06:13 2005