44100 is now an allowed frequency, too.
[swftools.git] / pdf2swf / xpdf / GString.cc
1 //========================================================================
2 //
3 // GString.cc
4 //
5 // Simple variable-length string type.
6 //
7 // Copyright 1996-2002 Glyph & Cog, LLC
8 //
9 //========================================================================
10
11 #ifdef __GNUC__
12 #pragma implementation
13 #endif
14
15 #include <aconf.h>
16 #include <stdlib.h>
17 #include <stddef.h>
18 #include <string.h>
19 #include <ctype.h>
20 #include "gtypes.h"
21 #include "GString.h"
22
23 static inline int size(int len) {
24   int delta;
25
26   delta = len < 256 ? 7 : 255;
27   return ((len + 1) + delta) & ~delta;
28 }
29
30 inline void GString::resize(int length1) {
31   char *s1;
32
33   if (!s) {
34     s = new char[size(length1)];
35   } else if (size(length1) != size(length)) {
36     s1 = new char[size(length1)];
37     memcpy(s1, s, length + 1);
38     delete[] s;
39     s = s1;
40   }
41 }
42
43 GString::GString() {
44   s = NULL;
45   resize(length = 0);
46   s[0] = '\0';
47 }
48
49 GString::GString(const char *sA) {
50   int n = strlen(sA);
51
52   s = NULL;
53   resize(length = n);
54   memcpy(s, sA, n + 1);
55 }
56
57 GString::GString(const char *sA, int lengthA) {
58   s = NULL;
59   resize(length = lengthA);
60   memcpy(s, sA, length * sizeof(char));
61   s[length] = '\0';
62 }
63
64 GString::GString(GString *str, int idx, int lengthA) {
65   s = NULL;
66   resize(length = lengthA);
67   memcpy(s, str->getCString() + idx, length);
68   s[length] = '\0';
69 }
70
71 GString::GString(GString *str) {
72   s = NULL;
73   resize(length = str->getLength());
74   memcpy(s, str->getCString(), length + 1);
75 }
76
77 GString::GString(GString *str1, GString *str2) {
78   int n1 = str1->getLength();
79   int n2 = str2->getLength();
80
81   s = NULL;
82   resize(length = n1 + n2);
83   memcpy(s, str1->getCString(), n1);
84   memcpy(s + n1, str2->getCString(), n2 + 1);
85 }
86
87 GString *GString::fromInt(int x) {
88   char buf[24]; // enough space for 64-bit ints plus a little extra
89   GBool neg;
90   Guint y;
91   int i;
92
93   i = 24;
94   if (x == 0) {
95     buf[--i] = '0';
96   } else {
97     if ((neg = x < 0)) {
98       y = (Guint)-x;
99     } else {
100       y = (Guint)x;
101     }
102     while (i > 0 && y > 0) {
103       buf[--i] = '0' + y % 10;
104       y /= 10;
105     }
106     if (neg && i > 0) {
107       buf[--i] = '-';
108     }
109   }
110   return new GString(buf + i, 24 - i);
111 }
112
113 GString::~GString() {
114   delete[] s;
115 }
116
117 GString *GString::clear() {
118   s[length = 0] = '\0';
119   resize(0);
120   return this;
121 }
122
123 GString *GString::append(char c) {
124   resize(length + 1);
125   s[length++] = c;
126   s[length] = '\0';
127   return this;
128 }
129
130 GString *GString::append(GString *str) {
131   int n = str->getLength();
132
133   resize(length + n);
134   memcpy(s + length, str->getCString(), n + 1);
135   length += n;
136   return this;
137 }
138
139 GString *GString::append(const char *str) {
140   int n = strlen(str);
141
142   resize(length + n);
143   memcpy(s + length, str, n + 1);
144   length += n;
145   return this;
146 }
147
148 GString *GString::append(const char *str, int lengthA) {
149   resize(length + lengthA);
150   memcpy(s + length, str, lengthA);
151   length += lengthA;
152   s[length] = '\0';
153   return this;
154 }
155
156 GString *GString::insert(int i, char c) {
157   int j;
158
159   resize(length + 1);
160   for (j = length + 1; j > i; --j)
161     s[j] = s[j-1];
162   s[i] = c;
163   ++length;
164   return this;
165 }
166
167 GString *GString::insert(int i, GString *str) {
168   int n = str->getLength();
169   int j;
170
171   resize(length + n);
172   for (j = length; j >= i; --j)
173     s[j+n] = s[j];
174   memcpy(s+i, str->getCString(), n);
175   length += n;
176   return this;
177 }
178
179 GString *GString::insert(int i, const char *str) {
180   int n = strlen(str);
181   int j;
182
183   resize(length + n);
184   for (j = length; j >= i; --j)
185     s[j+n] = s[j];
186   memcpy(s+i, str, n);
187   length += n;
188   return this;
189 }
190
191 GString *GString::insert(int i, const char *str, int lengthA) {
192   int j;
193
194   resize(length + lengthA);
195   for (j = length; j >= i; --j)
196     s[j+lengthA] = s[j];
197   memcpy(s+i, str, lengthA);
198   length += lengthA;
199   return this;
200 }
201
202 GString *GString::del(int i, int n) {
203   int j;
204
205   if (n > 0) {
206     for (j = i; j <= length - n; ++j)
207       s[j] = s[j + n];
208     resize(length -= n);
209   }
210   return this;
211 }
212
213 GString *GString::upperCase() {
214   int i;
215
216   for (i = 0; i < length; ++i) {
217     if (islower(s[i]))
218       s[i] = toupper(s[i]);
219   }
220   return this;
221 }
222
223 GString *GString::lowerCase() {
224   int i;
225
226   for (i = 0; i < length; ++i) {
227     if (isupper(s[i]))
228       s[i] = tolower(s[i]);
229   }
230   return this;
231 }