--- parser3/src/classes/op.C 2002/10/16 07:32:51 1.121 +++ parser3/src/classes/op.C 2003/02/17 12:13:43 1.127.2.12 @@ -1,13 +1,15 @@ /** @file Parser: parser @b operators. - Copyright (c) 2001, 2002 ArtLebedev Group (http://www.artlebedev.com) + Copyright (c) 2001-2003 ArtLebedev Group (http://www.artlebedev.com) Author: Alexandr Petrosian (http://paf.design.ru) */ -static const char* IDENT_OP_C="$Date: 2002/10/16 07:32:51 $"; +static const char* IDENT_OP_C="$Date: 2003/02/17 12:13:43 $"; #include "classes.h" +#include "pa_vmethod_frame.h" + #include "pa_common.h" #include "pa_request.h" #include "pa_vint.h" @@ -27,133 +29,178 @@ static const char* IDENT_OP_C="$Date: 20 class VClassMAIN: public VClass { public: - VClassMAIN(Pool& apool); + VClassMAIN(); }; +// defines for statics + +#define SWITCH_DATA_NAME "SWITCH-DATA" +#define CACHE_DATA_NAME "CACHE-DATA" +#define EXCEPTION_VAR_NAME "exception" +#define EXCEPTION_TYPE_PART_NAME "type" +#define EXCEPTION_SOURCE_PART_NAME "source" +#define EXCEPTION_COMMENT_PART_NAME "comment" +#define EXCEPTION_HANDLED_PART_NAME "handled" + +// statics + +//^switch ^case +static StringPtr switch_data_name(new String(SWITCH_DATA_NAME)); +//^cache +static StringPtr cache_data_name(new String(CACHE_DATA_NAME)); + +static StringPtr exception_var_name(new String(EXCEPTION_VAR_NAME)); +static StringPtr exception_type_part_name(new String(EXCEPTION_TYPE_PART_NAME)); +static StringPtr exception_source_part_name(new String(EXCEPTION_SOURCE_PART_NAME)); +static StringPtr exception_comment_part_name(new String(EXCEPTION_COMMENT_PART_NAME)); +static StringPtr exception_handled_part_name(new String(EXCEPTION_HANDLED_PART_NAME)); + + +// helpers + +class Untaint_lang_name2enum: public Hash { +public: + Untaint_lang_name2enum() { + #define ULN(name, LANG) \ + put(StringPtr(new String(name)), (value_type)String::UL_##LANG); + ULN("as-is", AS_IS); + ULN("optimized-as-is", AS_IS|String::UL_OPTIMIZE_BIT); + ULN("file-spec", FILE_SPEC); + ULN("http-header", HTTP_HEADER); + ULN("mail-header", MAIL_HEADER); + ULN("uri", URI); + ULN("table", TABLE); + ULN("sql", SQL); + ULN("js", JS); + ULN("xml", XML); + ULN("optimized-xml", XML|String::UL_OPTIMIZE_BIT); + ULN("html", HTML); + ULN("optimized-html", HTML|String::UL_OPTIMIZE_BIT); + #undef ULN + } +} untaint_lang_name2enum; + // methods -static void _if(Request& r, const String&, MethodParams *params) { - Value& condition_code=params->as_junction(0, "condition must be expression"); +static void _if(Request& r, StringPtr /*method_name*/, MethodParams& params) { + ValuePtr condition_code=params.as_junction(0, "condition must be expression"); bool condition=r.process_to_value(condition_code, /*0/*no name* /,*/ - false/*don't intercept string*/).as_bool(); + false/*don't intercept string*/)->as_bool(); if(condition) - r.write_pass_lang(r.process(params->as_junction(1, "'then' parameter must be code"))); - else if(params->size()>2) - r.write_pass_lang(r.process(params->as_junction(2, "'else' parameter must be code"))); + r.write_pass_lang(r.process(params.as_junction(1, "'then' parameter must be code"))); + else if(params.count()>2) + r.write_pass_lang(r.process(params.as_junction(2, "'else' parameter must be code"))); } -static void _untaint(Request& r, const String& method_name, MethodParams *params) { +static void _untaint(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); uchar lang; - if(params->size()==1) + if(params.count()==1) lang=String::UL_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_int(lang_name); + StringPtr lang_name=params.as_string(0, "lang must be string"); + lang=untaint_lang_name2enum.get(lang_name); if(!lang) throw Exception(0, - &lang_name, + lang_name, "invalid taint language"); } { - Value& vbody=params->as_junction(params->size()-1, "body must be code"); + ValuePtr 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 } } -static void _taint(Request& r, const String&, MethodParams *params) { +static void _taint(Request& r, StringPtr /*method_name*/, MethodParams& params) { Pool& pool=r.pool(); uchar lang; - if(params->size()==1) + if(params.count()==1) lang=String::UL_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_int(lang_name); + StringPtr lang_name=params.as_string(0, "lang must be string"); + lang=untaint_lang_name2enum.get(lang_name); if(!lang) throw Exception(0, - &lang_name, + lang_name, "invalid taint language"); } { - Value& vbody=params->as_no_junction(params->size()-1, "body must not be code"); + ValuePtr vbody=params.as_no_junction(params.count()-1, "body must not be code"); - String& result=*new(pool) String(pool); + String result; result.append( - vbody.as_string(), // process marking tainted with that lang + *vbody->as_string(&pool), // process marking tainted with that lang lang, true); // force result language to specified r.write_pass_lang(result); } } -static void _process(Request& r, const String& method_name, MethodParams *params) { +static void _process(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); const Method *main_method; - Value& target_self=params->size()>1? - params->as_no_junction(0, "target must not be code") - :r.get_method_frame()->caller()->self(); + ValuePtr target_self=params.count()>1? + params.as_no_junction(0, "target must not be code") + :ValuePtr(&r.get_method_frame()->caller()->self()); { - Value& vjunction=params->as_junction(params->size()-1, "body must be code"); + ValuePtr vjunction=params.as_junction(params.count()-1, "body must be code"); - VStateless_class *target_class=target_self.get_class(); + VStateless_class *target_class=target_self->get_last_derived_class(); if(!target_class) throw Exception("parser.runtime", - &method_name, + method_name, "no target class"); // evaluate source to process - const String& source=r.process_to_string(vjunction); + StringPtr source=r.process_to_string(vjunction); // temporary remove language change Temp_lang temp_lang(r, String::UL_PASS_APPENDED); // temporary zero @main so to maybe-replace it in processed code - Temp_method temp_method_main(*target_class, r.main_method_name, 0); + Temp_method temp_method_main(*target_class, main_method_name, MethodPtr(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, 0); + Temp_method temp_method_auto(*target_class, auto_method_name, MethodPtr(0)); // calculate pseudo file name of processed chars // would be something like "/some/file(4) process" char local_place[MAX_STRING]; #ifndef NO_STRING_ORIGIN - const Origin& source_origin=source.origin(); - const Origin& method_origin=method_name.origin(); + const String_fragment::Origin& source_origin=source->origin(); + const String_fragment::Origin& method_origin=method_name->origin(); size_t place_size; if(source_origin.file==method_origin.file) place_size=snprintf(local_place, MAX_STRING, "%s(%d) %s", // same file source_origin.file?source_origin.file:"unknown_file", 1+source_origin.line, - method_name.cstr())+1; + method_name->cstr())+1; else // different files ^process{external__file_text__or__sql} place_size=snprintf(local_place, MAX_STRING, "%s", source_origin.file?source_origin.file:"unknown_file")+1; #else - strncpy(local_place, method_name.cstr(), MAX_STRING-1); place[MAX_STRING-1]=0; + strncpy(local_place, method_name->cstr(), MAX_STRING-1); place[MAX_STRING-1]=0; size_t place_size=strlen(local_place)+1; #endif - char *heap_place=(char *)r.malloc(place_size); - memcpy(heap_place, local_place, place_size); + char *heap_place=pool.copy(local_place, place_size); // 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)), - *new(pool) String(pool, heap_place, place_size, true /*tainted*/), + source->cstr(String::UL_UNSPECIFIED, r.connection(StringPtr(0))), + StringPtr(new String(heap_place, place_size, true /*tainted*/)), heap_place); // main_method - main_method=target_class->get_method(r.main_method_name); + main_method=target_class->get_method(main_method_name); } // after restoring current-request-lang // maybe-execute @main[] if(main_method) { - // temporarily set request's self to target_self - Temp_request_self trs(r, target_self); // temporarily set method_frame's self to target_self Temp_method_frame_self tmfs(*r.get_method_frame(), target_self); // execute! @@ -161,27 +208,27 @@ static void _process(Request& r, const S } } -static void _rem(Request& r, const String&, MethodParams *params) { - params->as_junction(0, "body must be code"); +static void _rem(Request& r, StringPtr /*method_name*/, MethodParams& params) { + params.as_junction(0, "body must be code"); } -static void _while(Request& r, const String& method_name, MethodParams *params) { +static void _while(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Value& vcondition=params->as_junction(0, "condition must be expression"); - Value& body=params->as_junction(1, "body must be code"); + ValuePtr vcondition=params.as_junction(0, "condition must be expression"); + ValuePtr body=params.as_junction(1, "body must be code"); // while... int endless_loop_count=0; while(true) { if(++endless_loop_count>=MAX_LOOPS) // endless loop? throw Exception("parser.runtime", - &method_name, + method_name, "endless loop detected"); bool condition=r.process_to_value(vcondition, /*0/*no name* /,*/ - false/*don't intercept string*/).as_bool(); + false/*don't intercept string*/)->as_bool(); if(!condition) // ...condition is true break; @@ -190,69 +237,71 @@ static void _while(Request& r, const Str } } -static void _use(Request& r, const String& method_name, MethodParams *params) { - Value& vfile=params->as_no_junction(0, "file name must not be code"); - r.use_file(r.main_class, vfile.as_string()); +static void _use(Request& r, StringPtr method_name, MethodParams& params) { + Pool& pool=r.pool(); + ValuePtr vfile=params.as_no_junction(0, "file name must not be code"); + r.use_file(*r.main_class, vfile->as_string(&pool)); } -static void _for(Request& r, const String& method_name, MethodParams *params) { - Pool& pool=r.pool(); - 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); - Value& body_code=params->as_junction(3, "body must be code"); - Value *delim_maybe_code=params->size()>4?¶ms->get(4):0; +static void _for(Request& r, StringPtr method_name, MethodParams& params) { + Pool& pool=r.pool(); + StringPtr 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); if(to-from>=MAX_LOOPS) // too long loop? throw Exception("parser.runtime", - &method_name, + method_name, "endless loop detected"); bool need_delim=false; - VInt *vint=new(pool) VInt(pool, 0); + VIntPtr vint(new VInt(0)); r.get_method_frame()->caller()->put_element(var_name, vint, false); for(int i=from; i<=to; i++) { vint->set_int(i); StringOrValue sv_processed=r.process(body_code); - const String *s_processed=sv_processed.get_string(); + StringPtr s_processed=sv_processed.get_string(); if(delim_maybe_code && s_processed && s_processed->size()) { // delimiter set and we have body if(need_delim) // need delim & iteration produced string? - r.write_pass_lang(r.process(*delim_maybe_code)); + r.write_pass_lang(r.process(delim_maybe_code)); need_delim=true; } r.write_pass_lang(sv_processed); } } -static void _eval(Request& r, const String& method_name, MethodParams *params) { - Value& expr=params->as_junction(0, "need expression"); +static void _eval(Request& r, StringPtr method_name, MethodParams& params) { + ValuePtr expr=params.as_junction(0, "need expression"); // evaluate expresion - Value *value_result=r.process_to_value(expr, + ValuePtr value_result=r.process_to_value(expr, /*0/*no name YET* /,*/ - true/*don't intercept string*/).as_expr_result(); - if(params->size()>1) { - Value& fmt=params->as_no_junction(1, "fmt must not be code"); + true/*don't intercept string*/)->as_expr_result(); + if(params.count()>1) { + ValuePtr fmt=params.as_no_junction(1, "fmt must not be code"); Pool& pool=r.pool(); - String& string=*new(pool) String(pool); - string.APPEND_CONST(format(pool, value_result->as_double(), fmt.as_string().cstr())); + String string; + string.APPEND_CONST( + format(pool, value_result->as_double(), fmt->as_string(&pool)->cstr())); r.write_no_lang(string); } else - r.write_no_lang(*value_result); + r.write_no_lang(value_result); } -static void _connect(Request& r, const String& method_name, MethodParams *params) { +static void _connect(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); #ifdef RESOURCES_DEBUG struct timeval mt[2]; #endif - Value& url=params->as_no_junction(0, "url must not be code"); - Value& body_code=params->as_junction(1, "body must be code"); + ValuePtr url=params.as_no_junction(0, "url must not be code"); + ValuePtr body_code=params.as_junction(1, "body must be code"); - Table *protocol2driver_and_client=0; - if(Value *sql=r.main_class.get_element(*new(pool) String(pool, MAIN_SQL_NAME), &r.main_class, false)) { - if(Value *element=sql->get_element(*new(pool) String(pool, MAIN_SQL_DRIVERS_NAME), sql, false)) { + Table* protocol2driver_and_client=0; + if(ValuePtr sql=r.main_class->get_element(StringPtr(new String(MAIN_SQL_NAME)), *r.main_class, false)) { + if(ValuePtr element=sql->get_element(StringPtr(new String(MAIN_SQL_DRIVERS_NAME)), *sql, false)) { protocol2driver_and_client=element->get_table(); } } @@ -262,8 +311,8 @@ struct timeval mt[2]; gettimeofday(&mt[0],NULL); #endif // connect - SQL_Connection_ptr connection=SQL_driver_manager->get_connection( - url.as_string(), method_name, protocol2driver_and_client); + SQL_ConnectionPtr connection=SQL_driver_manager.get_connection(pool, + url->as_string(&pool), method_name, protocol2driver_and_client); #ifdef RESOURCES_DEBUG //measure:after connect @@ -281,67 +330,73 @@ r.sql_connect_time+=t[1]-t[0]; r.write_assign_lang(r.process(body_code)); } catch(...) { // process problem connection->mark_to_rollback(); - /*re*/throw; + rethrow; } } #ifndef DOXYGEN -struct Switch_data { - Request *r; - Value *searching; - Value *found; - Value *_default; +class Switch_data: public PA_Object { +public: + Request& r; + ValuePtr searching; + ValuePtr found; + ValuePtr _default; +public: + Switch_data(Request& ar, ValuePtr asearching): + r(ar), searching(asearching) {} }; +DECLARE_OBJECT_PTR(Switch_data); #endif -static void _switch(Request& r, const String&, MethodParams *params) { - Switch_data data={&r, &r.process_to_value(params->get(0))}; - Temp_hash_value switch_data_setter(r.classes_conf, *switch_data_name, &data); +static void _switch(Request& r, StringPtr /*method_name*/, MethodParams& params) { + Switch_dataPtr data(new Switch_data(r, r.process_to_value(params.get(0)))); + Temp_hash_value + switch_data_setter(r.classes_conf, switch_data_name, data); - Value& cases_code=params->as_junction(1, "switch cases must be code"); + ValuePtr 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(Value *selected_code=data.found ? data.found : data._default) { + if(ValuePtr 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)); + r.write_pass_lang(r.process(selected_code)); } } -static void _case(Request& r, const String& method_name, MethodParams *params) { +static void _case(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Switch_data *data=static_cast(r.classes_conf.get(*switch_data_name)); + Switch_data* data=static_cast(r.classes_conf.get(switch_data_name).get()); if(!data) throw Exception("parser.runtime", - &method_name, + method_name, "without switch"); - int count=params->size(); - Value *code=¶ms->as_junction(--count, "case result must be code"); + int count=params.count(); + ValuePtr 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)); + ValuePtr value=r.process_to_value(params.get(i)); - if(value.as_string() == CASE_DEFAULT_VALUE) { + if(*value->as_string(&pool) == CASE_DEFAULT_VALUE) { data->_default=code; break; } bool matches; if(data->searching->is_string()) - matches=data->searching->as_string() == value.as_string(); + matches=*data->searching->as_string(&pool) == *value->as_string(&pool); else - matches=data->searching->as_double() == value.as_double(); + matches=data->searching->as_double() == value->as_double(); if(matches) { if(data->found) throw Exception("parser.runtime", - &method_name, + method_name, "duplicate found"); data->found=code; @@ -354,7 +409,7 @@ static void _case(Request& r, const Stri // consts -const int DATA_STRING_SERIALIZED_VERSION=0x0002; +const int DATA_STRING_SERIALIZED_VERSION=0x0003; // helper types @@ -365,36 +420,44 @@ struct Data_string_serialized_prolog { }; #endif -void cache_delete(const String& file_spec) { +void cache_delete(StringPtr file_spec) { file_delete(file_spec, false/*fail_on_read_problem*/); } #ifndef DOXYGEN -struct Cache_data { +class Cache_data: public PA_Object { +public: time_t expires; }; +DECLARE_OBJECT_PTR(Cache_data); struct Locked_process_and_cache_put_action_info { Request *r; Cache_data *data; - Value *body_code; const String *evaluated_body; + ValuePtr body_code; StringPtr evaluated_body; }; #endif +/* @todo maybe network order worth spending some effort? + don't bothering myself with network byte order, + am not planning to be able to move resulting file across platforms +*/ static void locked_process_and_cache_put_action(int f, void *context) { Locked_process_and_cache_put_action_info& info= *static_cast(context); + + Pool& pool=info.r->pool(); // body->process - info.evaluated_body=&info.r->process_to_string(*info.body_code); + info.evaluated_body=info.r->process_to_string(info.body_code); // expiration time not spoiled by ^cache(0) or something? if(info.data->expires > time(0)) { // string -serialize> buffer - void *data; size_t data_size; - info.evaluated_body->serialize( + char *data; size_t data_size; + info.evaluated_body->serialize(pool, sizeof(Data_string_serialized_prolog), data, data_size); Data_string_serialized_prolog& prolog= - *static_cast(data); + *reinterpret_cast(data); prolog.version=DATA_STRING_SERIALIZED_VERSION; prolog.expires=info.data->expires; @@ -403,82 +466,79 @@ static void locked_process_and_cache_put } else // expired! info.data->expires=0; // flag it so that could be easily checked by caller } -const String *locked_process_and_cache_put(Request& r, - Value& body_code, +StringPtr locked_process_and_cache_put(Request& r, + ValuePtr body_code, Cache_data& data, - const String& file_spec) { - Locked_process_and_cache_put_action_info info={ - &r, - &data, - &body_code - }; + StringPtr file_spec) { + Locked_process_and_cache_put_action_info info; + info.r=&r; + info.data=&data; + info.body_code=body_code; - const String *result=file_write_action_under_lock( + StringPtr result=file_write_action_under_lock( file_spec, "cache_put", locked_process_and_cache_put_action, &info, false/*as_text*/, false/*do_append*/, false/*block*/, - false/*fail on lock problem*/) ? info.evaluated_body: 0; + false/*fail on lock problem*/) ? info.evaluated_body: StringPtr(0); time_t now=time(0); if(data.expires<=now) cache_delete(file_spec); return result; } -String *cache_get(Pool& pool, const String& file_spec, time_t now) { - void* data; size_t data_size; - if(file_read(pool, file_spec, - data, data_size, +StringPtr cache_get(Pool& pool, Charset& charset, StringPtr file_spec, time_t now) { + File_read_result file=file_read(pool, charset, file_spec, false/*as_text*/, - false/*fail_on_read_problem*/) - && data_size/* ignore reads which are empty due to + 0, //no params + false/*fail_on_read_problem*/); + if(file.success && file.size/* ignore reads which are empty due to non-unary open+lockEX conflict with lockSH */) { - + Data_string_serialized_prolog& prolog= - *static_cast(data); + *reinterpret_cast(file.data); - String *result=new(pool) String(pool); + StringPtr result(new String); if( - data_size>=sizeof(Data_string_serialized_prolog) + file.size>=sizeof(Data_string_serialized_prolog) && prolog.version==DATA_STRING_SERIALIZED_VERSION && prolog.expires > now && result->deserialize( - sizeof(Data_string_serialized_prolog), data, data_size, file_spec.cstr())) + sizeof(Data_string_serialized_prolog), file.data, file.size, file_spec->cstr(pool))) return result; } return 0; } -static time_t as_expires(Request& r, const String& method_name, MethodParams *params, +static time_t as_expires(Request& r, StringPtr method_name, MethodParams& params, int index, time_t now) { time_t result; - Value& vlifespan_or_expires=params->get(index); - if(Value *vdate=vlifespan_or_expires.as(VDATE_TYPE, false)) - result=static_cast(vdate)->get_time(); + if(Value* vdate=params[index]->as(VDATE_TYPE, false)) + result=static_cast(vdate)->get_time(); else - result=now+(time_t)params->as_double(index, "lifespan must be date or number", r); + result=now+(time_t)params.as_double(index, "lifespan must be date or number", r); return result; } -static const String as_file_spec(Request&r, MethodParams *params, int index) { - return r.absolute(params->as_string(index, "filespec must be string")); +static StringPtr as_file_spec(Request& r, MethodParams& params, int index) { + return r.absolute(params.as_string(index, "filespec must be string")); } -static void _cache(Request& r, const String& method_name, MethodParams *params) { +static void _cache(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); time_t now=time(0); // ^cache[filename] ^cache(seconds) ^cache[expires date] - if(params->size()==1) { - if(params->get(0).is_string()) { // filename? + if(params.count()==1) { + if(params[0]->is_string()) { // filename? cache_delete(as_file_spec(r, params, 0)); return; } // secods|expires date - Cache_data *data=static_cast(r.classes_conf.get(*cache_data_name)); + Cache_data* data=static_cast(r.classes_conf.get(cache_data_name).get()); if(!data) throw Exception("parser.runtime", - &method_name, + method_name, "expire-time reducing instruction without cache"); time_t expires=as_expires(r, method_name, params, 0, now); @@ -489,14 +549,15 @@ static void _cache(Request& r, const Str } // file_spec, expires, body code - const String &file_spec=r.absolute(params->as_string(0, "filespec must be string")); + StringPtr file_spec=r.absolute(params.as_string(0, "filespec must be string")); - Cache_data data; - Temp_hash_value cache_data_setter(r.classes_conf, *cache_data_name, &data); - data.expires=as_expires(r, method_name, params, 1, now); - Value& body_code=params->as_junction(2, "body must be code"); + Cache_dataPtr data(new Cache_data); + 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"); - if(data.expires>now) { // valid 'expires' specified? try cached copy... + if(data->expires>now) { // valid 'expires' specified? try cached copy... // hence we don't hope to have unary create/lockEX // we need some plan to live in a life like that, so... // worst races plan: @@ -514,7 +575,7 @@ static void _cache(Request& r, const Str // |lockSH succeeds; ... for(int retry=0; retry<2; retry++) { - if(String *cached_body=cache_get(pool, file_spec, now)) { // have cached copy? + if(StringPtr cached_body=cache_get(pool, r.charsets.source(), file_spec, now)) { // have cached copy? // write it out r.write_assign_lang(*cached_body); // happy with it @@ -522,8 +583,8 @@ static void _cache(Request& r, const Str } // non-blocked lock; process; cache it - if(const String*processed_body= - locked_process_and_cache_put(r, body_code, data, file_spec)) { + if(StringPtr processed_body= + locked_process_and_cache_put(r, body_code, *data, file_spec)) { // write it out r.write_assign_lang(*processed_body); // happy with it @@ -534,15 +595,15 @@ static void _cache(Request& r, const Str } } throw Exception(0, - &file_spec, + file_spec, "locking problem"); } else { // instructed not to cache; forget cached copy cache_delete(file_spec); // process - const String& processed_body=r.process_to_string(body_code); + StringPtr processed_body=r.process_to_string(body_code); // write it out - r.write_assign_lang(processed_body); + r.write_assign_lang(*processed_body); // happy with it return; } @@ -550,104 +611,108 @@ static void _cache(Request& r, const Str } // also used in pa_request.C to pass param to @unhandled_exception -VHash& exception2vhash(Pool& pool, const Exception& e) { - VHash& result=*new(pool) VHash(pool); - Hash& hash=result.hash(0); - if(const char *type=e.type(true)) - hash.put(*exception_type_part_name, new(pool) VString(*new(pool) String(pool, type))); - if(const String *asource=e.problem_source()) { - String& source=*new(pool) String(pool); - source.append(*asource, String::UL_TAINTED, true/*forced*/); +VHashPtr exception2vhash(Pool& pool, const Exception& e) { + VHashPtr result(new VHash); + HashStringValue& hash=result->hash(Exception::undefined_source); + if(const char* type=e.type(true)) + hash.put(exception_type_part_name, ValuePtr(new VString(StringPtr(new String(type))))); + if(StringPtr asource=e.problem_source()) { + StringPtr source(new String); + source->append(*asource, String::UL_TAINTED, true/*forced*/); - hash.put(*exception_source_part_name, new(pool) VString(source)); + hash.put(exception_source_part_name, ValuePtr(new VString(source))); #ifndef NO_STRING_ORIGIN - const Origin& origin=source.origin(); - hash.put(*new(pool) String(pool, "file", 0, true), - new(pool) VString(*new(pool) String(pool, origin.file))); - hash.put(*new(pool) String(pool, "lineno"), - new(pool) VInt(pool, 1+origin.line)); + const String_fragment::Origin& origin=source->origin(); + hash.put(StringPtr(new String("file", 0, true)), + ValuePtr(new VString(StringPtr(new String(origin.file))))); + hash.put(StringPtr(new String("lineno")), + ValuePtr(new VInt(1+origin.line))); #endif } - if(const char *ecomment=e.comment(true)) { - int comment_size=strlen(ecomment); - char *pcomment=(char *)pool.malloc(comment_size); - memcpy(pcomment, ecomment, comment_size); - hash.put(*exception_comment_part_name, - new(pool) VString(*new(pool) String(pool, pcomment, comment_size, true/*tainted*/))); + if(const char* ecomment=e.comment(true)) { + char *pcomment=pool.copy(ecomment); + hash.put(exception_comment_part_name, + ValuePtr(new VString(StringPtr(new String(pcomment, 0, true/*tainted*/))))); } - hash.put(*exception_handled_part_name, - new(pool) VBool(pool, false)); + hash.put(exception_handled_part_name, + ValuePtr(new VBool(false))); return result; } -static void _try_operator(Request& r, const String& method_name, MethodParams *params) { +static void _try_operator(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - Value& body_code=params->as_junction(0, "body_code must be code"); - Value& catch_code=params->as_junction(1, "catch_code must be code"); + ValuePtr body_code=params.as_junction(0, "body_code must be code"); + ValuePtr catch_code=params.as_junction(1, "catch_code must be code"); StringOrValue result; + // taking snapshot of try-context + Request_context_saver try_context(r); try { - Request_context_saver context_saved(r); // taking snapshot of request processing status, restoring it at } result=r.process(body_code); - context_saved.restore(); // manually restoring context } catch(const Exception& e) { - VHash& vhash=exception2vhash(pool, e); + 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 - Junction *junction=catch_code.get_junction(); - Value *method_frame=junction->method_frame; - 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); + VHashPtr vhash=exception2vhash(pool, e); + + JunctionPtr 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); + junction->method_frame->put_element(exception_var_name, vhash, false); result=r.process(catch_code); bool handled=false; - if(Value *value=static_cast(vhash.hash(0).get(*exception_handled_part_name))) + if(ValuePtr value= + vhash->hash(Exception::undefined_source).get(exception_handled_part_name)) handled=value->as_bool(); - junction->method_frame->put_element(*exception_var_name, saved_exception_var_value, false); + junction->method_frame->put_element(exception_var_name, saved_exception_var_value, false); - if(!handled) + if(!handled) { + throw_context.restore(); // restoring throw-context [exception were not handled] throw(e); // rethrow + } } - // write it out + // write out result r.write_pass_lang(result); } -static void _throw_operator(Request& r, const String& method_name, MethodParams *params) { +static void _throw_operator(Request& r, StringPtr method_name, MethodParams& params) { Pool& pool=r.pool(); - if(params->size()==1) { - Value& param0=params->get(0); - if(Hash *hash=param0.get_hash(&method_name)) { - const char *type=0; - if(Value *value=static_cast(hash->get(*exception_type_part_name))) - type=value->as_string().cstr(); - const String *source=0; - if(Value *value=static_cast(hash->get(*exception_source_part_name))) - source=&value->as_string(); - const char *comment=0; - if(Value *value= - static_cast(hash->get(*exception_comment_part_name))) - comment=value->as_string().cstr(); + if(params.count()==1) { + ValuePtr 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(); + StringPtr source(0); + if(ValuePtr value=hash->get(exception_source_part_name)) + source=value->as_string(&pool); + CharPtr comment(0); + if(ValuePtr value=hash->get(exception_comment_part_name)) + comment=value->as_string(&pool)->cstr(); throw Exception(type, - source?source:&method_name, + source?source:method_name, comment); } else throw Exception("parser.runtime", - &method_name, + method_name, "one-param version has hash param"); } else { - const char *type=params->as_string(0, "type must be string").cstr(); - const String& source=params->as_string(1, "source must be string"); - const char *comment=params->size()>2?params->as_string(2, "comment must be string").cstr():0; - throw Exception(type, &source, "%s", comment?comment:""); + const char* type=params.as_string(0, "type must be string")->cstr(pool); + StringPtr source=params.as_string(1, "source must be string"); + CharPtr comment=params.count()>2? params.as_string(2, "comment must be string")->cstr() + :CharPtr(0); + throw Exception(type, source, "%s", comment?comment:""); } } // constructor -VClassMAIN::VClassMAIN(Pool& apool): VClass(apool) { - set_name(*NEW String(pool(), MAIN_CLASS_NAME)); +VClassMAIN::VClassMAIN(): VClass() { + set_name(StringPtr(new String(MAIN_CLASS_NAME))); // ^if(condition){code-when-true} // ^if(condition){code-when-true}{code-when-false} @@ -706,6 +771,7 @@ VClassMAIN::VClassMAIN(Pool& apool): VCl // constructor & configurator -VClass& VClassMAIN_create(Pool& pool) { - return *new(pool) VClassMAIN(pool); +VStateless_classPtr VClassMAIN_create() { + + return VStateless_classPtr(new VClassMAIN); }