removed string(FILE *) constructor and save(FILE *) member function.
[dyninst.git] / common / src / String.C
1 // String.C
2
3 #include <assert.h>
4 #include "util/h/String.h"
5
6 string string::quote="\"";
7
8 string::string()
9     : str_(0), len_(0), key_(0) {
10 }
11
12 string::string(const char* str)
13     : str_(STRDUP(str)), len_(STRLEN(str)), key_(hashs(str)) {
14 }
15
16 string::string(const string& s)
17     : str_(STRDUP(s.str_)), len_(s.len_), key_(s.key_) {
18 }
19
20 string::string(int i) {
21    char tempBuffer[40];
22    sprintf(tempBuffer, "%d", i);
23
24    str_ = STRDUP(tempBuffer);
25    len_ = STRLEN(tempBuffer);
26    key_ = hashs (tempBuffer);
27 }
28
29 string::string(unsigned u) {
30    char tempBuffer[40];
31    sprintf(tempBuffer, "%u", u);
32
33    str_ = STRDUP(tempBuffer);
34    len_ = STRLEN(tempBuffer);
35    key_ = hashs (tempBuffer);
36 }
37
38 string::string(float f) {
39    char tempBuffer[40];
40    sprintf(tempBuffer, "%f", f);
41
42    str_ = STRDUP(tempBuffer);
43    len_ = STRLEN(tempBuffer);
44    key_ = hashs (tempBuffer);
45 }
46
47 string::string(double d) {
48    char tempBuffer[40];
49    sprintf(tempBuffer, "%g", d);
50
51    str_ = STRDUP(tempBuffer);
52    len_ = STRLEN(tempBuffer);
53    key_ = hashs (tempBuffer);
54 }
55
56 string::~string() {
57     delete [] str_; str_ = 0;
58 }
59
60 string&
61 string::operator=(const char* str) {
62     if (str_ == str) {
63         return *this;
64     }
65
66     delete [] str_; str_ = 0;
67
68     str_ = STRDUP(str);
69     len_ = STRLEN(str);
70     key_ = hashs(str);
71
72     return *this;
73 }
74
75 string&
76 string::operator=(const string& s) {
77     if (this == &s) {
78         return *this;
79     }
80
81     delete [] str_; str_ = 0;
82
83     str_ = STRDUP(s.str_);
84     len_ = s.len_;
85     key_ = s.key_;
86
87     return *this;
88 }
89
90 string&
91 string::operator+=(const string& s) {
92     unsigned nlen = len_ + s.len_;
93     char*    ptr  = new char[nlen+1];
94
95     memcpy(ptr, str_, len_);
96     memcpy(&ptr[len_], s.str_, s.len_);
97     ptr[nlen] = '\0';
98
99     delete[] str_; str_ = 0;
100     str_ = ptr;
101     len_ = nlen;
102     key_ = hashs(str_);
103
104     return *this;
105 }
106
107 string
108 string::operator+(const string& s) const {
109     string ret = *this;
110     return ret += s;
111 }
112
113 bool
114 string::operator==(const string& s) const {
115     return ((&s == this)
116         || ((key_ == s.key_)
117         && (len_ == s.len_)
118         && STREQ(str_, s.str_)));
119 }
120
121 bool
122 string::operator!=(const string& s) const {
123     return ((!(&s == this)) && (len_ != s.len_)
124         || STRNE(str_, s.str_));
125 }
126
127 bool
128 string::operator<=(const string& s) const {
129     return ((&s == this) || STRLE(str_, s.str_));
130 }
131
132 bool
133 string::operator>=(const string& s) const {
134     return ((&s == this) || STRGE(str_, s.str_));
135 }
136
137 bool
138 string::prefix_of(const char* s, unsigned sl) const {
139     return ((len_ > sl) ? false : STREQN(str_, s, len_));
140 }
141
142 bool
143 string::prefix_of(const string& s) const {
144     return ((&s == this) || prefix_of(s.str_, s.len_));
145 }
146
147 bool
148 string::prefixed_by(const char* s, unsigned sl) const {
149     return ((sl > len_) ? false : STREQN(str_, s, sl));
150 }
151
152 bool
153 string::prefixed_by(const string& s) const {
154     return ((&s == this) || prefixed_by(s.str_, s.len_));
155 }
156
157 unsigned
158 string::hashs(const char* str) {
159     if (!str) {
160         return 0;
161     }
162
163     unsigned h = 5381;
164     while (*str) {
165         h = (h << 5) + h + (unsigned) (*str);
166         str++;
167     }
168     return h;
169 }
170
171 unsigned
172 string::STRLEN(const char* str) {
173     return ((str)?(P_strlen(str)):(0));
174 }
175
176 char*
177 string::STRDUP(const char* str) {
178     if (!str) {
179         return 0;
180     }
181
182     unsigned size = P_strlen(str)+1;
183     char*    p    = new char[size];
184
185     (void) P_memcpy(p, str, size);
186     return p;
187 }
188
189 bool
190 string::STREQ(const char* s1, const char* s2) {
191     return ((s1&&s2)?(P_strcmp(s1,s2)==0):(!(s1||s2)));
192 }
193
194 bool
195 string::STREQN(const char* s1, const char* s2, unsigned len) {
196     return ((s1&&s2)?(P_strncmp(s1,s2,len)==0):(!(s1||s2)));
197 }
198
199 bool
200 string::STRNE(const char* s1, const char* s2) {
201     return ((s1&&s2)?(P_strcmp(s1,s2)!=0):(false));
202 }
203
204 bool
205 string::STRLT(const char* s1, const char* s2) {
206     return ((s1&&s2)?(P_strcmp(s1,s2)<0):(false));
207 }
208
209 bool
210 string::STRLE(const char* s1, const char* s2) {
211     return ((s1&&s2)?(P_strcmp(s1,s2)<=0):(!(s1||s2)));
212 }
213
214 bool
215 string::STRGT(const char* s1, const char* s2) {
216     return ((s1&&s2)?(P_strcmp(s1,s2)>0):(false));
217 }
218
219 bool
220 string::STRGE(const char* s1, const char* s2) {
221     return ((s1&&s2)?(P_strcmp(s1,s2)>=0):(!(s1||s2)));
222 }
223
224 ostream& operator<< (ostream &os, const string &s) {
225    return os << s.str_;
226 }
227
228