--- parser3/src/classes/hashfile.C 2005/08/08 09:24:27 1.35 +++ parser3/src/classes/hashfile.C 2023/09/26 20:49:05 1.65 @@ -1,13 +1,10 @@ /** @file Parser: @b hashfile parser class. - Copyright (c) 2001-2004 ArtLebedev Group (http://www.artlebedev.com) - Author: Alexandr Petrosian (http://paf.design.ru) + Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com) + Authors: Konstantin Morshnev , Alexandr Petrosian */ - -static const char * const IDENT="$Id: hashfile.C,v 1.35 2005/08/08 09:24:27 paf Exp $"; - #include "classes.h" #include "pa_request.h" @@ -15,21 +12,20 @@ static const char * const IDENT="$Id: ha #include "pa_vhashfile.h" #include "pa_vhash.h" +volatile const char * IDENT_HASHFILE_C="$Id: hashfile.C,v 1.65 2023/09/26 20:49:05 moko Exp $"; + // class class MHashfile : public Methoded { public: // VStateless_class - Value *create_new_value(Pool& apool, HashStringValue&) { return new VHashfile(apool); } - + Value *create_new_value(Pool& apool) { return new VHashfile(apool); } public: MHashfile(); -public: // Methoded - bool used_directly() { return true; } }; // global variable -DECLARE_CLASS_VAR(hashfile, new MHashfile, 0); +DECLARE_CLASS_VAR(hashfile, new MHashfile); // defines for statics @@ -37,7 +33,7 @@ DECLARE_CLASS_VAR(hashfile, new MHashfil // methods -typedef Hash HashStringBool; +typedef HashString HashStringBool; static void _open(Request& r, MethodParams& params) { HashStringBool* file_list=static_cast(r.classes_conf.get(OPEN_DATA_NAME)); @@ -46,9 +42,9 @@ static void _open(Request& r, MethodPara r.classes_conf.put(OPEN_DATA_NAME, file_list); } - const String& file_spec=r.absolute(params.as_string(0, "filename must be string")); + const String& file_spec=r.full_disk_path(params.as_string(0, FILE_NAME_MUST_BE_STRING)); if(file_list->get(file_spec)) - throw Exception("parser.runtime", + throw Exception(PARSER_RUNTIME, 0, "this hashfile is already opened, use existing variable"); file_list->put(file_spec, true); @@ -62,7 +58,7 @@ static void _hash(Request& r, MethodPara // write out result VHash& result=*new VHash(*self.get_hash()); - r.write_no_lang(result); + r.write(result); } static void _delete(Request& r, MethodParams& params) { @@ -81,7 +77,7 @@ static void _delete(Request& r, MethodPa static void _clear(Request& r, MethodParams&) { VHashfile& self=GET_SELF(r, VHashfile); - self.clear(); + self.delete_files(); } #ifndef DOXYGEN @@ -93,58 +89,88 @@ struct Foreach_info { Value* delim_maybe_code; Value* var_context; - VString* vkey; - VString* vvalue; bool need_delim; }; #endif -static void one_foreach_cycle(const String::Body key, const String& value, void* ainfo) { +static bool one_foreach_cycle( + const String::Body key, + const String& value, + void* ainfo) { Foreach_info& info=*static_cast(ainfo); - info.vkey->set_string(*new String(key, String::L_TAINTED)); - info.vvalue->set_string(value); - info.var_context->put_element(*info.var_context, *info.key_var_name, info.vkey, false); - info.var_context->put_element(*info.var_context, *info.value_var_name, info.vvalue, false); + if(info.key_var_name){ + VString* vkey=new VString(*new String(key, String::L_TAINTED)); + info.r->put_element(*info.var_context, *info.key_var_name, vkey); + } + if(info.value_var_name){ + VString* vvalue=new VString(value); + info.r->put_element(*info.var_context, *info.value_var_name, vvalue); + } + + Value& sv_processed=info.r->process(*info.body_code); + TempSkip4Delimiter skip(*info.r); - StringOrValue sv_processed=info.r->process(*info.body_code); const String* s_processed=sv_processed.get_string(); - if(info.delim_maybe_code && s_processed && s_processed->length()) { // delimiter set and we have body + if(info.delim_maybe_code && s_processed && !s_processed->is_empty()) { // delimiter set and we have body if(info.need_delim) // need delim & iteration produced string? - info.r->write_pass_lang(info.r->process(*info.delim_maybe_code)); - info.need_delim=true; + info.r->write(info.r->process(*info.delim_maybe_code)); + else + info.need_delim=true; } - info.r->write_pass_lang(sv_processed); + + info.r->write(sv_processed); + + return skip.check_break(); } static void _foreach(Request& r, MethodParams& params) { - VHashfile& self=GET_SELF(r, VHashfile); + InCycle temp(r); - Foreach_info info; - - info.r=&r; - info.key_var_name=¶ms.as_string(0, "key-var name must be string"); - info.value_var_name=¶ms.as_string(1, "value-var name must be string"); - info.body_code=¶ms.as_junction(2, "body must be code"); - info.delim_maybe_code=params.count()>3?params.get(3):0; - - info.var_context=info.body_code->get_junction()->wcontext; - info.vkey=new VString; - info.vvalue=new VString; + const String& key_var_name=params.as_string(0, "key-var name must be string"); + const String& value_var_name=params.as_string(1, "value-var name must be string"); - info.need_delim=false; + Foreach_info info={ + &r, + key_var_name.is_empty()? 0 : &key_var_name, + value_var_name.is_empty()? 0 : &value_var_name, + ¶ms.as_junction(2, "body must be code"), + /*delimiter*/params.count()>3 ? ¶ms[3] : 0, + /*var_context*/r.get_method_frame()->caller(), + false + }; + VHashfile& self=GET_SELF(r, VHashfile); self.for_each(one_foreach_cycle, &info); } +static bool one_cleanup_cycle(const String::Body, const String&, void*) { + return false; +} +static void _cleanup(Request& r, MethodParams&) { + VHashfile& self=GET_SELF(r, VHashfile); + + self.for_each(one_cleanup_cycle, 0); +} + +static void _release(Request& r, MethodParams&) { + VHashfile& self=GET_SELF(r, VHashfile); + self.close(); +} + // constructor MHashfile::MHashfile(): Methoded("hashfile") { - // ^hashfile::open[db_home;filename] + // ^hashfile::open[filename] add_native_method("open", Method::CT_DYNAMIC, _open, 1, 1); - // ^hash[] + // ^hashfile.hash[] add_native_method("hash", Method::CT_DYNAMIC, _hash, 0, 0); // ^hashfile.delete[key] add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1); - // ^hashfile.clear[] + // ^hashfile.clear[] -- for backward compatibility. use .delete[] instead. add_native_method("clear", Method::CT_DYNAMIC, _clear, 0, 0); + // ^hashfile.release[] + add_native_method("release", Method::CT_DYNAMIC, _release, 0, 0); + // ^hashfile.cleanup[] + add_native_method("cleanup", Method::CT_DYNAMIC, _cleanup, 0, 0); + add_native_method("defecate", Method::CT_DYNAMIC, _cleanup, 0, 0); // ^hashfile.foreach[key;value]{code}[delim] add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+1); }