--- parser3/src/classes/hash.C 2016/10/26 15:44:49 1.136 +++ parser3/src/classes/hash.C 2024/10/27 17:50:59 1.166 @@ -1,8 +1,8 @@ /** @file Parser: @b hash parser class. - Copyright (c) 2001-2015 Art. Lebedev Studio (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 */ #include "classes.h" @@ -11,13 +11,14 @@ #include "pa_request.h" #include "pa_charsets.h" #include "pa_vhash.h" +#include "pa_varray.h" #include "pa_vvoid.h" #include "pa_sql_connection.h" #include "pa_vtable.h" #include "pa_vbool.h" #include "pa_vmethod_frame.h" -volatile const char * IDENT_HASH_C="$Id: hash.C,v 1.136 2016/10/26 15:44:49 moko Exp $"; +volatile const char * IDENT_HASH_C="$Id: hash.C,v 1.166 2024/10/27 17:50:59 moko Exp $"; // class @@ -37,67 +38,65 @@ DECLARE_CLASS_VAR(hash, new MHash); #ifndef DOXYGEN class Hash_sql_event_handlers: public SQL_Driver_query_event_handlers { - const String& statement_string; const char* statement_cstr; bool distinct; - HashStringValue& rows_hash; + HashStringValue& result; Value* row_value; int column_index; - ArrayString& columns; + ArrayString* columns; bool one_bool_column; - static VBool only_one_column_value; Table2hash_value_type value_type; int columns_count; public: Table* empty; public: - Hash_sql_event_handlers( - const String& astatement_string, - const char* astatement_cstr, - bool adistinct, - HashStringValue& arows_hash, - Table2hash_value_type avalue_type) - : - statement_string(astatement_string), - statement_cstr(astatement_cstr), + Hash_sql_event_handlers(bool adistinct, HashStringValue& aresult, Table2hash_value_type avalue_type): distinct(adistinct), - rows_hash(arows_hash), - value_type(avalue_type), + result(aresult), row_value(0), column_index(0), + columns(new ArrayString), one_bool_column(false), - columns(*new ArrayString), + value_type(avalue_type), empty(0) { } bool add_column(SQL_Error& error, const char* str, size_t ) { try { - columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */); + if(columns_count){ + // another query in multi_statements mode + columns=new ArrayString; + columns_count=0; + } + *columns+=new String(str, String::L_TAINTED /* no length as 0x00 can be inside */); return false; } catch(...) { - error=SQL_Error("exception occured in Hash_sql_event_handlers::add_column"); + error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column"); return true; } } bool before_rows(SQL_Error& error) { - if(columns.count()<1) { - error=SQL_Error(PARSER_RUNTIME, "no columns"); + columns_count=columns->count(); + if(columns_count<1) { + error=SQL_Error("no columns"); return true; } - switch(value_type){ - case C_STRING: { - if(columns.count()>2){ - error=SQL_Error(PARSER_RUNTIME, "only 2 columns allowed for $.type[string]."); - return true; + if(columns_count==1) { + one_bool_column=true; + } else { + switch(value_type){ + case C_STRING: { + if(columns_count>2){ + error=SQL_Error("only 2 columns allowed for $.type[string]"); + return true; + } + break; + } + case C_TABLE: { + // create empty table which we'll copy later + empty=new Table(columns); + break; } - } - case C_TABLE: { - // create empty table which we'll copy later - empty=new Table(&columns); - columns_count=columns.count(); - } - case C_HASH: { - one_bool_column=columns.count()==1; } } return false; @@ -110,53 +109,56 @@ public: bool add_row_cell(SQL_Error& error, const char *str, size_t ) { try { - const String& cell=str?*new String(str, String::L_TAINTED /* no length as 0x00 can be inside */):String::Empty; + const String& cell=str ? *new String(str, String::L_TAINTED /* no length as 0x00 can be inside */) : String::Empty; + + if(column_index==columns_count){ + // should never happen, buggy driver case + error=SQL_Error("columns index exceed the columns count"); + return true; + } bool duplicate=false; if(one_bool_column) { - duplicate=rows_hash.put_dont_replace(cell, &only_one_column_value); // put. existed? + duplicate=result.put_dont_replace(cell, &VBool::get(true)); // put. existed? } else if(column_index==0) { switch(value_type){ case C_HASH: { VHash* row_vhash=new VHash; row_value=row_vhash; - duplicate=rows_hash.put_dont_replace(cell, row_vhash); // put. existed? + duplicate=result.put_dont_replace(cell, row_vhash); // put. existed? break; } case C_STRING: { VString* row_vstring=new VString(); row_value=row_vstring; - duplicate=rows_hash.put_dont_replace(cell, row_vstring); // put. existed? + duplicate=result.put_dont_replace(cell, row_vstring); // put. existed? break; } case C_TABLE: { - VTable* vtable=(VTable*)rows_hash.get(cell); - Table* table; + VTable* vtable=(VTable*)result.get(cell); if(vtable) { // table with this key exist? if(!distinct) { duplicate=true; break; } - table=vtable->get_table(); } else { // no? creating table of same structure as source Table::Action_options table_options(0, 0); - table=new Table(*empty, table_options/*no rows, just structure*/); - vtable=new VTable(table); - rows_hash.put(cell, vtable); // put + vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/)); + result.put(cell, vtable); // put } ArrayString* row=new ArrayString(columns_count); row_value=(Value*)row; *row+=&cell; - *table+=row; + *vtable->get_table()+=row; break; } } } else { switch(value_type) { case C_HASH: { - row_value->get_hash()->put(*columns[column_index], new VString(cell)); + row_value->get_hash()->put(*columns->get(column_index), new VString(cell)); break; } case C_STRING: { @@ -173,20 +175,19 @@ public: } if(duplicate & !distinct) { - error=SQL_Error(PARSER_RUNTIME, "duplicate key"); + error=SQL_Error("duplicate key"); return true; } column_index++; return false; } catch(...) { - error=SQL_Error("exception occured in Hash_sql_event_handlers::add_row_cell"); + error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell"); return true; } } }; -VBool Hash_sql_event_handlers::only_one_column_value(true); #endif @@ -197,7 +198,13 @@ static void _create_or_add(Request& r, M HashStringValue* self_hash=&(self.hash()); HashStringValue* src_hash; - if(VHashBase* src=static_cast(vsrc.as(VHASH_TYPE))) { + if(VArray* src=dynamic_cast(&vsrc)) { + for(ArrayValue::Iterator i(src->array()); i; i.next()){ + if(i.value()) + self_hash->put(i.key(), i.value()); + } + return; + } else if(VHashBase* src=dynamic_cast(&vsrc)) { src_hash=&(src->hash()); if(src_hash==self_hash) // same: doing nothing @@ -206,11 +213,13 @@ static void _create_or_add(Request& r, M if(Value* vdefault=src->get_default()) self.set_default(vdefault); } else { + // allows $h[^hash::create[non-blank string]], thus as_hash("param") is more correct, but is not backward compatible src_hash=vsrc.get_hash(); } if(src_hash) - src_hash->for_each(copy_all_overwrite_to, self_hash); + for(HashStringValue::Iterator i(*src_hash); i; i.next()) + self_hash->put(i.key(), i.value()); } } @@ -221,7 +230,8 @@ static void _sub(Request& r, MethodParam self->clear(); return; } - src->for_each(remove_key_from, self); + for(HashStringValue::Iterator i(*src); i; i.next()) + self->remove(i.key()); } } @@ -236,7 +246,7 @@ static void _union(Request& r, MethodPar src->for_each(copy_all_dontoverwrite_to, result.get_hash()); // return result - r.write_no_lang(result); + r.write(result); } #ifndef DOXYGEN @@ -245,20 +255,47 @@ struct Copy_intersection_to_info { HashStringValue* dest; }; #endif -static void copy_intersection_to(HashStringValue::key_type key, HashStringValue::value_type value, Copy_intersection_to_info *info) { + +static void copy_intersection_by_arg(HashStringValue::key_type key, HashStringValue::value_type, Copy_intersection_to_info *info) { + if(HashStringValue::value_type value=info->b->get(key)) + info->dest->put_dont_replace(key, value); +} + +static void copy_intersection_by_self(HashStringValue::key_type key, HashStringValue::value_type value, Copy_intersection_to_info *info) { if(info->b->get(key)) info->dest->put_dont_replace(key, value); } + static void _intersection(Request& r, MethodParams& params) { Value& result=*new VHash; - // dest += b + + bool order_by_arg=false; + if(params.count()>1) + if(HashStringValue* options=params.as_hash(1, "options")) { + int valid_options=0; + if(Value* vorder=options->get("order")) { + const String &sorder=r.process(*vorder).as_string(); + if(sorder == "arg") + order_by_arg=true; + else if(sorder != "self") + throw Exception(PARSER_RUNTIME, &sorder, "'order' must be 'self' or 'arg'"); + valid_options++; + } + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); + } + if(HashStringValue* b=params.as_hash(0, "param")) { - Copy_intersection_to_info info={b, result.get_hash()}; - GET_SELF(r, VHashBase).hash().for_each(copy_intersection_to, &info); + if(order_by_arg){ + Copy_intersection_to_info info={&GET_SELF(r, VHashBase).hash(), result.get_hash()}; + b->for_each(copy_intersection_by_arg, &info); + } else { + Copy_intersection_to_info info={b, result.get_hash()}; + GET_SELF(r, VHashBase).hash().for_each(copy_intersection_by_self, &info); + } } - // return result - r.write_no_lang(result); + r.write(result); } static bool intersects( HashStringValue::key_type key, HashStringValue::value_type /*value*/, HashStringValue* b) { @@ -271,23 +308,17 @@ static void _intersects(Request& r, Meth if(HashStringValue* b=params.as_hash(0, "param")) { HashStringValue* self=&(GET_SELF(r, VHashBase).hash()); if(b==self) { - r.write_no_lang(VBool::get(true)); + r.write(VBool::get(true)); return; } result=self->first_that(intersects, b)!=0; } // return result - r.write_no_lang(VBool::get(result)); + r.write(VBool::get(result)); } -extern String sql_bind_name; -extern String sql_limit_name; -extern String sql_offset_name; -extern String sql_default_name; -extern String sql_distinct_name; -extern String sql_value_type_name; extern Table2hash_value_type get_value_type(Value& vvalue_type); extern int marshal_binds(HashStringValue& hash, SQL_Driver::Placeholder*& placeholders); extern void unmarshal_bind_updates(HashStringValue& hash, int placeholder_count, SQL_Driver::Placeholder* placeholders); @@ -303,25 +334,25 @@ static void _sql(Request& r, MethodParam if(params.count()>1) if(HashStringValue* options=params.as_hash(1, "sql options")) { int valid_options=0; - if(Value* vbind=options->get(sql_bind_name)) { - valid_options++; - bind=vbind->get_hash(); - } - if(Value* vlimit=options->get(sql_limit_name)) { - valid_options++; - limit=(ulong)r.process(*vlimit).as_double(); - } - if(Value* voffset=options->get(sql_offset_name)) { - valid_options++; - offset=(ulong)r.process(*voffset).as_double(); - } - if(Value* vdistinct=options->get(sql_distinct_name)) { - valid_options++; - distinct=r.process(*vdistinct).as_bool(); - } - if(Value* vvalue_type=options->get(sql_value_type_name)) { - valid_options++; - value_type=get_value_type(r.process(*vvalue_type)); + for(HashStringValue::Iterator i(*options); i; i.next() ){ + String::Body key=i.key(); + Value* value=i.value(); + if(key == sql_bind_name) { + bind=value->get_hash(); + valid_options++; + } else if(key == sql_limit_name) { + limit=(ulong)r.process(*value).as_double(); + valid_options++; + } else if(key == sql_offset_name) { + offset=(ulong)r.process(*value).as_double(); + valid_options++; + } else if (key == sql_distinct_name) { + distinct=r.process(*value).as_bool(); + valid_options++; + } else if (key == sql_value_type_name) { + value_type=get_value_type(r.process(*value)); + valid_options++; + } } if(valid_options!=options->count()) throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); @@ -336,19 +367,10 @@ static void _sql(Request& r, MethodParam const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection()); HashStringValue& hash=GET_SELF(r, VHashBase).hash(); - hash.clear(); - Hash_sql_event_handlers handlers( - statement_string, statement_cstr, - distinct, - hash, - value_type); - - r.connection()->query( - statement_cstr, - placeholders_count, placeholders, - offset, limit, - handlers, - statement_string); + hash.clear(); + Hash_sql_event_handlers handlers(distinct, hash, value_type); + + r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string); if(bind) unmarshal_bind_updates(*bind, placeholders_count, placeholders); @@ -372,11 +394,11 @@ static void _keys(Request& r, MethodPara GET_SELF(r, VHashBase).hash().for_each(keys_collector, table); - r.write_no_lang(*new VTable(table)); + r.write(*new VTable(table)); } static void _count(Request& r, MethodParams&) { - r.write_no_lang(*new VInt(GET_SELF(r, VHashBase).hash().count())); + r.write(*new VInt(GET_SELF(r, VHashBase).hash().count())); } static void _delete(Request& r, MethodParams& params) { @@ -390,7 +412,7 @@ static void _contains(Request& r, Method VHashBase& self=GET_SELF(r, VHashBase); const String& key_name=params.as_string(0, "key must be string"); bool result=SYMBOLS_EQ(key_name,_DEFAULT_SYMBOL) ? (self.get_default() != 0) : self.hash().contains(key_name); - r.write_no_lang(VBool::get(result)); + r.write(VBool::get(result)); } static void _foreach(Request& r, MethodParams& params) { @@ -419,19 +441,19 @@ static void _foreach(Request& r, MethodP r.put_element(caller, *value_var_name, i.value()); Value& sv_processed=r.process(*body_code); - Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING); + TempSkip4Delimiter skip(r); const String* s_processed=sv_processed.get_string(); if(s_processed && !s_processed->is_empty()) { // we have body if(need_delim) // need delim & iteration produced string? - r.write_pass_lang(r.process(*delim_maybe_code)); + r.write(r.process(*delim_maybe_code)); else need_delim=true; } - r.write_pass_lang(sv_processed); + r.write(sv_processed); - if(lskip==Request::SKIP_BREAK) + if(skip.check_break()) break; } } else { @@ -445,9 +467,8 @@ static void _foreach(Request& r, MethodP r.put_element(caller, *value_var_name, i.value()); r.process_write(*body_code); - Request::Skip lskip=r.get_skip(); r.set_skip(Request::SKIP_NOTHING); - if(lskip==Request::SKIP_BREAK) + if(r.check_skip_break()) break; } } @@ -459,14 +480,14 @@ enum AtResultType { AtResultTypeHash = 2 }; -inline Value& SingleElementHash(String::Body akey, Value* avalue) { +static Value& SingleElementHash(String::Body akey, Value* avalue) { Value& result=*new VHash; result.put_element(*new String(akey, String::L_TAINTED), avalue); return result; } #ifndef DOXYGEN -struct Hash_seq_item { +struct Hash_seq_item : public PA_Allocated { HashStringValue::Pair *hash_pair; union { const char *c_str; @@ -495,9 +516,7 @@ static void _sort(Request& r, MethodPara 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"); Value& key_maker=params.as_junction(2, "key-maker must be code"); - bool reverse=params.count()>3/*..[desc|asc|]*/? - reverse=params.as_no_junction(3, "order must not be code").as_string()=="desc": - false; // default=asc + bool reverse=params.count()>3 /*..[desc|asc|]*/ && params.as_no_junction(3, "order must not be code").as_string()=="desc"; // default=asc const String* key_var=key_var_name.is_empty()? 0 : &key_var_name; const String* value_var=value_var_name.is_empty()? 0 : &value_var_name; @@ -506,7 +525,7 @@ static void _sort(Request& r, MethodPara HashStringValue& hash=GET_SELF(r, VHashBase).hash(); int count=hash.count(); - Hash_seq_item* seq=new(PointerFreeGC) Hash_seq_item[count]; + Hash_seq_item* seq=new Hash_seq_item[count]; int pos=0; bool key_values_are_strings=true; @@ -553,8 +572,6 @@ static void _at(Request& r, MethodParams HashStringValue& hash=GET_SELF(r, VHashBase).hash(); size_t count=hash.count(); - int pos=0; - // misha@ // I do not like that type is checked before whence. // But I do not like the idea to move it after whence (where process can be called) even more. @@ -569,20 +586,7 @@ static void _at(Request& r, MethodParams throw Exception(PARSER_RUNTIME, &stype, "type must be 'key', 'value' or 'hash'"); } - Value& vwhence=params[0]; - if(vwhence.is_string()) { - const String& swhence=*vwhence.get_string(); - if(swhence == "last") - pos=count-1; - else if(swhence != "first") - throw Exception(PARSER_RUNTIME, - &swhence, - "whence must be 'first', 'last' or expression"); - } else { - pos=r.process(vwhence).as_int(); - if(pos < 0) - pos+=count; - } + int pos=params.as_index(0, count, r); if(count && pos >= 0 && (size_t)pos < count){ switch(result_type) { @@ -590,15 +594,15 @@ static void _at(Request& r, MethodParams { #ifdef HASH_ORDER if(pos == 0) { - r.write_pass_lang(*new VString(*new String(hash.first_key(), String::L_TAINTED))); + r.write(*new VString(*new String(hash.first_key(), String::L_TAINTED))); } else if((size_t)pos == count-1) { - r.write_pass_lang(*new VString(*new String(hash.last_key(), String::L_TAINTED))); + r.write(*new VString(*new String(hash.last_key(), String::L_TAINTED))); } else #endif { for(HashStringValue::Iterator i(hash); i; i.next(), pos-- ) if(!pos){ - r.write_pass_lang(*new VString(*new String(i.key(), String::L_TAINTED))); + r.write(*new VString(*new String(i.key(), String::L_TAINTED))); break; } } @@ -608,15 +612,15 @@ static void _at(Request& r, MethodParams { #ifdef HASH_ORDER if(pos == 0) { - r.write_pass_lang(*hash.first_value()); + r.write(*hash.first_value()); } else if((size_t)pos == count-1) { - r.write_pass_lang(*hash.last_value()); + r.write(*hash.last_value()); } else #endif { for(HashStringValue::Iterator i(hash); i; i.next(), pos-- ) if(!pos){ - r.write_pass_lang(*i.value()); + r.write(*i.value()); break; } } @@ -626,15 +630,15 @@ static void _at(Request& r, MethodParams { #ifdef HASH_ORDER if(pos == 0) { - r.write_no_lang(SingleElementHash(hash.first_key(), hash.first_value())); + r.write(SingleElementHash(hash.first_key(), hash.first_value())); } else if((size_t)pos == count-1) { - r.write_no_lang(SingleElementHash(hash.last_key(), hash.last_value())); + r.write(SingleElementHash(hash.last_key(), hash.last_value())); } else #endif { for(HashStringValue::Iterator i(hash); i; i.next(), pos-- ) if(!pos){ - r.write_no_lang(SingleElementHash(i.key(), i.value())); + r.write(SingleElementHash(i.key(), i.value())); break; } } @@ -644,6 +648,136 @@ static void _at(Request& r, MethodParams } } +extern String table_reverse_name; + +static void _select(Request& r, MethodParams& params) { + InCycle temp(r); + const String* key_var_name=¶ms.as_string(0, "key-var name must be string"); + const String* value_var_name=¶ms.as_string(1, "value-var name must be string"); + Value& vcondition=params.as_expression(2, "condition must be number, bool or expression"); + + if(key_var_name->is_empty()) key_var_name=0; + if(value_var_name->is_empty()) value_var_name=0; + + HashStringValue& source_hash=GET_SELF(r, VHashBase).hash(); + Value& caller=*r.get_method_frame()->caller(); + + int limit=source_hash.count(); + bool reverse=false; + bool copy_default=false; + + if(params.count()>3) + if(HashStringValue* options=params.as_hash(3)) { + int valid_options=0; + if(Value* vlimit=options->get(sql_limit_name)) { + valid_options++; + limit=r.process(*vlimit).as_int(); + } + if(Value* vreverse=options->get(table_reverse_name)) { + valid_options++; + reverse=r.process(*vreverse).as_bool(); + } + if(Value* vcopy_default=options->get(sql_default_name)) { + valid_options++; + copy_default=r.process(*vcopy_default).as_bool(); + } + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); + } + + HashStringValue& result_hash=*new HashStringValue(); + + if(limit>0){ + +#ifdef HASH_ORDER + if(reverse){ + for(HashStringValue::ReverseIterator i(source_hash); i; i.prev()){ + if(key_var_name) + r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED))); + if(value_var_name) + r.put_element(caller, *value_var_name, i.value()); + + bool condition=r.process(vcondition).as_bool(); + + if(r.check_skip_break()) + break; + + if(condition){ + result_hash.put(i.key(), i.value()); + if(!--limit) + break; + } + } + } else { +#else + { +#endif + for(HashStringValue::Iterator i(source_hash); i; i.next() ){ + if(key_var_name) + r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED))); + if(value_var_name) + r.put_element(caller, *value_var_name, i.value()); + + bool condition=r.process(vcondition).as_bool(); + + if(r.check_skip_break()) + break; + + if(condition){ + result_hash.put(i.key(), i.value()); + if(!--limit) + break; + } + } + } + } + + VHash *result=new VHash(result_hash); + if(copy_default){ + result->set_default(GET_SELF(r, VHashBase).get_default()); + } + + r.write(*result); +} + +static void _reverse(Request& r, MethodParams& params) { + VHashBase& self=GET_SELF(r, VHashBase); + HashStringValue& source_hash=self.hash(); + HashStringValue& result_hash=*new HashStringValue(); + +#ifdef HASH_ORDER + for(HashStringValue::ReverseIterator i(source_hash); i; i.prev()) + result_hash.put(i.key(), i.value()); +#else + for(HashStringValue::Iterator i(source_hash); i; i.next() ) + result_hash.put(i.key(), i.value()); +#endif + + VHashBase& result=*new VHash(result_hash); + if(Value* vdefault=self.get_default()) + result.set_default(vdefault); + + r.write(result); +} + + +static void _rename(Request& r, MethodParams& params) { + HashStringValue& hash=GET_SELF(r, VHashBase).hash(); + + if(params.count()>1){ + const String& key_from=params.as_string(0, "from key must be string"); + const String& key_to=params.as_string(1, "to key must be string"); + + hash.rename(key_from, key_to); + } else { + HashStringValue* names=params.as_hash(0,"single parameter"); + + for(HashStringValue::Iterator i(*names); i; i.next()) + hash.rename(i.key(), i.value()->as_string()); + } +} + + // constructor MHash::MHash(): Methoded("hash") @@ -656,8 +790,8 @@ MHash::MHash(): Methoded("hash") add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1); // ^a.union[b] = hash add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1); - // ^a.intersection[b] = hash - add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 1); + // ^a.intersection[b][options hash] = hash + add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 2); // ^a.intersects[b] = bool add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1); @@ -683,12 +817,22 @@ MHash::MHash(): Methoded("hash") // ^hash.sort[key;value]{string-key-maker}[[asc|desc]] // ^hash.sort[key;value](numeric-key-maker)[[asc|desc]] - add_native_method("sort", Method::CT_DYNAMIC, _sort, 2+1, 2+1+1); + add_native_method("sort", Method::CT_DYNAMIC, _sort, 3, 4); + + // ^hash.select[key;value](bool-condition)[options hash] + add_native_method("select", Method::CT_DYNAMIC, _select, 3, 4); + + // ^hash.reverse[] + add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0); // ^hash._at[first|last[;'key'|'value'|'hash']] // ^hash._at([-+]offset)[['key'|'value'|'hash']] add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2); + // ^hash.rename[from;to] + // ^hash.rename[ $.from[to] ... ] + add_native_method("rename", Method::CT_DYNAMIC, _rename, 1, 2); + #ifdef FEATURE_GET_ELEMENT4CALL // aliases without "_" add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);