Annotation of parser3/src/include/pa_string.h, revision 1.144.2.24

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.24! paf        11: static const char* IDENT_STRING_H="$Date: 2003/02/14 12:59:10 $";
1.144.2.10  paf        12: 
                     13: // includes
1.1       paf        14: 
1.15      paf        15: #include "pa_pool.h"
1.144.2.12  paf        16: #include "pa_types.h"
                     17: #include "pa_array.h"
1.4       paf        18: 
1.144.2.12  paf        19: // forwards
1.144.2.10  paf        20: 
1.144.2.22  paf        21: class Table; DECLARE_OBJECT_PTR(Table);
1.144.2.5  paf        22: class SQL_Connection;
                     23: class Dictionary;
1.144.2.15  paf        24: class Request_charsets;
1.144.2.22  paf        25: typedef Array<StringPtr> ArrayString; DECLARE_OBJECT_PTR(ArrayString);
1.144.2.5  paf        26: 
                     27: // helpers
                     28: 
1.9       paf        29: #ifndef NO_STRING_ORIGIN
1.33      paf        30: #      define STRING_APPEND_PARAMS \
1.144.2.18  paf        31:                const char* src, size_t size,  \
1.144.2.7  paf        32:                String_UL lang, \
1.144.2.18  paf        33:                const char* file, uint line
1.54      paf        34: /// appends piece to String  @see String::real_append
                     35: #      define APPEND(src, size, lang, file, line) \
                     36:                real_append(src, size, lang, file, line)
1.9       paf        37: #else
1.33      paf        38: #      define STRING_APPEND_PARAMS \
1.144.2.18  paf        39:                const char* src, \
1.33      paf        40:                size_t size, \
1.144.2.7  paf        41:                String_UL lang
1.54      paf        42: /// appends piece to String  @see String::real_append
                     43: #      define APPEND(src, size, lang, file, line) \
                     44:                real_append(src, size, lang)
                     45: #endif
1.83      paf        46: /// appends clean piece to String @see String::real_append
1.54      paf        47: #define APPEND_CLEAN(src, size, file, line) \
1.62      paf        48:        APPEND(src, size, String::UL_CLEAN, file, line)
1.83      paf        49: /// appends piece to String as-is @see String::real_append
                     50: #define APPEND_AS_IS(src, size, file, line) \
                     51:        APPEND(src, size, String::UL_AS_IS, file, line)
1.48      paf        52: /// appends tainted piece to String  @see String::real_append
1.54      paf        53: #define APPEND_TAINTED(src, size, file, line) \
1.62      paf        54:        APPEND(src, size, String::UL_TAINTED, file, line)
1.48      paf        55: /// handy: appends const char* piece to String  @see String::real_append
1.83      paf        56: #define        APPEND_CONST(src) APPEND_AS_IS(src, 0, 0, 0)
1.9       paf        57: 
1.144.2.7  paf        58: typedef uint String_UL;
                     59: 
1.144.2.2  paf        60: struct String_fragment { 
1.144.2.7  paf        61:        String_UL/*Untaint_lang*/ lang; ///< untaint flag, later untaint language
1.144.2.18  paf        62:        const char* ptr;  ///< pointer to the start
1.144.2.2  paf        63:        size_t size;  ///< length
1.41      paf        64: 
1.144.2.2  paf        65: #ifndef NO_STRING_ORIGIN
                     66:        /// all String pieces hold information of where they come from
                     67:        struct Origin {
1.144.2.18  paf        68:                const char* file;  ///< macros file name | load file name | sql query text
1.144.2.2  paf        69:                uint line; ///< file line no | record no
                     70:        } origin;  ///< origin
                     71: #endif
                     72: };
                     73: 
                     74: /** 
                     75:        String which knows the language of all it's fragments.
1.41      paf        76: 
                     77:        All pieces remember 
                     78:        - the file and its line they are from [can be turned off by NO_STRING_ORIGIN]
                     79:        - whether they are tainted or not, 
                     80:          and the language which should be used to detaint them
                     81: */
1.48      paf        82: 
1.144.2.2  paf        83: class String: public Array<String_fragment> {
                     84:        size_t fsize;
1.144.2.24! paf        85:        int count() const { return 0; } // hiding fro accidental use instead of size()
1.144.2.2  paf        86: public:
1.1       paf        87: 
1.106     parser     88:        /** piece is tainted or not. the language to use when detaint
                     89:                remember to change String_Untaint_lang_name @ untaint.C along
                     90:        */
1.27      paf        91:        enum Untaint_lang {
1.72      paf        92:                UL_UNSPECIFIED=0, ///< zero value handy for hash lookup @see untaint_lang_name2enum
1.122     paf        93:                // these two must go before others, there are checks for >UL_AS_IS
1.62      paf        94:                UL_CLEAN, ///< clean
1.122     paf        95:                UL_AS_IS,     ///< leave all characters intact
                     96: 
1.48      paf        97:                UL_PASS_APPENDED,
1.41      paf        98:                        /**<
                     99:                                leave language built into string being appended.
                    100:                                just a flag, that value not stored
                    101:                        */
1.122     paf       102:                UL_TAINTED,  ///< tainted, untaint language as assigned later 
                    103:                // untaint languages. assigned by ^untaint[lang]{...}
1.103     parser    104:                UL_FILE_SPEC, ///< file specification
1.74      paf       105:                UL_HTTP_HEADER,    ///< text in HTTP response header
                    106:                UL_MAIL_HEADER,    ///< text in mail header
1.48      paf       107:                UL_URI,       ///< text in uri
                    108:                UL_TABLE,     ///< ^table:set body
                    109:                UL_SQL,       ///< ^table:sql body
                    110:                UL_JS,        ///< JavaScript code
1.102     parser    111:                UL_XML,         ///< ^dom:set xml
1.48      paf       112:                UL_HTML,      ///< HTML code (for editing)
1.144.2.7  paf       113:                UL_OPTIMIZE_BIT = 0x8000  ///< flag, requiring cstr whitespace optimization
1.27      paf       114:        };
                    115: 
1.8       paf       116: public:
                    117: 
1.144.2.18  paf       118:        explicit String(const char* src=0, size_t src_size=0, bool tainted=false);
1.14      paf       119:        String(const String& src);
1.144.2.2  paf       120:        bool is_empty() const { return !size(); }
                    121:        size_t size() const { return fsize; }
1.69      paf       122:        /// convert to C string. if 'lang' known, forcing 'lang' to it
1.144.2.5  paf       123:        CharPtr cstr(Untaint_lang lang=UL_AS_IS, 
1.82      paf       124:                SQL_Connection *connection=0,
1.144.2.14  paf       125:                const Request_charsets *charsets=0) const {
1.88      parser    126: 
1.144.2.12  paf       127:                CharPtr result(new char[cstr_bufsize(lang, connection, charsets)]);
                    128:                char *eol=store_to(result.get(), lang, connection, charsets);
1.50      paf       129:                *eol=0;
                    130:                return result;
                    131:        }
1.144.2.9  paf       132:        char *cstr(Pool& pool, Untaint_lang lang=UL_AS_IS, 
                    133:                SQL_Connection *connection=0,
1.144.2.14  paf       134:                const Request_charsets *charsets=0) const {
1.144.2.12  paf       135:                char *result=new(pool) char[cstr_bufsize(lang, connection, charsets)];
                    136:                char *eol=store_to(result, lang, connection, charsets);
1.144.2.9  paf       137:                *eol=0;
                    138:                return result;
                    139:        }
1.144.2.12  paf       140:        char *cstr_debug_origins(Pool& pool) const;
1.108     parser    141:        /// puts pieces to buf
1.144.2.5  paf       142:        void serialize(Pool& pool, size_t prolog_size,  char *& buf, size_t& buf_size) const;
1.108     parser    143:        /// appends pieces from buf to self
1.144.2.18  paf       144:        bool deserialize(size_t prolog_size, void *buf, size_t buf_size, const char* file);
1.46      paf       145:        /** append fragment
1.83      paf       146:                @see APPEND_AS_IS, APPEND_CLEAN, APPEND_TAINTED, APPEND_CONST
1.46      paf       147:        */
1.9       paf       148:        String& real_append(STRING_APPEND_PARAMS);
1.44      paf       149:        /// @return <0 ==0 or >0 depending on comparison result
1.62      paf       150:        int cmp (int& partial, const String& src, 
1.72      paf       151:                size_t this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;
1.56      paf       152:        bool operator < (const String& src) const {     int p; return cmp(p, src)<0; }
                    153:        bool operator > (const String& src) const {     int p; return cmp(p, src)>0; }
                    154:        bool operator <= (const String& src) const { int p; return cmp(p, src)<=0; }
                    155:        bool operator >= (const String& src) const { int p; return cmp(p, src)>=0; }
1.26      paf       156:        bool operator == (const String& src) const {
                    157:                if(size()!=src.size()) // can speed up in trivial case
                    158:                        return false;
1.56      paf       159:                int p; return cmp(p, src)==0;
1.26      paf       160:        }
1.56      paf       161:        bool operator != (const String& src) const { int p; return cmp(p, src)!=0; }
1.26      paf       162: 
1.50      paf       163:        /**
                    164:                 @param partial 
                    165:                        returns partial match status. 
1.51      paf       166:                        - -1: strings too different
                    167:                        -  0: full match
                    168:                        -  1: means @c this starts @c src
                    169:                        -  2: means @src starts @this
1.50      paf       170:        */
1.61      paf       171:        int cmp(int& partial, const char* src_ptr, size_t src_size=0, 
1.72      paf       172:                size_t this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;
1.139     paf       173:        /// this starts with src
                    174:        bool starts_with(const char* src_ptr, size_t src_size=0) const {
                    175:                int p; cmp(p, src_ptr, src_size);
                    176:                return p==0 || p==2;
                    177:        }
1.50      paf       178:        bool operator == (const char* src_ptr) const { 
                    179:                size_t src_size=src_ptr?strlen(src_ptr):0;
                    180:                if(size() != src_size)
                    181:                        return false;
                    182:                int partial; // unused
1.56      paf       183:                return cmp(partial, src_ptr, src_size)==0; 
1.50      paf       184:        }
1.80      paf       185:        bool operator != (const char* src_ptr) const { 
                    186:                int partial; // unused
                    187:                return cmp(partial, src_ptr, 0)!=0; 
                    188:        }
                    189: 
1.144.2.11  paf       190:        String& append_to(String& dest, uchar lang, bool forced) const;
                    191:        String& append(const String& src, uchar lang, bool forced=false) { 
                    192:                return src.append_to(*this, lang, forced);
                    193:        }
1.76      paf       194:        String& operator << (const String& src) { return append(src, UL_PASS_APPENDED); }
1.144.2.17  paf       195:        String& operator << (StringPtr src) { return append(*src, UL_PASS_APPENDED); }
1.144.2.18  paf       196:        String& operator << (const char* src) { return APPEND_CONST(src); }
1.8       paf       197: 
1.144.2.7  paf       198:        /// simple hash code of string
1.14      paf       199:        uint hash_code() const;
1.100     parser    200: 
1.142     paf       201:        /// extracts first char of a string, if any
                    202:        char first_char() const {
1.144.2.2  paf       203:                return is_empty()?0:*felements[0].ptr;
1.142     paf       204:        }
1.54      paf       205: 
                    206:        /// extracts [start, finish) piece of string
1.144.2.4  paf       207:        StringPtr mid(size_t start, size_t finish) const;
1.55      paf       208: 
1.59      paf       209:        /// @return position of substr in string, -1 means "not found" [String version]
1.62      paf       210:        int pos(const String& substr, 
1.112     paf       211:                int this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;
1.59      paf       212:        /// @return position of substr in string, -1 means "not found" [const char* version]
1.144.2.18  paf       213:        int pos(const char* substr, size_t substr_size=0, 
1.112     paf       214:                int this_offset=0, Untaint_lang lang=UL_UNSPECIFIED) const;
1.62      paf       215: 
1.144.2.22  paf       216:        void split(ArrayString& result, 
1.62      paf       217:                size_t *pos_after_ref, 
1.144.2.18  paf       218:                const char* delim, size_t delim_size, 
1.144.2.17  paf       219:                Untaint_lang lang=UL_UNSPECIFIED, int limit=-1);
1.144.2.22  paf       220:        void split(ArrayString& result, 
1.62      paf       221:                size_t *pos_after_ref, 
                    222:                const String& delim, 
1.144.2.17  paf       223:                Untaint_lang lang=UL_UNSPECIFIED, int limit=-1);
1.62      paf       224: 
1.144.2.23  paf       225:        typedef void (*Row_action)(TablePtr table, ArrayStringPtr row, 
1.136     paf       226:                int prestart, int prefinish, 
                    227:                int poststart, int postfinish,
1.144.2.9  paf       228:                void *info);
1.87      parser    229:        /**
1.144.2.5  paf       230:                @return table of found items, if any.
1.87      parser    231:                table format is defined and fixed[can be used by others]: 
                    232:                @verbatim
                    233:                        prematch/match/postmatch/1/2/3/...
                    234:                @endverbatim
                    235:        */
1.144.2.9  paf       236:        TablePtr match(Charset& source_charset,
1.144.2.17  paf       237:                StringPtr aorigin,              
1.64      paf       238:                const String& regexp, 
1.144.2.17  paf       239:                StringPtr options,
1.99      parser    240:                Row_action row_action, void *info,
1.144.2.9  paf       241:                bool *was_global=0) const;
1.87      parser    242:        enum Change_case_kind {
                    243:                CC_UPPER,
                    244:                CC_LOWER
                    245:        };
1.144.2.5  paf       246:        StringPtr change_case(Pool& pool, Charset& source_charset,
1.144.2.17  paf       247:                Change_case_kind kind);
1.144.2.5  paf       248:        StringPtr replace(Pool& pool, Dictionary& dict) const;
1.144.2.17  paf       249:        double as_double();
                    250:        int as_int();
1.137     paf       251: 
1.144.2.5  paf       252:        StringPtr join_chains(Pool& pool) const;
1.13      paf       253: 
1.41      paf       254: #ifndef NO_STRING_ORIGIN
                    255:        /// origin of string. calculated by first row
1.144.2.2  paf       256:        const String_fragment::Origin& origin() const;
1.41      paf       257: #endif
1.8       paf       258: 
1.144.2.5  paf       259:        size_t cstr_bufsize(Untaint_lang lang=UL_UNSPECIFIED,
                    260:                SQL_Connection *connection=0,
1.144.2.14  paf       261:                const Request_charsets *charsets=0) const;
1.79      paf       262:        /// convert to C string, store to 'dest' which must be big enough for proper untaint
1.82      paf       263:        char *store_to(char *dest, Untaint_lang lang=UL_UNSPECIFIED, 
                    264:                SQL_Connection *connection=0,
1.144.2.14  paf       265:                const Request_charsets *charsets=0) const;
1.144.2.2  paf       266: /*
1.144.2.1  paf       267:        void join_chain(
1.130     paf       268:                                           const Chunk*& achunk, const Chunk::Row*& arow, uint& acountdown, 
1.144.2.18  paf       269:                                           uchar& joined_lang, const char* & joined_ptr, size_t& joined_size) const;
1.144.2.2  paf       270: */
1.7       paf       271: private: //disabled
                    272: 
1.12      paf       273:        String& operator = (const String&) { return *this; }
1.7       paf       274: 
1.1       paf       275: };
1.144.2.22  paf       276: 
1.144.2.7  paf       277: 
                    278: /// simple hash code of string. used by Hash
                    279: inline uint hash_code(const String& self) {
                    280:        return self.hash_code();
                    281: }
                    282: /// simple hash code of string. used by Hash
1.144.2.17  paf       283: inline uint hash_code(StringPtr self) {
1.144.2.7  paf       284:        return self->hash_code();
                    285: }
1.144.2.5  paf       286: 
                    287: // helpers
                    288: 
                    289: #define STRING_PREPARED_FOREACH_FRAGMENT(code) \
                    290:        for(; fragment<last; fragment++) { \
                    291:                code; \
                    292:        }
                    293: 
                    294: #define STRING_FOREACH_FRAGMENT(code) \
                    295:        { \
                    296:                element_type *last = felements+fused; \
                    297:                element_type *fragment = felements; \
                    298:                STRING_PREPARED_FOREACH_FRAGMENT(code) \
                    299:        }
1.1       paf       300: 
                    301: #endif

E-mail: