Debian Codegraph @

lib/common/String.cpp

raw
1 #include "avm_stl.h"
2 #include <string.h>
3 #include <ctype.h>
4 #include <stdio.h>
5 #include <stdlib.h>
6 #include <stdarg.h>
7
8 AVM_BEGIN_NAMESPACE;
9
10 static char empty_string[] = ""; // used as empty string - shall never be overwritten
11
12 string::string()
13 {
14 //str = new char[1];
15 //str[0] = 0;
16 str = empty_string;
17 }
18
19 string::string(char s)
20 {
21 str = new char[2];
22 str[0] = s;
23 str[1] = 0;
24 }
25
26 string::string(const char* s, size_type len)
27 {
28 size_t slen = (s) ? strlen(s) : 0;
29 if (len == 0 || len > slen)
30 len = slen;
31 str = new char[len + 1];
32 if (str)
33 {
34 if (s)
35 memcpy(str, s, len);
36 str[len] = 0;
37 }
38 else
39 str = empty_string;
40 }
41
42 string::string(const string& s, size_type len)
43 {
44 if (len == 0 || len > s.size())
45 len = s.size();
46
47 str = new char[len + 1];
48 if (str)
49 {
50 memcpy(str, s.str, len);
51 str[len] = 0;
52 }
53 else
54 str = empty_string;
55 }
56
57 string::~string()
58 {
59 if (str != empty_string)
60 {
61 //AVM_WRITE("Init", 0, "delete %s\n", str);
62 delete[] str;
63 }
64 }
65
66 bool string::operator==(const char* s) const
67 {
68 if (s)
69 return !strcmp(str, s);
70 return (size() == 0);
71 }
72
73 bool string::operator<(const string& s) const
74 {
75 return (strcmp(str, s.str)<0);
76 }
77
78 string& string::operator=(const char* s)
79 {
80 if (str != s)
81 {
82 if (str != empty_string)
83 delete[] str;
84 size_t sz = (!s) ? 0 : strlen(s) + 1;
85 if (sz > 1 && (str = new char[sz]))
86 memcpy(str, s, sz);
87 else
88 str = empty_string;
89 }
90 return *this;
91 }
92
93 string& string::operator+=(const char* s)
94 {
95 if (s)
96 {
97 size_type s1 = size();
98 size_t s2 = strlen(s) + 1; // with '0'
99 if (s2 > 1)
100 {
101 char* p = new char[s1 + s2];
102 if (p)
103 {
104 memcpy(p, str, s1);
105 memcpy(p + s1, s, s2);
106 if (str != empty_string)
107 delete[] str;
108 str = p;
109 }
110 }
111 }
112 return *this;
113 }
114
115 string& string::erase(size_type from, size_type to)
116 {
117 if (str != empty_string)
118 {
119 char* p = str + from;
120 if (to != npos && to > 0 && to < size())
121 {
122 // add check for size() ???
123 char* i = p + to;
124 while (*i)
125 *p++ = *i++;
126 }
127 if (p == str)
128 {
129 delete[] str;
130 str = empty_string;
131 }
132 else
133 *p = 0;
134 }
135 return *this;
136 }
137
138 void string::insert(size_type pos, const string& s)
139 {
140 size_type l = s.size();
141 size_type k = size();
142 char* p = new char[k + l + 1];
143 if (p)
144 {
145 strcpy(p, str);
146 strcpy(p + pos, s.str);
147 strcpy(p + pos + l, str + pos);
148 if (str != empty_string)
149 delete[] str;
150 str = p;
151 str[k + l] = 0;
152 }
153 }
154
155 string::size_type string::find(const string& s, size_type startpos) const
156 {
157 const char* p = strstr(str + startpos, s.str);
158 return (p) ? p - str : npos;
159 }
160
161 string::size_type string::find(char c) const
162 {
163 const char* p = strchr(str, c);
164 return (p) ? p - str : npos;
165 }
166
167 string::size_type string::rfind(char c) const
168 {
169 const char* p = strrchr(str, c);
170 return (p) ? p - str : npos;
171 }
172
173 int string::sprintf(const char* fmt, ...)
174 {
175 int r;
176 char* s = 0;
177 va_list ap;
178 va_start(ap, fmt);
179 if (str != empty_string)
180 delete[] str;
181 #ifdef _GNU_SOURCE
182 r = vasprintf(&s, fmt, ap);
183 #else
184 // a bit poor hack but should be sufficient
185 // eventually write full implementation
186 s = malloc(1000);
187 r = vsnprintf(s, 999, fmt, ap);
188 #endif
189 if (s && (str = new char[r + 1]))
190 {
191 memcpy(str, s, r);
192 str[r] = 0;
193 free(s);
194 }
195 else
196 {
197 str = empty_string;
198 r = 0;
199 }
200
201 return r;
202 }
203
204 string& string::tolower()
205 {
206 char* p = str;
207
208 while (*p) {
209 *p = (char)::tolower(*p);
210 p++;
211 }
212
213 return *this;
214 }
215
216 string& string::toupper()
217 {
218 char* p = str;
219
220 while (*p) {
221 *p = (char)::toupper(*p);
222 p++;
223 }
224
225 return *this;
226 }
227
228 AVM_END_NAMESPACE