--- parser3/src/classes/op.C 2003/03/20 08:11:12 1.127.2.22.2.5 +++ parser3/src/classes/op.C 2003/03/21 14:27:50 1.127.2.22.2.8 @@ -5,7 +5,7 @@ Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char* IDENT_OP_C="$Date: 2003/03/20 08:11:12 $"; +static const char* IDENT_OP_C="$Date: 2003/03/21 14:27:50 $"; #include "classes.h" #include "pa_vmethod_frame.h" @@ -63,9 +63,9 @@ class Untaint_lang_name2enum: public Has public: Untaint_lang_name2enum() { #define ULN(name, LANG) \ - put(String* (new String(name)), (value_type)String::UL_##LANG); + put(String* (new String(name)), (value_type)String::L_##LANG); ULN("as-is", AS_IS); - ULN("optimized-as-is", AS_IS|String::UL_OPTIMIZE_BIT); + ULN("optimized-as-is", AS_IS|String::L_OPTIMIZE_BIT); ULN("file-spec", FILE_SPEC); ULN("http-header", HTTP_HEADER); ULN("mail-header", MAIL_HEADER); @@ -74,9 +74,9 @@ public: ULN("sql", SQL); ULN("js", JS); ULN("xml", XML); - ULN("optimized-xml", XML|String::UL_OPTIMIZE_BIT); + ULN("optimized-xml", XML|String::L_OPTIMIZE_BIT); ULN("html", HTML); - ULN("optimized-html", HTML|String::UL_OPTIMIZE_BIT); + ULN("optimized-html", HTML|String::L_OPTIMIZE_BIT); #undef ULN } } untaint_lang_name2enum; @@ -84,7 +84,7 @@ public: // methods static void _if(Request& r, const String& /*method_name*/, MethodParams* params) { - ValuePtr condition_code=params->as_junction(0, "condition must be expression"); + Value* condition_code=params->as_junction(0, "condition must be expression"); bool condition=r.process_to_value(condition_code, /*0/*no name* /,*/ @@ -97,9 +97,9 @@ static void _if(Request& r, const String static void _untaint(Request& r, const String& method_name, MethodParams* params) { - Untaint_lang lang; + Language lang; if(params->count()==1) - lang=String::UL_AS_IS; // mark as simply 'tainted'. useful in html from sql + lang=String::L_AS_IS; // mark as simply 'tainted'. useful in html from sql else { const String& lang_name=params->as_string(0, "lang must be string"); lang=untaint_lang_name2enum.get(lang_name); @@ -110,7 +110,7 @@ static void _untaint(Request& r, const S } { - ValuePtr vbody=params->as_junction(params->count()-1, "body must be code"); + Value* vbody=params->as_junction(params->count()-1, "body must be code"); Temp_lang temp_lang(r, lang); // set temporarily specified ^untaint[language; r.write_pass_lang(r.process(vbody)); // process marking tainted with that lang @@ -119,9 +119,9 @@ static void _untaint(Request& r, const S static void _taint(Request& r, const String& /*method_name*/, MethodParams* params) { - Untaint_lang lang; + Language lang; if(params->count()==1) - lang=String::UL_TAINTED; // mark as simply 'tainted'. useful in table:set + lang=String::L_TAINTED; // mark as simply 'tainted'. useful in table:set else { const String& lang_name=params->as_string(0, "lang must be string"); lang=untaint_lang_name2enum.get(lang_name); @@ -132,11 +132,11 @@ static void _taint(Request& r, const Str } { - ValuePtr vbody=params->as_no_junction(params->count()-1, "body must not be code"); + Value* vbody=params->as_no_junction(params->count()-1, "body must not be code"); String result; result.append( - *vbody->as_string(&pool), // process marking tainted with that lang + *vbody->as_string(), // process marking tainted with that lang lang, true); // force result language to specified r.write_pass_lang(result); } @@ -144,12 +144,12 @@ static void _taint(Request& r, const Str static void _process(Request& r, const String& method_name, MethodParams* params) { const String* source; // must be declared here to prevent premature destruction - MethodPtr main_method; - ValuePtr target_self=params->count()>1? + Method* main_method; + Value* target_self=params->count()>1? params->as_no_junction(0, "target must not be code") - :ValuePtr(&r.get_method_frame()->caller()->self()); + :Value*(&r.get_method_frame()->caller()->self()); { - ValuePtr vjunction=params->as_junction(params->count()-1, "body must be code"); + Value* vjunction=params->as_junction(params->count()-1, "body must be code"); VStateless_class *target_class=target_self->get_last_derived_class(); if(!target_class) @@ -161,11 +161,11 @@ static void _process(Request& r, const S source=r.process_to_string(vjunction); // temporary remove language change - Temp_lang temp_lang(r, String::UL_PASS_APPENDED); + Temp_lang temp_lang(r, String::L_PASS_APPENDED); // temporary zero @main so to maybe-replace it in processed code - Temp_method temp_method_main(*target_class, main_method_name, MethodPtr(0)); + Temp_method temp_method_main(*target_class, main_method_name, Method*(0)); // temporary zero @auto so it wouldn't be auto-called in Request::use_buf - Temp_method temp_method_auto(*target_class, auto_method_name, MethodPtr(0)); + Temp_method temp_method_auto(*target_class, auto_method_name, Method*(0)); // calculate pseudo file name of processed chars // would be something like "/some/file(4) process" @@ -190,7 +190,7 @@ static void _process(Request& r, const S // process source code, append processed methods to 'self' class // maybe-define new @main r.use_buf(*target_class, - source->cstr(String::UL_UNSPECIFIED, r.connection(0)), + source->cstr(String::L_UNSPECIFIED, r.connection(0)), String* (new String(heap_place, place_size, true /*tainted*/)), heap_place); @@ -213,8 +213,8 @@ static void _rem(Request& r, const Strin static void _while(Request& r, const String& method_name, MethodParams* params) { - ValuePtr vcondition=params->as_junction(0, "condition must be expression"); - ValuePtr body=params->as_junction(1, "body must be code"); + Value* vcondition=params->as_junction(0, "condition must be expression"); + Value* body=params->as_junction(1, "body must be code"); // while... int endless_loop_count=0; @@ -236,16 +236,16 @@ static void _while(Request& r, const Str } static void _use(Request& r, const String& method_name, MethodParams* params) { - ValuePtr vfile=params->as_no_junction(0, "file name must not be code"); - r.use_file(*r.main_class, vfile->as_string(&pool)); + Value* vfile=params->as_no_junction(0, "file name must not be code"); + r.use_file(*r.main_class, vfile->as_string()); } static void _for(Request& r, const String& method_name, MethodParams* params) { const String& var_name=params->as_string(0, "var name must be string"); int from=params->as_int(1, "from must be int", r); int to=params->as_int(2, "to must be int", r); - ValuePtr body_code=params->as_junction(3, "body must be code"); - ValuePtr delim_maybe_code=params->count()>4?(*params)[4]:ValuePtr(0); + Value* body_code=params->as_junction(3, "body must be code"); + Value* delim_maybe_code=params->count()>4?(*params)[4]:0; if(to-from>=MAX_LOOPS) // too long loop? throw Exception("parser.runtime", @@ -260,7 +260,7 @@ static void _for(Request& r, const Strin StringOrValue sv_processed=r.process(body_code); const String& s_processed=sv_processed.get_string(); - if(delim_maybe_code && s_processed && s_processed->size()) { // delimiter set and we have body + if(delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body if(need_delim) // need delim & iteration produced string? r.write_pass_lang(r.process(delim_maybe_code)); need_delim=true; @@ -270,16 +270,16 @@ static void _for(Request& r, const Strin } static void _eval(Request& r, const String& method_name, MethodParams* params) { - ValuePtr expr=params->as_junction(0, "need expression"); + Value* expr=params->as_junction(0, "need expression"); // evaluate expresion - ValuePtr value_result=r.process_to_value(expr, + Value* value_result=r.process_to_value(expr, /*0/*no name YET* /,*/ true/*don't intercept string*/)->as_expr_result(); if(params->count()>1) { - ValuePtr fmt=params->as_no_junction(1, "fmt must not be code"); + Value* fmt=params->as_no_junction(1, "fmt must not be code"); String string; string.APPEND_CONST( - format(value_result->as_double(), fmt->as_string(&pool)->cstr())); + format(value_result->as_double(), fmt->as_string().cstr())); r.write_no_lang(string); } else r.write_no_lang(value_result); @@ -289,12 +289,12 @@ static void _connect(Request& r, const S #ifdef RESOURCES_DEBUG struct timeval mt[2]; #endif - ValuePtr url=params->as_no_junction(0, "url must not be code"); - ValuePtr body_code=params->as_junction(1, "body must be code"); + Value* url=params->as_no_junction(0, "url must not be code"); + Value* body_code=params->as_junction(1, "body must be code"); Table* protocol2driver_and_client=0; - if(ValuePtr sql=r.main_class->get_element(String* (new String(MAIN_SQL_NAME)), *r.main_class, false)) { - if(ValuePtr element=sql->get_element(String* (new String(MAIN_SQL_DRIVERS_NAME)), *sql, false)) { + if(Value* sql=r.main_class->get_element(String* (new String(MAIN_SQL_NAME)), *r.main_class, false)) { + if(Value* element=sql->get_element(String* (new String(MAIN_SQL_DRIVERS_NAME)), *sql, false)) { protocol2driver_and_client=element->get_table(); } } @@ -305,7 +305,7 @@ gettimeofday(&mt[0],NULL); #endif // connect SQL_ConnectionPtr connection=SQL_driver_manager.get_connection(pool, - url->as_string(&pool), method_name, protocol2driver_and_client); + url->as_string(), method_name, protocol2driver_and_client); #ifdef RESOURCES_DEBUG //measure:after connect @@ -331,25 +331,25 @@ r.sql_connect_time+=t[1]-t[0]; class Switch_data: public PA_Object { public: Request& r; - ValuePtr searching; - ValuePtr found; - ValuePtr _default; + Value* searching; + Value* found; + Value* _default; public: - Switch_data(Request& ar, ValuePtr asearching): + Switch_data(Request& ar, Value* asearching): r(ar), searching(asearching) {} }; DECLARE_OBJECT_PTR(Switch_data); #endif static void _switch(Request& r, const String& /*method_name*/, MethodParams* params) { Switch_dataPtr data(new Switch_data(r, r.process_to_value(params->get(0)))); - Temp_hash_value + Temp_hash_value switch_data_setter(r.classes_conf, switch_data_name, data); - ValuePtr cases_code=params->as_junction(1, "switch cases must be code"); + Value* cases_code=params->as_junction(1, "switch cases must be code"); // execution of found ^case[...]{code} must be in context of ^switch[...]{code} // because of stacked WWrapper used there as wcontext r.process(cases_code, true/*intercept_string*/); - if(ValuePtr selected_code=data->found? data->found: data->_default) { + if(Value* selected_code=data->found? data->found: data->_default) { // setting code context, would execute in ^switch[...]{>>context<<} //selected_code->get_junction()->change_context(cases_code.get_junction()); r.write_pass_lang(r.process(selected_code)); @@ -365,23 +365,23 @@ static void _case(Request& r, const Stri "without switch"); int count=params->count(); - ValuePtr code=params->as_junction(--count, "case result must be code"); + Value* code=params->as_junction(--count, "case result must be code"); // killing context for safety, would execute in ^switch[...]{>>context<<} // reason: context is stacked, and it would become invalid afterwards //code->get_junction()->change_context(0); for(int i=0; iget(i)); + Value* value=r.process_to_value(params->get(i)); - if(*value->as_string(&pool) == CASE_DEFAULT_VALUE) { + if(*value->as_string() == CASE_DEFAULT_VALUE) { data->_default=code; break; } bool matches; if(data->searching->is_string()) - matches=*data->searching->as_string(&pool) == *value->as_string(&pool); + matches=*data->searching->as_string() == *value->as_string(); else matches=data->searching->as_double() == value->as_double(); @@ -425,7 +425,7 @@ DECLARE_OBJECT_PTR(Cache_data); struct Locked_process_and_cache_put_action_info { Request *r; Cache_data *data; - ValuePtr body_code; const String& evaluated_body; + Value* body_code; const String& evaluated_body; }; #endif /* @todo maybe network order worth spending some effort? @@ -459,7 +459,7 @@ static void locked_process_and_cache_put info.data->expires=0; // flag it so that could be easily checked by caller } const String& locked_process_and_cache_put(Request& r, - ValuePtr body_code, + Value* body_code, Cache_data& data, const String& file_spec) { Locked_process_and_cache_put_action_info info; @@ -543,10 +543,10 @@ static void _cache(Request& r, const Str const String& file_spec=r.absolute(params->as_string(0, "filespec must be string")); Cache_dataPtr data(new Cache_data); - Temp_hash_value + Temp_hash_value cache_data_setter(r.classes_conf, cache_data_name, data); data->expires=as_expires(r, method_name, params, 1, now); - ValuePtr body_code=params->as_junction(2, "body must be code"); + Value* body_code=params->as_junction(2, "body must be code"); if(data->expires>now) { // valid 'expires' specified? try cached copy... // hence we don't hope to have unary create/lockEX @@ -602,39 +602,39 @@ static void _cache(Request& r, const Str } // also used in pa_request.C to pass param to @unhandled_exception -VHashPtr exception2vhashconst Exception& e) { - VHashPtr result(new VHash); +VHash* exception2vhashconst Exception& e) { + VHash* result(new VHash); HashStringValue& hash=result->hash(0); if(const char* type=e.type(true)) - hash.put(exception_type_part_name, ValuePtr(new VString(String* (new String(type))))); + hash.put(exception_type_part_name, Value*(new VString(String* (new String(type))))); if(const String& asource=e.problem_source()) { const String* source(new String); - source->append(*asource, String::UL_TAINTED, true/*forced*/); + source->append(*asource, String::L_TAINTED, true/*forced*/); - hash.put(exception_source_part_name, ValuePtr(new VString(source))); + hash.put(exception_source_part_name, Value*(new VString(source))); #ifndef NO_STRING_ORIGIN const String_fragment::Origin& origin=source->origin(); hash.put(String* (new String("file", 0, true)), - ValuePtr(new VString(String* (new String(origin.file))))); + Value*(new VString(String* (new String(origin.file))))); hash.put(String* (new String("lineno")), - ValuePtr(new VInt(1+origin.line))); + Value*(new VInt(1+origin.line))); #endif } if(const char* ecomment=e.comment(true)) { char *pcomment=pool.copy(ecomment); hash.put(exception_comment_part_name, - ValuePtr(new VString(String* (new String(pcomment, 0, true/*tainted*/))))); + Value*(new VString(String* (new String(pcomment, 0, true/*tainted*/))))); } hash.put(exception_handled_part_name, - ValuePtr(new VBool(false))); + Value*(new VBool(false))); return result; } static void _try_operator(Request& r, const String& method_name, MethodParams* params) { - ValuePtr body_code=params->as_junction(0, "body_code must be code"); - ValuePtr catch_code=params->as_junction(1, "catch_code must be code"); + Value* body_code=params->as_junction(0, "body_code must be code"); + Value* catch_code=params->as_junction(1, "catch_code must be code"); StringOrValue result; // taking snapshot of try-context @@ -645,15 +645,15 @@ static void _try_operator(Request& r, co Request_context_saver throw_context(r); // taking snapshot of throw-context [stack trace contains error] try_context.restore(); // restoring try-context to perform catch-code - VHashPtr vhash=exception2vhash(e); + VHash* vhash=exception2vhash(e); - JunctionPtr junction=catch_code->get_junction(); + Junction* junction=catch_code->get_junction(); Value* method_frame=junction->method_frame; - ValuePtr saved_exception_var_value=method_frame->get_element(exception_var_name, *method_frame, false); + Value* saved_exception_var_value=method_frame->get_element(exception_var_name, *method_frame, false); junction->method_frame->put_element(exception_var_name, vhash, false); result=r.process(catch_code); bool handled=false; - if(ValuePtr value= + if(Value* value= vhash->hash(0).get(exception_handled_part_name)) handled=value->as_bool(); junction->method_frame->put_element(exception_var_name, saved_exception_var_value, false); @@ -670,17 +670,17 @@ static void _try_operator(Request& r, co static void _throw_operator(Request& r, const String& method_name, MethodParams* params) { if(params->count()==1) { - ValuePtr param0=(*params)[0]; + Value* param0=(*params)[0]; if(HashStringValue *hash=param0->get_hash(method_name)) { const char* type=0; - if(ValuePtr value=hash->get(exception_type_part_name)) - type=value->as_string(&pool)->cstr(); + if(Value* value=hash->get(exception_type_part_name)) + type=value->as_string().cstr(); const String* source; - if(ValuePtr value=hash->get(exception_source_part_name)) - source=value->as_string(&pool); + if(Value* value=hash->get(exception_source_part_name)) + source=value->as_string(); const char* comment; - if(ValuePtr value=hash->get(exception_comment_part_name)) - comment=value->as_string(&pool)->cstr(); + if(Value* value=hash->get(exception_comment_part_name)) + comment=value->as_string().cstr(); throw Exception(type, source?source:method_name, @@ -772,7 +772,7 @@ VClassMAIN::VClassMAIN(): VClass() { // constructor & configurator -VStateless_classPtr VClassMAIN_create() { +VStateless_class* VClassMAIN_create() { - return VStateless_classPtr(new VClassMAIN); + return VStateless_class*(new VClassMAIN); }