--- parser3/src/classes/array.C 2024/09/21 01:36:32 1.6 +++ parser3/src/classes/array.C 2024/11/04 03:53:25 1.35 @@ -1,7 +1,7 @@ /** @file Parser: @b array parser class. - Copyright (c) 2001-2023 Art. Lebedev Studio (http://www.artlebedev.com) + Copyright (c) 2001-2024 Art. Lebedev Studio (http://www.artlebedev.com) Authors: Konstantin Morshnev , Alexandr Petrosian */ @@ -17,7 +17,7 @@ #include "pa_vbool.h" #include "pa_vmethod_frame.h" -volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.6 2024/09/21 01:36:32 moko Exp $"; +volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.35 2024/11/04 03:53:25 moko Exp $"; // class @@ -34,17 +34,11 @@ public: DECLARE_CLASS_VAR(array, new MArray); const char* const PARAM_ARRAY_OR_HASH = "param must be array or hash"; -const char* const PARAM_ARRAY = "param must be array"; +const char* const PARAM_INDEX = "index must be integer"; // methods -enum HState { - HS_FIRST, - HS_STRING, - HS_NUMBER -}; - -static void _create_or_add(Request& r, MethodParams& params) { +static void _copy_or_add(Request& r, MethodParams& params) { if(params.count()) { Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH); VArray& self=GET_SELF(r, VArray); @@ -52,30 +46,25 @@ static void _create_or_add(Request& r, M if(VArray* src=dynamic_cast(&vsrc)) { if(src==&self) - throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array"); - self_array.append(src->array()); + return; + if(self_array.count()){ + for(ArrayValue::Iterator i(src->array()); i; i.next()){ + if(i.value()) + self_array.put(i.index(), i.value()); + } + } else { + self_array.copy(src->array()); + return; + } } else { - HashStringValue* src_hash=vsrc.get_hash(); + HashStringValue* src_hash=vsrc.as_hash("param must be array or"); if(!src_hash) return; - HState hs=HS_FIRST; for(HashStringValue::Iterator i(*src_hash); i; i.next()){ - if (hs==HS_STRING){ - self_array+=i.value(); - } else if(hs==HS_NUMBER){ - self_array.put(VArray::index(i.key()), i.value()); - } else { - try { - self_array.put(VArray::index(i.key()), i.value()); - hs==HS_NUMBER; - } catch(...) { - self_array+=i.value(); - hs==HS_STRING; - } - } + self_array.put(VArray::index(i.key()), i.value()); } } - self.invalidate(); + self_array.invalidate(); } } @@ -93,11 +82,13 @@ static ArrayValue::Action_options get_ac if(Value* voffset=options->get(sql_offset_name)) { valid_options++; - result.offset=r.process(*voffset).as_int(); + int offset=r.process(*voffset).as_int(); + result.offset=offset < 0 ? 0 : offset; } if(Value* vlimit=options->get(sql_limit_name)) { valid_options++; - result.limit=r.process(*vlimit).as_int(); + int limit=r.process(*vlimit).as_int(); + result.limit=limit < 0 ? 0: limit; } if(valid_options!=options->count()) @@ -107,7 +98,7 @@ static ArrayValue::Action_options get_ac } static void _join(Request& r, MethodParams& params) { - Value& vsrc=params.as_no_junction(0, PARAM_ARRAY); + Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH); ArrayValue::Action_options o=get_action_options(r, params, 1); VArray& self=GET_SELF(r, VArray); @@ -135,20 +126,452 @@ static void _join(Request& r, MethodPara self_array+=i.value(); } } - self.invalidate(); - } else - throw Exception(PARSER_RUNTIME, 0, PARAM_ARRAY); + } else { + HashStringValue* src_hash=vsrc.as_hash("param must be array or"); + if(!src_hash) + return; + if(o.defined){ + for(HashStringValue::Iterator i(*src_hash); i; i.next()){ + if(o.offset > 0){ + o.offset--; + continue; + } + if(o.limit-- == 0) + break; + self_array+=i.value(); + } + } else { + for(HashStringValue::Iterator i(*src_hash); i; i.next()){ + self_array+=i.value(); + } + } + } + self_array.invalidate(); } -static void _sql(Request& r, MethodParams& params) {} +#ifndef DOXYGEN + +#define STRING(str) ((str) ? *new String(str, String::L_TAINTED /* no length as 0x00 can be inside */) : String::Empty) + +class SparseArray_sql_event_handlers: public SQL_Driver_query_event_handlers { + bool distinct; + ArrayValue& result; + Value* row_value; + int column_index; + ArrayString* columns; + bool one_bool_column; + Table2hash_value_type value_type; + int columns_count; +public: + Table* empty; +public: + SparseArray_sql_event_handlers(bool adistinct, ArrayValue& aresult, Table2hash_value_type avalue_type): + distinct(adistinct), + result(aresult), + row_value(0), + column_index(0), + columns(new ArrayString), + one_bool_column(false), + value_type(avalue_type), + empty(0) { + } + + bool add_column(SQL_Error& error, const char* str, size_t ) { + try { + if(columns_count){ + // another query in multi_statements mode + columns=new ArrayString; + columns_count=0; + } + *columns+=&STRING(str); + return false; + } catch(...) { + error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column"); + return true; + } + } + + bool before_rows(SQL_Error& error) { + columns_count=columns->count(); + if(columns_count<1) { + error=SQL_Error("no columns"); + 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] and $.sparse(true)"); + return true; + } + break; + } + case C_TABLE: { + // create empty table which we'll copy later + empty=new Table(columns); + break; + } + } + } + return false; + } + + bool add_row(SQL_Error& /*error*/) { + column_index=0; + return false; + } + + bool add_row_cell(SQL_Error& error, const char *str, size_t ) { + try { + if(column_index==columns_count){ + // should never happen, buggy driver case + error=SQL_Error("columns index exceed the columns count"); + return true; + } -static void _sub(Request& r, MethodParams& params) {} + bool duplicate=false; + if(one_bool_column) { + size_t index=str ? pa_atoui(str) : 0; + duplicate=result.put_dont_replace(index, &VBool::get(true)); // put. existed? + } else if(column_index==0) { + size_t index=str ? pa_atoui(str) : 0; + switch(value_type){ + case C_HASH: { + VHash* row_vhash=new VHash; + row_value=row_vhash; + duplicate=result.put_dont_replace(index, row_vhash); // put. existed? + break; + } + case C_STRING: { + VString* row_vstring=new VString(); + row_value=row_vstring; + duplicate=result.put_dont_replace(index, row_vstring); // put. existed? + break; + } + case C_TABLE: { + VTable* vtable=(VTable*)result.get(index); -static void _union(Request& r, MethodParams& params) {} + if(vtable) { // table with this key exist? + if(!distinct) { + duplicate=true; + break; + } + } else { + // no? creating table of same structure as source + Table::Action_options table_options(0, 0); + vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/)); + result.put(index, vtable); // put + } + ArrayString* row=new ArrayString(columns_count); + *row+=&STRING(str); + *vtable->get_table()+=row; + row_value=(Value*)row; + break; + } + } + } else { + const String& cell=STRING(str); + switch(value_type) { + case C_HASH: { + row_value->get_hash()->put(*columns->get(column_index), new VString(cell)); + break; + } + case C_STRING: { + VString* row_string=(VString*)row_value; + row_string->set_string(cell); + break; + } + case C_TABLE: { + ArrayString* row=(ArrayString*)row_value; + *row+=&cell; + break; + } + } + } + + if(duplicate & !distinct) { + error=SQL_Error("duplicate key"); + return true; + } + + column_index++; + return false; + } catch(const Exception& e) { + error=SQL_Error(e.type(), e.comment()); + return true; + } catch(...) { + error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell"); + return true; + } + } +}; + +class Array_sql_event_handlers: public SQL_Driver_query_event_handlers { + ArrayValue& result; + Value* row_value; + int column_index; + ArrayString* columns; + Table2hash_value_type value_type; + int columns_count; +public: + Table* empty; +public: + Array_sql_event_handlers(ArrayValue& aresult, Table2hash_value_type avalue_type): + result(aresult), + row_value(0), + column_index(0), + columns(new ArrayString), + value_type(avalue_type), + empty(0) { + } + + bool add_column(SQL_Error& error, const char* str, size_t ) { + try { + if(columns_count){ + // another query in multi_statements mode + columns=new ArrayString; + columns_count=0; + } + *columns+=&STRING(str); + return false; + } catch(...) { + error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_column"); + return true; + } + } + + bool before_rows(SQL_Error& error) { + columns_count=columns->count(); + if(columns_count<1) { + error=SQL_Error("no columns"); + return true; + } + switch(value_type){ + case C_STRING: { + if(columns_count>1){ + error=SQL_Error("only one column allowed for $.type[string]"); + return true; + } + break; + } + case C_TABLE: { + // create empty table which we'll copy later + empty=new Table(columns); + break; + } + } + return false; + } + + bool add_row(SQL_Error& /*error*/) { + column_index=0; + return false; + } + + bool add_row_cell(SQL_Error& error, const char *str, size_t ) { + try { + if(column_index==columns_count){ + // should never happen, buggy driver case + error=SQL_Error("columns index exceed the columns count"); + return true; + } + + if(column_index==0) { + switch(value_type){ + case C_HASH: { + VHash* row_vhash=new VHash; + row_value=row_vhash; + result+=row_vhash; + break; + } + case C_STRING: { + VString* row_vstring=new VString(); + row_value=row_vstring; + result+=row_vstring; + break; + } + case C_TABLE: { + // creating table of same structure as source + Table::Action_options table_options(0, 0); + VTable* vtable=new VTable(new Table(*empty, table_options/*no rows, just structure*/)); + ArrayString* row=new ArrayString(columns_count); + *vtable->get_table()+=row; + row_value=(Value*)row; + result+=vtable; + break; + } + } + } + + const String& cell=STRING(str); + switch(value_type) { + case C_HASH: { + row_value->get_hash()->put(*columns->get(column_index), new VString(cell)); + break; + } + case C_STRING: { + VString* row_string=(VString*)row_value; + row_string->set_string(cell); + break; + } + case C_TABLE: { + ArrayString* row=(ArrayString*)row_value; + *row+=&cell; + break; + } + } + + column_index++; + return false; + } catch(const Exception& e) { + error=SQL_Error(e.type(), e.comment()); + return true; + } catch(...) { + error=SQL_Error("exception occurred in Hash_sql_event_handlers::add_row_cell"); + return true; + } + } +}; + +#endif + +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); + +static void _sql(Request& r, MethodParams& params) { + Value& statement=params.as_junction(0, "statement must be code"); + + HashStringValue* bind=0; + ulong limit=SQL_NO_LIMIT; + ulong offset=0; + bool distinct=false; + bool sparse=false; + Table2hash_value_type value_type=C_HASH; + if(params.count()>1) + if(HashStringValue* options=params.as_hash(1, "sql options")) { + int valid_options=0; + bool distinct_specified=false; + 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(); + distinct_specified=true; + valid_options++; + } else if (key == sql_value_type_name) { + value_type=get_value_type(r.process(*value)); + valid_options++; + } else if (key == "sparse") { + sparse=r.process(*value).as_bool(); + valid_options++; + } + } + if(valid_options!=options->count()) + throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION); + if(distinct_specified && !sparse) + throw Exception(PARSER_RUNTIME, 0, "'distinct' option can only be used when $.sparse(true) is specified"); + } -static void _intersection(Request& r, MethodParams& params) {} + SQL_Driver::Placeholder* placeholders=0; + uint placeholders_count=0; + if(bind) + placeholders_count=marshal_binds(*bind, placeholders); -static void _intersects(Request& r, MethodParams& params) {} + const String& statement_string=r.process_to_string(statement); + const char* statement_cstr=statement_string.untaint_cstr(String::L_SQL, r.connection()); + + VArray& self=GET_SELF(r, VArray); + ArrayValue& array=self.array(); + + if(array.count()){ + array.clear(); array.invalidate(); // just in case if called as method + } + + if(sparse){ + SparseArray_sql_event_handlers handlers(distinct, array, value_type); + r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string); + } else { + Array_sql_event_handlers handlers(array, value_type); + r.connection()->query(statement_cstr, placeholders_count, placeholders, offset, limit, handlers, statement_string); + } + + array.confirm_all_used(); + + if(bind) + unmarshal_bind_updates(*bind, placeholders_count, placeholders); +} + + +static void mid(Request& r, size_t offset=0, size_t limit=ARRAY_OPTION_LIMIT_ALL) { + ArrayValue& array=GET_SELF(r, VArray).array(); + if(limit>0){ + VArray *result=new VArray; + ArrayValue& result_array=result->array(); + for(ArrayValue::Iterator i(array); i; i.next()){ + if(i.value()){ + if(offset > 0){ + offset--; + continue; + } + if(limit-- == 0) + break; + result_array+=i.value(); + } + } + result_array.confirm_all_used(); + r.write(*result); + } else { + r.write(*new VArray); + } +} + +static void _left(Request& r, MethodParams& params) { + int sn=params.as_int(0, "n must be int", r); + mid(r, 0, sn < 0 ? 0 : sn); +} + +static void _right(Request& r, MethodParams& params) { + int sn=params.as_int(0, "n must be int", r); + + if(sn>0){ + size_t used=GET_SELF(r, VArray).array().used(); + if((size_t)sn=0", begin); + + if(params.count()>1) { + int n=params.as_int(1, "n must be int", r); + if(n<0) + throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n); + mid(r, begin, n); + } else { + mid(r, begin); + } +} static void _keys(Request& r, MethodParams& params) { const String* keys_column_name; @@ -186,52 +609,82 @@ static void _count(Request& r, MethodPar r.write(*new VInt(array.used())); } -static void _append(Request& r, MethodParams& params) { - VArray& self=GET_SELF(r, VArray); - ArrayValue& array=self.array(); +static void _create_or_append_or_push(Request& r, MethodParams& params) { + ArrayValue& array=GET_SELF(r, VArray).array(); int count=params.count(); - for(int i=0; i0) - GET_SELF(r, VArray).clear(VArray::index(params.as_int(0, "index must be integer", r))); - else - GET_SELF(r, VArray).clear(); + ArrayValue& array=GET_SELF(r, VArray).array(); + if(params.count()>0) { + if(params[0].is_string()) { + array.clear(VArray::index(*params[0].get_string())); + } else { + array.clear(VArray::index(params.as_int(0, PARAM_INDEX, r))); + } + } else + array.clear(); + array.invalidate(); +} + +static void _remove(Request& r, MethodParams& params) { + ArrayValue& array=GET_SELF(r, VArray).array(); + array.remove(VArray::index(params.as_int(0, PARAM_INDEX, r))); + array.invalidate(); +} + +static void _pop(Request& r, MethodParams& params) { + ArrayValue& array=GET_SELF(r, VArray).array(); + Value *result=array.pop(); + if(result){ + r.write(*result); + array.change_used(-1); + } else { + r.write(*VVoid::get()); + } } static void _contains(Request& r, MethodParams& params) { VArray& self=GET_SELF(r, VArray); - bool result=self.contains(VArray::index(params.as_int(0, "index must be integer", r))); + + bool result=self.contains(params[0].is_string() ? VArray::index(*params[0].get_string()) : VArray::index(params.as_int(0, PARAM_INDEX, r))); r.write(VBool::get(result)); } static void _for(Request& r, MethodParams& params) { InCycle temp(r); - const String* value_var_name=¶ms.as_string(0, "value-var name must be string"); - Value* body_code=¶ms.as_junction(1, "body must be code"); - Value* delim_maybe_code=params.count()>2?¶ms[2]:0; + 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* body_code=¶ms.as_junction(2, "body must be code"); + Value* delim_maybe_code=params.count()>3 ? ¶ms[3] : 0; Value& caller=*r.get_method_frame()->caller(); + if(key_var_name->is_empty()) key_var_name=0; if(value_var_name->is_empty()) value_var_name=0; ArrayValue& array=GET_SELF(r, VArray).array(); @@ -239,6 +692,11 @@ static void _for(Request& r, MethodParam if(delim_maybe_code){ // delimiter set bool need_delim=false; for(ArrayValue::Iterator i(array); i; i.next()){ + if(key_var_name){ + VString* vkey=new VString(*new String(i.key(), String::L_TAINTED)); + r.put_element(caller, *key_var_name, vkey); + } + if(value_var_name) r.put_element(caller, *value_var_name, i.value() ? i.value() : VVoid::get()); @@ -260,6 +718,11 @@ static void _for(Request& r, MethodParam } } else { for(ArrayValue::Iterator i(array); i; i.next()){ + if(key_var_name){ + VString* vkey=new VString(*new String(i.key(), String::L_TAINTED)); + r.put_element(caller, *key_var_name, vkey); + } + if(value_var_name) r.put_element(caller, *value_var_name, i.value() ? i.value() : VVoid::get()); @@ -272,15 +735,12 @@ static void _for(Request& r, MethodParam } static void _foreach(Request& r, MethodParams& params) { - if(params[1].get_junction()) - return _for(r, 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* body_code=¶ms.as_junction(2, "body must be code"); - Value* delim_maybe_code=params.count()>3?¶ms[3]:0; + Value* delim_maybe_code=params.count()>3 ? ¶ms[3] : 0; Value& caller=*r.get_method_frame()->caller(); if(key_var_name->is_empty()) key_var_name=0; @@ -419,6 +879,7 @@ static void _sort(Request& r, MethodPara for(pos=0; pos 1) { const String& stype=params.as_string(1, "type must be string"); @@ -452,53 +910,72 @@ 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) { - case AtResultTypeKey: - { - for(ArrayValue::Iterator i(array); i; i.next() ){ - if(i.value() && !(pos--)){ + if(count == array.count()){ +l1: switch(result_type) { + case AtResultTypeKey: + r.write(*new VString(*new String(pa_uitoa(pos), String::L_TAINTED))); + break; + case AtResultTypeValue: + r.write(*array.get(pos)); + break; + case AtResultTypeHash: + r.write(SingleElementHash(pa_uitoa(pos), array.get(pos))); + break; + } + } else if((size_t)pos == count-1){ + pos=array.count()-1; + goto l1; + } else { + for(ArrayValue::Iterator i(array); i; i.next() ){ + if(i.value() && !(pos--)){ + switch(result_type) { + case AtResultTypeKey: r.write(*new VString(*new String(i.key(), String::L_TAINTED))); break; - } - } - break; - } - case AtResultTypeValue: - { - for(ArrayValue::Iterator i(array); i; i.next() ) - if(i.value() &&!(pos--)){ + case AtResultTypeValue: r.write(*i.value()); break; - } - break; - } - case AtResultTypeHash: - { - for(ArrayValue::Iterator i(array); i; i.next() ) - if(i.value() &&!(pos--)){ + case AtResultTypeHash: r.write(SingleElementHash(i.key(), i.value())); break; - } + } break; } + } } } } +static void _set(Request& r, MethodParams& params) { + ArrayValue& array=GET_SELF(r, VArray).array(); + size_t count=array.used(); // not array.count() + + int pos=params.as_index(0, count, r); + + if(count && pos >= 0 && (size_t)pos < count){ + if(count == array.count()){ + array.put(pos, &r.process(params[1])); + return; + } else if((size_t)pos == count-1){ + array.put(array.count()-1, &r.process(params[1])); + return; + } else { + for(ArrayValue::Iterator i(array); i; i.next() ){ + if(i.value() && !(pos--)){ + array.put(i.index(), &r.process(params[1])); + return; + } + } + } + } + + if(count) + throw Exception(PARSER_RUNTIME, 0, "index '%d' is out of range 0..%d", pos, count-1); + throw Exception(PARSER_RUNTIME, 0, "index '%d' is out of range: array is empty", pos); +} extern String table_reverse_name; @@ -579,10 +1056,11 @@ static void _select(Request& r, MethodPa } } + result_array.confirm_all_used(); r.write(*result); } -static void _reverse(Request& r, MethodParams& params) { +static void _reverse(Request& r, MethodParams&) { ArrayValue& source_array=GET_SELF(r, VArray).array(); VArray& result=*new VArray(source_array.count()); @@ -595,37 +1073,58 @@ static void _reverse(Request& r, MethodP r.write(result); } +static void _compact(Request& r, MethodParams& params) { + bool compact_undef=false; + if(params.count()>0){ + const String& what=params.as_string(0, PARAMETER_MUST_BE_STRING); + if(!what.is_empty()){ + if(what != "undef") + throw Exception(PARSER_RUNTIME, &what, "param must be empty or 'undef'"); + compact_undef=true; + } + } + ArrayValue& array=GET_SELF(r, VArray).array(); + array.compact(compact_undef); + array.confirm_all_used(); +} + // constructor MArray::MArray(): Methoded(VARRAY_TYPE) { - // ^array::create[[copy_from]] - add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1); + // ^array::copy[[copy_from]] + add_native_method("copy", Method::CT_DYNAMIC, _copy_or_add, 0, 1); // ^array.add[add_from] - add_native_method("add", Method::CT_DYNAMIC, _create_or_add, 1, 1); + add_native_method("add", Method::CT_DYNAMIC, _copy_or_add, 1, 1); // ^array.join[join_from[;options]] add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2); - // ^array.sub[sub_from] - add_native_method("sub", Method::CT_DYNAMIC, _sub, 1, 1); - // ^array.union[b] = array - add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1); - // ^array.intersection[b][options array] = array - add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 2); - // ^array.intersects[b] = bool - add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1); - - // ^array.append[value;value] - add_native_method("append", Method::CT_DYNAMIC, _append, 1, 10000); - - // ^array.insert[index;value...] + // ^array::create[value[;value...]] + add_native_method("create", Method::CT_DYNAMIC, _create_or_append_or_push, 0, 10000); + // ^array.append[value[;value...]] + add_native_method("append", Method::CT_DYNAMIC, _create_or_append_or_push, 1, 10000); + // ^array.push[value[;value...]] + add_native_method("push", Method::CT_DYNAMIC, _create_or_append_or_push, 1, 10000); + // ^array.insert(index)[value[;value...]] add_native_method("insert", Method::CT_DYNAMIC, _insert, 2, 10000); - // ^array.delete[index] + // ^array.left(n) + add_native_method("left", Method::CT_DYNAMIC, _left, 1, 1); + // ^array.right(n) + add_native_method("right", Method::CT_DYNAMIC, _right, 1, 1); + // ^array.mid(p) + // ^array.mid(p;n) + add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2); + + // ^array.delete(index) or ^array.delete[index] add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1); + // ^array.remove(index) + add_native_method("remove", Method::CT_DYNAMIC, _remove, 1, 1); + // ^array.pop[] + add_native_method("pop", Method::CT_DYNAMIC, _pop, 0, 0); - // ^array.contains[index] + // ^array.contains(index) ^array.contains[index] add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1); // ^array::sql[query][options array] @@ -637,8 +1136,10 @@ MArray::MArray(): Methoded(VARRAY_TYPE) // ^array._count[[all]] add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 1); + // ^array.for[index;value]{code}[delim] + add_native_method("for", Method::CT_DYNAMIC, _for, 3, 3+1); // ^array.foreach[index;value]{code}[delim] - add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2, 2+1+1); + add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 3, 3+1); // ^array.sort[index;value]{string-key-maker}[[asc|desc]] // ^array.sort[index;value](numeric-key-maker)[[asc|desc]] @@ -650,14 +1151,21 @@ MArray::MArray(): Methoded(VARRAY_TYPE) // ^array.reverse[] add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0); + // ^array.compact[[undef]] + add_native_method("compact", Method::CT_DYNAMIC, _compact, 0, 1); + // ^array._at[first|last[;'key'|'value'|'hash']] - // ^array._at([-+]offset)[['key'|'value'|'hash']] + // ^array._at([-+]index)[['key'|'value'|'hash']] add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2); + // ^array.set[first|last;value] + // ^array.set([-+]index)[value] + add_native_method("set", Method::CT_DYNAMIC, _set, 2, 2); + #ifdef FEATURE_GET_ELEMENT4CALL // aliases without "_" add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1); - add_native_method("count", Method::CT_DYNAMIC, _count, 0, 0); + add_native_method("count", Method::CT_DYNAMIC, _count, 0, 1); add_native_method("at", Method::CT_DYNAMIC, _at, 1, 2); #endif