Annotation of parser3/src/include/pa_string.h, revision 1.144.2.28.2.50
1.41 paf 1: /** @file
1.43 paf 2: Parser: string class decl.
3:
1.144.2.18 paf 4: Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com)
1.124 paf 5: Author: Alexandr Petrosian <paf@design.ru> (http://paf.design.ru)
1.1 paf 6: */
7:
8: #ifndef PA_STRING_H
9: #define PA_STRING_H
1.140 paf 10:
1.144.2.28.2. 0(paf 11:3): static const char* IDENT_STRING_H="$Date: 2003/04/10 11:35:10 $";
1.144.2.10 paf 12:
13: // includes
1.1 paf 14:
1.144.2.12 paf 15: #include "pa_types.h"
16: #include "pa_array.h"
1.4 paf 17:
1.144.2.28.2. (paf 18:): extern "C" { // cord's author forgot to do that
7(paf 19:3): #define CORD_NO_IO
(paf 20:): #include "cord.h"
21:): };
22:):
1.144.2.12 paf 23: // forwards
1.144.2.10 paf 24:
1.144.2.28 paf 25: class Charset;
1.144.2.28.2. (paf 26:): class Table;
1.144.2.5 paf 27: class SQL_Connection;
28: class Dictionary;
1.144.2.15 paf 29: class Request_charsets;
1.144.2.28.2. (paf 30:): class String;
7(paf 31:3): typedef Array<const String*> ArrayString;
1.144.2.5 paf 32:
1.144.2.28.2. (paf 33:): /// this is result of pos functions which mean that substr were not found
34:): #define STRING_NOT_FOUND ((size_t)-1)
35:):
7(paf 36:3): class StringBody {
37:3):
38:3): CORD body;
39:3):
40:3): public:
41:3):
42:3): StringBody(): body(CORD_EMPTY) {}
5(paf 43:3): StringBody(CORD abody): body(abody) {
3(paf 44:3): assert(!body // no body
45:3): || *body // ordinary string
46:3): || body[1]==1 // CONCAT_HDR
47:3): || body[1]==4 // FN_HDR
48:3): || body[1]==6 // SUBSTR_HDR
49:3): );
5(paf 50:3): }
1(paf 51:3): /// WARNING: length is only HELPER length, str in ANY case should be zero-terminated
52:3): StringBody(const char* str, size_t helper_length): body(CORD_EMPTY) {
6(paf 53:3): append_know_length(str, helper_length?helper_length:strlen(str));
2(paf 54:3): }
4(paf 55:3): static StringBody Format(int value);
7(paf 56:3):
57:3): void clear() { body=CORD_EMPTY; }
58:3):
59:3): bool operator! () const { return is_empty(); }
60:3):
61:3): uint hash_code() const;
62:3):
0(paf 63:3): const char* cstr() const { return CORD_to_const_char_star(body); }
1(paf 64:3): char* cstrm() const { return CORD_to_char_star(body); }
0(paf 65:3):
7(paf 66:3): size_t length() const { return CORD_len(body); }
67:3):
68:3): bool is_empty() const { return body==CORD_EMPTY; }
69:3):
6(paf 70:3): void append_know_length(const char *str, size_t known_length) {
9(paf 71:3): if(known_length)
72:3): body=CORD_cat_char_star(body, str, known_length);
7(paf 73:3): }
6(paf 74:3): void append_strdup_know_length(const char* str, size_t known_length) {
9(paf 75:3): if(known_length)
76:3): append_know_length(pa_strdup(str, known_length), known_length);
1(paf 77:3): }
2(paf 78:3): void append(char c) { body=CORD_cat_char(body, c); }
6(paf 79:3): StringBody& operator << (const StringBody src) { body=CORD_cat(body, src.body); return *this; }
80:3): StringBody& operator << (const char* str) { append_know_length(str, strlen(str)); return *this; }
7(paf 81:3):
82:3): // could not figure out why this operator is needed [should do this chain: string->simple->==]
8(paf 83:3): bool operator < (const StringBody src) const { return CORD_cmp(body, src.body)<0; }
84:3): bool operator > (const StringBody src) const { return CORD_cmp(body, src.body)>0; }
85:3): bool operator <= (const StringBody src) const { return CORD_cmp(body, src.body)<=0; }
86:3): bool operator >= (const StringBody src) const { return CORD_cmp(body, src.body)>=0; }
87:3): bool operator != (const StringBody src) const { return CORD_cmp(body, src.body)!=0; }
88:3): bool operator == (const StringBody src) const { return CORD_cmp(body, src.body)==0; }
7(paf 89:3):
90:3): int ncmp(size_t x_begin, const StringBody y, size_t y_begin, size_t size) const {
91:3): return CORD_ncmp(body, x_begin, y.body, y_begin, size);
92:3): }
93:3):
94:3): char fetch(size_t index) const { return CORD_fetch(body, index); }
1(paf 95:3): StringBody mid(size_t index, size_t length) const { return CORD_substr(body, index, length); }
3(paf 96:3): size_t pos(const char* substr, size_t offset=0) const { return CORD_str(body, offset, substr); }
1(paf 97:3): size_t pos(const StringBody substr, size_t offset=0) const {
98:3): if(!substr.length())
99:3): return STRING_NOT_FOUND; // in this case CORD_str returns 0 [parser users got used to -1]
100:3): return CORD_str(body, offset, substr.body);
101:3): }
2(paf 102:3): size_t pos(char c,
103:3): size_t offset=0) const {
104:3): return CORD_chr(body, offset, c);
105:3): }
1(paf 106:3):
107:3): template<typename I> void for_each(int (*callback)(const char* s, I), I info) const {
108:3): CORD_iter5(body, 0, 0, (CORD_batched_iter_fn)callback, info);
109:3): }
110:3):
111:3): void set_pos(CORD_pos& pos, size_t index) const { CORD_set_pos(pos, body, index); }
7(paf 112:3):
5(paf 113:3): StringBody normalize() const {
114:3): return StringBody(CORD_balance(body));
115:3): }
116:3):
117:3): void dump() const {
118:3): CORD_dump(body);
119:3): }
7(paf 120:3): };
(paf 121:):
1.144.2.2 paf 122: /**
123: String which knows the language of all it's fragments.
1.41 paf 124:
125: All pieces remember
126: - whether they are tainted or not,
127: and the language which should be used to detaint them
128: */
1.144.2.28.2. (paf 129:): class String: public PA_Object {
130:):
2(paf 131:3): // friend class StringBody;
7(paf 132:3):
1.144.2.2 paf 133: public:
1.1 paf 134:
1.106 parser 135: /** piece is tainted or not. the language to use when detaint
136: remember to change String_Untaint_lang_name @ untaint.C along
137: */
1.144.2.28.2. 7(paf 138:3): enum Language {
139:3): L_UNSPECIFIED=0, ///< zero value handy for hash lookup @see untaint_lang_name2enum
140:3): // these two must go before others, there are checks for >L_AS_IS
141:3): L_CLEAN, ///< clean
142:3): L_AS_IS, ///< leave all characters intact
1.122 paf 143:
1.144.2.28.2. 7(paf 144:3): L_PASS_APPENDED,
1.41 paf 145: /**<
146: leave language built into string being appended.
147: just a flag, that value not stored
148: */
1.144.2.28.2. 7(paf 149:3): L_TAINTED, ///< tainted, untaint language as assigned later
1.122 paf 150: // untaint languages. assigned by ^untaint[lang]{...}
1.144.2.28.2. 7(paf 151:3): L_FILE_SPEC, ///< file specification
152:3): L_HTTP_HEADER, ///< text in HTTP response header
153:3): L_MAIL_HEADER, ///< text in mail header
154:3): L_URI, ///< text in uri
155:3): L_TABLE, ///< ^table:set body
156:3): L_SQL, ///< ^table:sql body
157:3): L_JS, ///< JavaScript code
158:3): L_XML, ///< ^dom:set xml
159:3): L_HTML, ///< HTML code (for editing)
160:3): L_OPTIMIZE_BIT = 0x8000 ///< flag, requiring cstr whitespace optimization
1.27 paf 161: };
162:
1.144.2.28.2. (paf 163:): struct Fragment {
7(paf 164:3): Language lang; ///< untaint flag, later untaint language
0(paf 165:3): size_t length; ///< length
9(paf 166:3): Fragment(Language alang, size_t asize): lang(alang), length(asize) {
3(paf 167:3): assert(alang!=L_UNSPECIFIED);
168:3): assert(asize!=(size_t)-1);
9(paf 169:3): }
(paf 170:): };
171:):
172:): class ArrayFragment: public Array<Fragment> {
6(paf 173:3): void append(element_type src) {
(paf 174:): *static_cast<Array<Fragment> *>(this)+=src;
175:): }
6(paf 176:3): /// hiding from accidental USE, use append_positions
177:3): void append(const ArrayFragment& src, int offset, int limit) {
178:3): static_cast<Array<Fragment> *>(this)->append(src, offset, limit);
179:3): }
(paf 180:): public:
181:): ArrayFragment& operator += (element_type src) {
8(paf 182:3): if(size_t lcount=count()) { // not empty?
(paf 183:): // try to join with last
4(paf 184:3): Fragment& last=get_ref(lcount-1);
(paf 185:): if(last.lang==src.lang) {
0(paf 186:3): last.length+=src.length;
(paf 187:): return *this;
188:): }
189:): }
6(paf 190:3): append(src);
(paf 191:): return *this;
192:): }
0(paf 193:3): void append(const ArrayFragment& src) { append(src, 0, ARRAY_OPTION_LIMIT_ALL); }
6(paf 194:3): void append_positions(const ArrayFragment& src, size_t substr_begin, size_t substr_end);
7(paf 195:3):
196:3): size_t length() {
197:3): size_t result=0;
198:3): for(Array_iterator<element_type> i(*this); i.has_next(); ) {
199:3): const Fragment fragment=i.next();
200:3): result+=fragment.length;
201:3): }
202:3): return result;
203:3): }
(paf 204:): };
205:):
206:): struct C {
7(paf 207:3): const char *str;
208:3): size_t length;
209:3): operator const char *() { return str; }
210:3): C(const char *astr, size_t asize): str(astr), length(asize) {}
211:3): };
212:3):
213:3): struct Cm {
(paf 214:): char *str;
0(paf 215:3): size_t length;
7(paf 216:3): //operator char *() { return str; }
217:3): Cm(char *astr, size_t asize): str(astr), length(asize) {}
(paf 218:): };
219:):
220:): private:
221:):
7(paf 222:3): StringBody body; ///< all characters of string
0(paf 223:3): ArrayFragment fragments; ///< fragment language+length info
(paf 224:):
1.8 paf 225: public:
226:
1.144.2.28.2. 6(paf 227:3): explicit String(const char* cstr=0, size_t helper_length=0, bool tainted=false);
8(paf 228:3): explicit String(const C cstr, bool tainted=false);
1.14 paf 229: String(const String& src);
1.144.2.28.2. 7(paf 230:3): String(StringBody abody, Language alang): body(abody) {
231:3): fragments+=Fragment(alang, abody.length());
232:3): }
8(paf 233:3):
234:3): #define ASSERT_STRING_INVARIANT(string) \
235:3): assert((string).body.length()==(string).fragments.length())
7(paf 236:3):
237:3): /// for convinient hash lookup
2(paf 238:3): operator const StringBody() const { return body; }
7(paf 239:3):
240:3): bool is_empty() const { return body.is_empty(); }
241:3): size_t length() const { return body.length(); }
(paf 242:):
2(paf 243:3): /// convert to CORD. if 'lang' known, forcing 'lang' to it
1(paf 244:3): StringBody cstr_to_string_body(Language lang=L_AS_IS,
7(paf 245:3): SQL_Connection* connection=0,
(paf 246:): const Request_charsets *charsets=0) const;
247:):
2(paf 248:3): /// convert to constant C string. if 'lang' known, forcing 'lang' to it
7(paf 249:3): const char* cstr(Language lang=L_AS_IS,
250:3): SQL_Connection* connection=0,
1.144.2.14 paf 251: const Request_charsets *charsets=0) const {
1.144.2.28.2. 1(paf 252:3): return cstr_to_string_body(lang, connection, charsets).cstr();
(paf 253:): }
2(paf 254:3): /// convert to Modifiable C string. if 'lang' known, forcing 'lang' to it
7(paf 255:3): char *cstrm(Language lang=L_AS_IS,
256:3): SQL_Connection* connection=0,
(paf 257:): const Request_charsets *charsets=0) const {
1(paf 258:3): return cstr_to_string_body(lang, connection, charsets).cstrm();
1.144.2.9 paf 259: }
1.108 parser 260: /// puts pieces to buf
1.144.2.28.2. 7(paf 261:3): Cm serialize(size_t prolog_size) const;
1.108 parser 262: /// appends pieces from buf to self
1.144.2.28.2. 4(paf 263:3): bool deserialize(size_t prolog_size, void *buf, size_t buf_size);
7(paf 264:3): /// @see StringBody::append_know_length
265:3): String& append_know_length(const char* str, size_t known_length, Language lang);
1(paf 266:3): /// @see StringBody::append_help_length
267:3): String& append_help_length(const char* str, size_t helper_length, Language lang);
6(paf 268:3): String& append_strdup(const char* str, size_t helper_length, Language lang);
(paf 269:):
7(paf 270:3): bool operator == (const char* y) const { return body==StringBody(y); }
0(paf 271:3): bool operator != (const char* y) const { return body!=StringBody(y); }
(paf 272:):
273:): /// this starts with y
7(paf 274:3): bool starts_with(const char* y) const {
275:3): return body.ncmp(0/*x_begin*/, StringBody(y), 0/*y_begin*/, strlen(y))==0;
1.80 paf 276: }
1.144.2.28.2. 9(paf 277:3): /// x starts with this
278:3): bool this_starts(const char* x) const {
279:3): return StringBody(x).ncmp(0/*x_begin*/, body, 0/*y_begin*/, length())==0;
(paf 280:): }
1.80 paf 281:
1.144.2.28.2. 7(paf 282:3): String& append_to(String& dest, Language lang, bool forced) const;
283:3): String& append(const String& src, Language lang, bool forced=false) {
1.144.2.11 paf 284: return src.append_to(*this, lang, forced);
285: }
1.144.2.28.2. 7(paf 286:3): String& operator << (const String& src) { return append(src, L_PASS_APPENDED); }
1(paf 287:3): String& operator << (const char* src) { return append_help_length(src, 0, L_AS_IS); }
8(paf 288:3): String& operator << (const StringBody src) {
6(paf 289:3): body<<src;
9(paf 290:3): fragments+=Fragment(L_AS_IS, src.length());
291:3): return *this;
292:3): }
1.100 parser 293:
1.142 paf 294: /// extracts first char of a string, if any
295: char first_char() const {
1.144.2.28.2. 7(paf 296:3): return is_empty()?0:body.fetch(0);
1.142 paf 297: }
1.144.2.28.2. 8(paf 298:3):
299:3): bool operator < (const String& src) const { return body<src.body; }
300:3): bool operator > (const String& src) const { return body>src.body; }
301:3): bool operator <= (const String& src) const { return body<=src.body; }
302:3): bool operator >= (const String& src) const { return body>=src.body; }
303:3): bool operator != (const String& src) const { return body!=src.body; }
304:3): bool operator == (const String& src) const { return body==src.body; }
1.54 paf 305:
306: /// extracts [start, finish) piece of string
1.144.2.28.2. 2(paf 307:3): String& mid(size_t substr_begin, size_t substr_end) const;
(paf 308:):
309:): /**
7(paf 310:3): ignore lang if it's L_UNSPECIFIED
(paf 311:): but when specified: look for substring that lies in ONE fragment in THAT lang
312:): @return position of substr in string, -1 means "not found" [const char* version]
313:): */
1(paf 314:3): size_t pos(const StringBody substr,
7(paf 315:3): size_t this_offset=0, Language lang=L_UNSPECIFIED) const;
316:3): /// String version of @see pos(const char*, int, Language)
(paf 317:): size_t pos(const String& substr,
7(paf 318:3): size_t this_offset=0, Language lang=L_UNSPECIFIED) const;
2(paf 319:3): size_t pos(char c,
320:3): size_t this_offset=0) const {
321:3): return body.pos(c, this_offset);
322:3): }
1.62 paf 323:
1.144.2.22 paf 324: void split(ArrayString& result,
1.144.2.28.2. 2(paf 325:3): size_t& pos_after,
(paf 326:): const char* delim,
2(paf 327:3): Language lang=L_UNSPECIFIED, int limit=-1) const;
1.144.2.22 paf 328: void split(ArrayString& result,
1.144.2.28.2. 5(paf 329:3): size_t& pos_after,
1.62 paf 330: const String& delim,
1.144.2.28.2. 7(paf 331:3): Language lang=L_UNSPECIFIED, int limit=-1) const;
1.62 paf 332:
1.144.2.28.2. 6(paf 333:3): typedef void (*Row_action)(Table& table, ArrayString* row,
1.136 paf 334: int prestart, int prefinish,
335: int poststart, int postfinish,
1.144.2.9 paf 336: void *info);
1.87 parser 337: /**
1.144.2.5 paf 338: @return table of found items, if any.
1.87 parser 339: table format is defined and fixed[can be used by others]:
340: @verbatim
341: prematch/match/postmatch/1/2/3/...
342: @endverbatim
343: */
1.144.2.28.2. (paf 344:): Table* match(Charset& source_charset,
1.64 paf 345: const String& regexp,
1.144.2.28.2. 5(paf 346:3): const String* options,
1.99 parser 347: Row_action row_action, void *info,
1.144.2.27 paf 348: bool& just_matched) const;
1.87 parser 349: enum Change_case_kind {
350: CC_UPPER,
351: CC_LOWER
352: };
1.144.2.28.2. (paf 353:): String& change_case(Charset& source_charset,
5(paf 354:3): Change_case_kind kind) const;
(paf 355:): const String& replace(const Dictionary& dict) const;
356:): double as_double() const;
357:): int as_int() const;
1.137 paf 358:
1.7 paf 359: private: //disabled
360:
1.12 paf 361: String& operator = (const String&) { return *this; }
1.7 paf 362:
1.1 paf 363: };
1.144.2.7 paf 364:
365: /// simple hash code of string. used by Hash
1.144.2.28.2. 8(paf 366:3): inline uint hash_code(const StringBody self) {
1.144.2.7 paf 367: return self.hash_code();
368: }
1.1 paf 369:
370: #endif
E-mail:
![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pa_string.h CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [parser3project] / parser3 / src / include