Annotation of parser3/src/classes/string.C, revision 1.53

1.24      paf         1: /** @file
                      2:        Parser: @b string parser class.
                      3: 
1.4       paf         4:        Copyright (c) 2001 ArtLebedev Group (http://www.artlebedev.com)
1.24      paf         5: 
1.5       paf         6:        Author: Alexander Petrosyan <paf@design.ru> (http://design.ru/paf)
1.4       paf         7: 
1.53    ! parser      8:        $Id: string.C,v 1.52 2001/05/19 18:35:40 parser Exp $
1.1       paf         9: */
                     10: 
1.43      paf        11: #include "classes.h"
1.1       paf        12: #include "pa_request.h"
                     13: #include "pa_vdouble.h"
                     14: #include "pa_vint.h"
1.17      paf        15: #include "pa_vtable.h"
1.25      paf        16: #include "pa_vbool.h"
1.27      paf        17: #include "pa_string.h"
1.53    ! parser     18: #include "pa_sql_connection.h"
1.1       paf        19: 
1.41      paf        20: // defines
1.1       paf        21: 
1.41      paf        22: #define STRING_CLASS_NAME "string"
                     23: 
                     24: // class
                     25: 
                     26: class MString : public Methoded {
1.53    ! parser     27: public: // VStateless_class
        !            28:        Value *create_new_value(Pool& pool) { return new(pool) VString(pool); }
        !            29: 
1.41      paf        30: public:
                     31:        MString(Pool& pool);
1.44      paf        32: public: // Methoded
1.53    ! parser     33:        bool used_directly() { return true; }
1.41      paf        34: };
1.1       paf        35: 
                     36: // methods
                     37: 
1.47      paf        38: static void _length(Request& r, const String& method_name, MethodParams *) {
1.1       paf        39:        Pool& pool=r.pool();
1.47      paf        40:        Value& result=*new(pool) VDouble(pool, r.self->get_string()->size());
                     41:        result.set_name(method_name);
                     42:        r.write_no_lang(result);
1.1       paf        43: }
                     44: 
1.47      paf        45: static void _int(Request& r, const String& method_name, MethodParams *) {
1.1       paf        46:        Pool& pool=r.pool();
1.48      parser     47:        Value& result=*new(pool) VInt(pool, r.self->as_int());
1.47      paf        48:        result.set_name(method_name);
                     49:        r.write_no_lang(result);
1.1       paf        50: }
                     51: 
1.47      paf        52: static void _double(Request& r, const String& method_name, MethodParams *) {
1.1       paf        53:        Pool& pool=r.pool();
1.47      paf        54:        Value& result=*new(pool) VDouble(pool, r.self->as_double());
                     55:        result.set_name(method_name);
                     56:        r.write_no_lang(result);
1.1       paf        57: }
                     58: 
1.38      paf        59: /*not static*/void _string_format(Request& r, const String& method_name, MethodParams *params) {
1.9       paf        60:        Pool& pool=r.pool();
                     61: 
1.38      paf        62:        Value& fmt=params->get_junction(0, "fmt must be code");
1.9       paf        63: 
1.24      paf        64:        Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
                     65:        char *buf=format(pool, r.self->as_double(), r.process(fmt).as_string().cstr());
1.9       paf        66:        
1.12      paf        67:        r.write_no_lang(String(pool, buf));
1.9       paf        68: }
1.11      paf        69: 
1.38      paf        70: static void _left(Request& r, const String&, MethodParams *params) {
1.15      paf        71:        Pool& pool=r.pool();
                     72: 
1.38      paf        73:        size_t n=(size_t)r.process(params->get(0)).as_double();
1.15      paf        74:        
                     75:        const String& string=*static_cast<VString *>(r.self)->get_string();
1.35      paf        76:        r.write_assign_lang(*new(pool) VString(string.mid(0, n)));
1.15      paf        77: }
                     78: 
1.38      paf        79: static void _right(Request& r, const String&, MethodParams *params) {
1.15      paf        80:        Pool& pool=r.pool();
                     81: 
1.38      paf        82:        size_t n=(size_t)r.process(params->get(0)).as_double();
1.15      paf        83:        
                     84:        const String& string=*static_cast<VString *>(r.self)->get_string();
1.35      paf        85:        r.write_assign_lang(*new(pool) VString(string.mid(string.size()-n, string.size())));
1.15      paf        86: }
                     87: 
1.38      paf        88: static void _mid(Request& r, const String&, MethodParams *params) {
1.15      paf        89:        Pool& pool=r.pool();
                     90: 
1.38      paf        91:        size_t p=(size_t)r.process(params->get(0)).as_double();
                     92:        size_t n=(size_t)r.process(params->get(1)).as_double();
1.15      paf        93:        
                     94:        const String& string=*static_cast<VString *>(r.self)->get_string();
1.35      paf        95:        r.write_assign_lang(*new(pool) VString(string.mid(p, p+n)));
1.15      paf        96: }
                     97: 
1.38      paf        98: static void _pos(Request& r, const String& method_name, MethodParams *params) {
1.16      paf        99:        Pool& pool=r.pool();
                    100: 
1.38      paf       101:        Value& substr=params->get_no_junction(0, "substr must not be code");
1.16      paf       102:        
                    103:        const String& string=*static_cast<VString *>(r.self)->get_string();
                    104:        r.write_assign_lang(*new(pool) VInt(pool, string.pos(substr.as_string())));
                    105: }
                    106: 
1.38      paf       107: static void split_list(Request& r, const String& method_name, MethodParams *params,
1.23      paf       108:                                           const String& string, 
                    109:                                           Array& result) {
1.38      paf       110:        Value& delim_value=params->get_no_junction(0, "delimiter must not be code");
1.23      paf       111: 
1.45      paf       112:        string.split(result, 0, delim_value.as_string());
1.19      paf       113: }
                    114: 
1.38      paf       115: static void _lsplit(Request& r, const String& method_name, MethodParams *params) {
1.19      paf       116:        Pool& pool=r.pool();
                    117:        const String& string=*static_cast<VString *>(r.self)->get_string();
                    118: 
1.21      paf       119:        Array& row=*new(pool) Array(pool);
                    120:        split_list(r, method_name, params, string, row);
1.19      paf       121: 
1.21      paf       122:        Table& table=*new(pool) Table(pool, &string, 
                    123:                0/*nameless*/, 1/*row preallocate(and only)*/);
                    124:        table+=&row;
1.19      paf       125: 
                    126:        r.write_no_lang(*new(pool) VTable(pool, &table));
                    127: }
                    128: 
1.38      paf       129: static void _rsplit(Request& r, const String& method_name, MethodParams *params) {
1.19      paf       130:        Pool& pool=r.pool();
                    131:        const String& string=*static_cast<VString *>(r.self)->get_string();
                    132: 
                    133:        Array list(pool);
                    134:        split_list(r, method_name, params, string, list);
                    135: 
1.21      paf       136:        Array& row=*new(pool) Array(pool);
                    137:        for(int i=list.size(); --i>=0; )
                    138:                row+=list.get(i);
                    139: 
                    140:        Table& table=*new(pool) Table(pool, &string, 
                    141:                0/*nameless*/, 1/*row preallocate(and only)*/);
                    142:        table+=&row;
1.17      paf       143: 
1.19      paf       144:        r.write_no_lang(*new(pool) VTable(pool, &table));
1.17      paf       145: }
                    146: 
1.33      paf       147: static void search_action(Table& table, Array *row, int, int, void *) {
1.28      paf       148:        if(row)
                    149:                table+=row;
1.27      paf       150: }
                    151: 
1.40      paf       152: /// used by string: _match / replace_action
1.27      paf       153: struct Replace_action_info {
1.30      paf       154:        Request *request;  const String *origin;
1.31      paf       155:        const String *src;  String *dest;
1.27      paf       156:        Value *replacement_code;
1.29      paf       157:        const String *post_match;
1.27      paf       158: };
1.33      paf       159: static void replace_action(Table& table, Array *row, int start, int finish, 
1.31      paf       160:                                                           void *info) {
1.27      paf       161:        Replace_action_info& ai=*static_cast<Replace_action_info *>(info);
1.31      paf       162:        if(row) { // begin&middle
                    163:                // piece from last match['start'] to beginning of this match['finish']
                    164:                if(start!=finish)
1.37      paf       165:                        *ai.dest << ai.src->mid(start, finish);//ai.dest->APPEND_CONST("-");
1.51      parser    166:                // store found parts in one-record VTable
1.32      paf       167:                if(table.size()) // middle
                    168:                        table.put(0, row);
                    169:                else // begin
1.30      paf       170:                        table+=row;
                    171:                { // execute 'replacement_code' in 'table' context
                    172:                        VTable& vtable=*new(table.pool()) VTable(table.pool(), &table);
                    173:                        vtable.set_name(*ai.origin);
                    174: 
                    175:                        Junction *junction=ai.replacement_code->get_junction();
1.52      parser    176:                        junction->rcontext=/*must be some way to get to 
                    177:                                                           outside world junction->root=*/&vtable;
1.30      paf       178:                        Value& replaced=ai.request->process(*ai.replacement_code, ai.origin, false);
                    179: 
1.34      paf       180:                        /*
1.31      paf       181:                        ai.dest->APPEND_CONST("(");
1.37      paf       182:                                *ai.dest << *(String *)row->get(1/*match* /);
1.31      paf       183:                        ai.dest->APPEND_CONST(")");
1.34      paf       184:                        */
1.37      paf       185:                        *ai.dest << replaced.as_string();
1.29      paf       186:                }
                    187:                ai.post_match=(String *)row->get(2/*post_match*/);
                    188:        } else // end
1.37      paf       189:                *ai.dest << *ai.post_match;
1.27      paf       190: }
                    191: 
1.50      parser    192: /// @todo use pcre:study somehow
1.38      paf       193: static void _match(Request& r, const String& method_name, MethodParams *params) {
1.24      paf       194:        Pool& pool=r.pool();
1.28      paf       195:        const String& src=*static_cast<VString *>(r.self)->get_string();
1.24      paf       196: 
1.38      paf       197:        Value& regexp=params->get_no_junction(0, "regexp must not be code");
                    198: 
                    199:        const String *options=
                    200:                params->size()>1?
                    201:                &params->get_no_junction(1, "options must not be code").as_string():0;
1.24      paf       202: 
1.27      paf       203:        Value *result;
1.24      paf       204:        Temp_lang temp_lang(r, String::UL_PASS_APPENDED);
1.25      paf       205:        Table *table;
1.27      paf       206:        if(params->size()<3) { // search
1.39      paf       207:                if(src.match(r.pcre_tables,
                    208:                        &method_name, 
1.32      paf       209:                        regexp.as_string(), options,
1.27      paf       210:                        &table,
1.33      paf       211:                        search_action, 0)) {
1.27      paf       212:                        // matched
                    213:                        if(table->columns()->size()==3 && // just matched[3=pre/match/post], no substrings
                    214:                                table->size()==1)  // just one row, not /g_lobal search
                    215:                                result=new(pool) VBool(pool, true);
                    216:                        else // table of pre/match/post+substrings
                    217:                                result=new(pool) VTable(pool, table);
                    218:                } else // not matched [not global]
                    219:                        result=new(pool) VBool(pool, false);
                    220:        } else { // replace
1.38      paf       221:                Value& replacement_code=params->get_junction(2, "replacement code must be code");
1.24      paf       222: 
1.28      paf       223:                String& dest=*new(pool) String(pool);
1.27      paf       224:                Replace_action_info replace_action_info={
1.30      paf       225:                        &r, &method_name,
1.31      paf       226:                        &src, &dest,
1.28      paf       227:                        &replacement_code,
1.29      paf       228:                        &src
1.27      paf       229:                };
1.39      paf       230:                src.match(r.pcre_tables,
                    231:                        &method_name, 
1.27      paf       232:                        r.process(regexp).as_string(), options,
                    233:                        &table,
1.33      paf       234:                        replace_action, &replace_action_info);
1.28      paf       235:                result=new(pool) VString(dest);
1.27      paf       236:        }
1.26      paf       237:        result->set_name(method_name);
1.34      paf       238:        r.write_assign_lang(*result);
1.24      paf       239: }
                    240: 
1.49      parser    241: static void change_case(Request& r, const String& method_name, MethodParams *params, 
                    242:                                                String::Change_case_kind kind) {
                    243:        Pool& pool=r.pool();
                    244:        const String& src=*static_cast<VString *>(r.self)->get_string();
                    245: 
                    246:        r.write_assign_lang(*new(pool) VString(src.change_case(pool, r.pcre_tables,
                    247:                kind)));
                    248: }
                    249: static void _upper(Request& r, const String& method_name, MethodParams *params) {
                    250:        change_case(r, method_name, params, String::CC_UPPER);
                    251: }
                    252: static void _lower(Request& r, const String& method_name, MethodParams *params) {
                    253:        change_case(r, method_name, params, String::CC_LOWER);
                    254: }
                    255: 
1.53    ! parser    256: String& sql_result_string(Request& r, const String& method_name, MethodParams *params) {
        !           257:        Pool& pool=r.pool();
        !           258: 
        !           259:        if(!r.connection)
        !           260:                PTHROW(0, 0,
        !           261:                        &method_name,
        !           262:                        "without connect");
        !           263: 
        !           264:        Value& statement=params->get_junction(0, "statement must be code");
        !           265: 
        !           266:        ulong offset=0;
        !           267:        if(params->size()>1) {
        !           268:                Value& offset_code=params->get_junction(1, "offset must be expression");
        !           269:                offset=(ulong)r.process(offset_code).as_double();
        !           270:        }
        !           271: 
        !           272:        Temp_lang temp_lang(r, String::UL_SQL);
        !           273:        const String& statement_string=r.process(statement).as_string();
        !           274:        const char *statement_cstr=
        !           275:                statement_string.cstr(String::UL_UNSPECIFIED, r.connection);
        !           276:        unsigned int sql_column_count; SQL_Driver::Cell *sql_columns;
        !           277:        unsigned long sql_row_count; SQL_Driver::Cell **sql_rows;
        !           278:        bool need_rethrow=false; Exception rethrow_me;
        !           279:        PTRY {
        !           280:                r.connection->query(
        !           281:                        statement_cstr, offset, 0,
        !           282:                        &sql_column_count, &sql_columns,
        !           283:                        &sql_row_count, &sql_rows);
        !           284:        }
        !           285:        PCATCH(e) { // query problem
        !           286:                rethrow_me=e;  need_rethrow=true;
        !           287:        }
        !           288:        PEND_CATCH
        !           289:        if(need_rethrow)
        !           290:                PTHROW(rethrow_me.type(), rethrow_me.code(),
        !           291:                        &statement_string, // setting more specific source [were url]
        !           292:                        rethrow_me.comment());
        !           293:        
        !           294:        if(sql_column_count!=1)
        !           295:                PTHROW(0, 0,
        !           296:                        &statement_string,
        !           297:                        "result must contain only one column");
        !           298: 
        !           299:        if(sql_row_count!=1)
        !           300:                PTHROW(0, 0,
        !           301:                        &statement_string,
        !           302:                        "result must contain only one row");
        !           303: 
        !           304:        String& result=*new(pool) String(pool);
        !           305:        SQL_Driver::Cell& cell=sql_rows[0][0];
        !           306:        result.APPEND_TAINTED(
        !           307:                (const char *)cell.ptr, cell.size,
        !           308:                statement_cstr, 0);
        !           309:        
        !           310:        return result;
        !           311: }
        !           312: 
        !           313: static void _sql(Request& r, const String& method_name, MethodParams *params) {
        !           314:        Pool& pool=r.pool();
        !           315: 
        !           316:        VString& result=*new(pool) VString(sql_result_string(r, method_name, params));
        !           317:        result.set_name(method_name);
        !           318:        r.write_assign_lang(result);
        !           319: }
        !           320: 
1.41      paf       321: // constructor
                    322: 
                    323: MString::MString(Pool& apool) : Methoded(apool) {
                    324:        set_name(*NEW String(pool(), STRING_CLASS_NAME));
                    325: 
1.9       paf       326: 
1.1       paf       327:        // ^string.length[]
1.41      paf       328:        add_native_method("length", Method::CT_DYNAMIC, _length, 0, 0);
1.6       paf       329:        
1.1       paf       330:        // ^string.int[]
1.41      paf       331:        add_native_method("int", Method::CT_DYNAMIC, _int, 0, 0);
1.6       paf       332:        
1.1       paf       333:        // ^string.double[]
1.41      paf       334:        add_native_method("double", Method::CT_DYNAMIC, _double, 0, 0);
1.9       paf       335: 
1.24      paf       336:        // ^string.format{format}
1.41      paf       337:        add_native_method("format", Method::CT_DYNAMIC, _string_format, 1, 1);
1.14      paf       338: 
1.15      paf       339:        // ^string.left(n)
1.41      paf       340:        add_native_method("left", Method::CT_DYNAMIC, _left, 1, 1);
1.15      paf       341:        // ^string.right(n)
1.41      paf       342:        add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1);
1.15      paf       343:        // ^string.mid(p;n)
1.41      paf       344:        add_native_method("mid", Method::CT_DYNAMIC, _mid, 2, 2);
1.16      paf       345: 
                    346:        // ^string.pos[substr]
1.41      paf       347:        add_native_method("pos", Method::CT_DYNAMIC, _pos, 1, 1);
1.17      paf       348: 
                    349:        // ^string.lsplit[delim]
1.41      paf       350:        add_native_method("lsplit", Method::CT_DYNAMIC, _lsplit, 1, 1);
1.19      paf       351:        // ^string.rsplit[delim]
1.41      paf       352:        add_native_method("rsplit", Method::CT_DYNAMIC, _rsplit, 1, 1);
1.24      paf       353: 
1.32      paf       354:        // ^string.match[regexp][options]
                    355:        // ^string.match[regexp][options]{replacement-code}
1.41      paf       356:        add_native_method("match", Method::CT_DYNAMIC, _match, 1, 3);
1.49      parser    357: 
                    358:        // ^string.toupper[]
                    359:        add_native_method("upper", Method::CT_DYNAMIC, _upper, 0, 0);
                    360:        // ^string.tolower[]
                    361:        add_native_method("lower", Method::CT_DYNAMIC, _lower, 0, 0);
1.53    ! parser    362: 
        !           363:        // ^string:sql[query]
        !           364:        // ^string:sql[query](offset)
        !           365:        add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);
1.2       paf       366: }      
1.1       paf       367: 
1.41      paf       368: // global variable
                    369: 
                    370: Methoded *string_class;
                    371: 
                    372: // creator
                    373: 
                    374: Methoded *MString_create(Pool& pool) {
                    375:        return string_class=new(pool) MString(pool);
                    376: }

E-mail: