[BACK]Return to array.C CVS log [TXT] [DIR] Up to [parser3project] / parser3 / src / classes

Diff for /parser3/src/classes/array.C between versions 1.9 and 1.26

version 1.9, 2024/09/22 17:01:23 version 1.26, 2024/10/26 18:53:36
Line 38  const char* const PARAM_INDEX = "index m Line 38  const char* const PARAM_INDEX = "index m
   
 // methods  // methods
   
 static void _create_or_add(Request& r, MethodParams& params) {  static void _copy_or_add(Request& r, MethodParams& params) {
         if(params.count()) {          if(params.count()) {
                 Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH);                  Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH);
                 VArray& self=GET_SELF(r, VArray);                  VArray& self=GET_SELF(r, VArray);
Line 46  static void _create_or_add(Request& r, M Line 46  static void _create_or_add(Request& r, M
   
                 if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {                  if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
                         if(src==&self)                          if(src==&self)
                                 throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");                                  return;
                         self_array.append(src->array());                          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.append(src->array());
                           }
                 } else {                  } else {
                         HashStringValue* src_hash=vsrc.get_hash();                          HashStringValue* src_hash=vsrc.as_hash("param must be array or");
                         if(!src_hash)                          if(!src_hash)
                                 return;                                  return;
                         for(HashStringValue::Iterator i(*src_hash); i; i.next()){                          for(HashStringValue::Iterator i(*src_hash); i; i.next()){
                                 self_array.put(VArray::index(i.key()), i.value());                                  self_array.put(VArray::index(i.key()), i.value());
                         }                          }
                 }                  }
                 self.invalidate();                  self_array.invalidate();
         }          }
 }  }
   
Line 119  static void _join(Request& r, MethodPara Line 126  static void _join(Request& r, MethodPara
                         }                          }
                 }                  }
         } else {          } else {
                 HashStringValue* src_hash=vsrc.get_hash();                  HashStringValue* src_hash=vsrc.as_hash("param must be array or");
                 if(!src_hash)                  if(!src_hash)
                         return;                          return;
                 if(o.defined){                  if(o.defined){
Line 138  static void _join(Request& r, MethodPara Line 145  static void _join(Request& r, MethodPara
                         }                          }
                 }                  }
         }          }
         self.invalidate();          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 mid(Request& r, ArrayValue::Action_options o) {                          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);
   
                                                   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");
                   }
   
           SQL_Driver::Placeholder* placeholders=0;
           uint placeholders_count=0;
           if(bind)
                   placeholders_count=marshal_binds(*bind, placeholders);
   
           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();          ArrayValue& array=GET_SELF(r, VArray).array();
         if(o.limit>0){          if(limit>0){
                 VArray *result=new VArray;                  VArray *result=new VArray;
                 ArrayValue& result_array=result->array();                  ArrayValue& result_array=result->array();
                 for(ArrayValue::Iterator i(array); i; i.next()){                  for(ArrayValue::Iterator i(array); i; i.next()){
                         if(i.value()){                          if(i.value()){
                                 if(o.offset > 0){                                  if(offset > 0){
                                         o.offset--;                                          offset--;
                                         continue;                                          continue;
                                 }                                  }
                                 if(o.limit-- == 0)                                  if(limit-- == 0)
                                         break;                                          break;
                                 result_array+=i.value();                                  result_array+=i.value();
                         }                          }
                 }                  }
                   result_array.confirm_all_used();
                 r.write(*result);                  r.write(*result);
         } else {          } else {
                 r.write(*new VArray);                  r.write(*new VArray);
Line 168  static void mid(Request& r, ArrayValue:: Line 538  static void mid(Request& r, ArrayValue::
   
 static void _left(Request& r, MethodParams& params) {  static void _left(Request& r, MethodParams& params) {
         int sn=params.as_int(0, "n must be int", r);          int sn=params.as_int(0, "n must be int", r);
         mid(r, ArrayValue::Action_options(0, sn < 0 ? 0 : sn));          mid(r, 0, sn < 0 ? 0 : sn);
 }  }
   
 static void _right(Request& r, MethodParams& params) {  static void _right(Request& r, MethodParams& params) {
Line 176  static void _right(Request& r, MethodPar Line 546  static void _right(Request& r, MethodPar
   
         if(sn>0){          if(sn>0){
                 size_t used=GET_SELF(r, VArray).array().used();                  size_t used=GET_SELF(r, VArray).array().used();
                 if(sn<used){                  if((size_t)sn<used){
                         mid(r, ArrayValue::Action_options(used-sn, sn));                          mid(r, used-sn, sn);
                 } else {                  } else {
                         mid(r, ArrayValue::Action_options());                          mid(r);
                 }                  }
         } else {          } else {
                 mid(r, ArrayValue::Action_options(0, 0));                  mid(r, 0, 0);
         }          }
 }  }
   
 static void _mid(Request& r, MethodParams& params) {  static void _mid(Request& r, MethodParams& params) {
         const String& string=GET_SELF(r, VString).string();  
   
         int begin=params.as_int(0, "p must be int", r);          int begin=params.as_int(0, "p must be int", r);
   
         if(begin<0)          if(begin<0)
                 throw Exception(PARSER_RUNTIME, 0,  "p(%d) must be >=0", begin);                  throw Exception(PARSER_RUNTIME, 0,  "p(%d) must be >=0", begin);
   
         size_t end;  
         size_t length=0;  
   
         if(params.count()>1) {          if(params.count()>1) {
                 int n=params.as_int(1, "n must be int", r);                  int n=params.as_int(1, "n must be int", r);
                 if(n<0)                  if(n<0)
                         throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n);                          throw Exception(PARSER_RUNTIME, 0, "n(%d) must be >=0", n);
                 mid(r, ArrayValue::Action_options(begin, n));                  mid(r, begin, n);
         } else {          } else {
                 mid(r, ArrayValue::Action_options(begin));                  mid(r, begin);
         }          }
 }  }
   
Line 242  static void _count(Request& r, MethodPar Line 608  static void _count(Request& r, MethodPar
         r.write(*new VInt(array.used()));          r.write(*new VInt(array.used()));
 }  }
   
 static void _append(Request& r, MethodParams& params) {  static void _create_or_append(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          ArrayValue& array=GET_SELF(r, VArray).array();
         ArrayValue& array=self.array();  
   
         int count=params.count();          int count=params.count();
   
         for(int i=0; i<count; i++){          if(array.count()){
                 array+=&r.process(params[i]);                  for(int i=0; i<count; i++)
                           array+=&r.process(params[i]);
                   array.invalidate();
           } else {
                   for(int i=0; i<count; i++)
                           array+=&r.process(params[i]);
                   array.confirm_all_used();
         }          }
         self.invalidate();  
 }  }
   
 static void _insert(Request& r, MethodParams& params) {  static void _insert(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          ArrayValue& array=GET_SELF(r, VArray).array();
         ArrayValue& array=self.array();  
   
         int count=params.count();          int count=params.count();
         size_t index=VArray::index(params.as_int(0, PARAM_INDEX, r));          size_t index=VArray::index(params.as_int(0, PARAM_INDEX, r));
Line 264  static void _insert(Request& r, MethodPa Line 633  static void _insert(Request& r, MethodPa
         for(int i=1; i<count; i++){          for(int i=1; i<count; i++){
                 array.insert(index++, &r.process(params[i]));                  array.insert(index++, &r.process(params[i]));
         }          }
         self.invalidate();          array.invalidate();
 }  }
   
 static void _delete(Request& r, MethodParams& params) {  static void _delete(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          ArrayValue& array=GET_SELF(r, VArray).array();
         if(params.count()>0)          if(params.count()>0)
                 self.array().clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));                  array.clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
         else          else
                 self.array().clear();                  array.clear();
         self.invalidate();          array.invalidate();
 }  }
   
 static void _remove(Request& r, MethodParams& params) {  static void _remove(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          ArrayValue& array=GET_SELF(r, VArray).array();
         self.array().remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));          array.remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));
         self.invalidate();          array.invalidate();
 }  }
   
 static void _contains(Request& r, MethodParams& params) {  static void _contains(Request& r, MethodParams& params) {
Line 492  static void _sort(Request& r, MethodPara Line 861  static void _sort(Request& r, MethodPara
                 for(pos=0; pos<count; pos++)                  for(pos=0; pos<count; pos++)
                         array+=seq[pos].array_data;                          array+=seq[pos].array_data;
   
           array.confirm_all_used();
         delete[] seq;          delete[] seq;
 }  }
   
Line 501  enum AtResultType { Line 871  enum AtResultType {
         AtResultTypeHash = 2          AtResultTypeHash = 2
 };  };
   
 inline Value& SingleElementHash(String::Body akey, Value* avalue) {  static Value& SingleElementHash(String::Body akey, Value* avalue) {
         Value& result=*new VHash;          Value& result=*new VHash;
         result.put_element(*new String(akey, String::L_TAINTED), avalue);          result.put_element(*new String(akey, String::L_TAINTED), avalue);
         return result;          return result;
 }  }
   
 static void _at(Request& r, MethodParams& params) {  static void _at(Request& r, MethodParams& params) {
         VArray& self=GET_SELF(r, VArray);          ArrayValue& array=GET_SELF(r, VArray).array();
         ArrayValue& array=self.array();  
         size_t count=array.used(); // not array.count()          size_t count=array.used(); // not array.count()
   
         int pos=0;          int pos=0;
Line 539  static void _at(Request& r, MethodParams Line 908  static void _at(Request& r, MethodParams
         }          }
   
         if(count && pos >= 0 && (size_t)pos < count){          if(count && pos >= 0 && (size_t)pos < count){
                 switch(result_type) {                  if(count == array.count()){
                         case AtResultTypeKey:                          switch(result_type) {
                                 {                                  case AtResultTypeKey:
                                         for(ArrayValue::Iterator i(array); i; i.next() ){                                          r.write(*new VString(*new String(pa_uitoa(pos), String::L_TAINTED)));
                                                 if(i.value() && !(pos--)){                                          break;
                                   case AtResultTypeValue:
                                           r.write(*array.get(pos));
                                           break;
                                   case AtResultTypeHash:
                                           r.write(SingleElementHash(pa_uitoa(pos), array.get(pos)));
                                           break;
                           }
                   } 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)));                                                          r.write(*new VString(*new String(i.key(), String::L_TAINTED)));
                                                         break;                                                          break;
                                                 }                                                  case AtResultTypeValue:
                                         }  
                                         break;  
                                 }  
                         case AtResultTypeValue:  
                                 {  
                                         for(ArrayValue::Iterator i(array); i; i.next() )  
                                                 if(i.value() &&!(pos--)){  
                                                         r.write(*i.value());                                                          r.write(*i.value());
                                                         break;                                                          break;
                                                 }                                                  case AtResultTypeHash:
                                         break;  
                                 }  
                         case AtResultTypeHash:  
                                 {  
                                         for(ArrayValue::Iterator i(array); i; i.next() )  
                                                 if(i.value() &&!(pos--)){  
                                                         r.write(SingleElementHash(i.key(), i.value()));                                                          r.write(SingleElementHash(i.key(), i.value()));
                                                         break;                                                          break;
                                                 }                                          }
                                         break;                                          break;
                                 }                                  }
                           }
                 }                  }
         }          }
 }  }
Line 652  static void _select(Request& r, MethodPa Line 1021  static void _select(Request& r, MethodPa
                 }                  }
         }          }
   
           result_array.confirm_all_used();
         r.write(*result);          r.write(*result);
 }  }
   
 static void _reverse(Request& r, MethodParams& params) {  static void _reverse(Request& r, MethodParams&) {
         ArrayValue& source_array=GET_SELF(r, VArray).array();          ArrayValue& source_array=GET_SELF(r, VArray).array();
   
         VArray& result=*new VArray(source_array.count());          VArray& result=*new VArray(source_array.count());
Line 668  static void _reverse(Request& r, MethodP Line 1038  static void _reverse(Request& r, MethodP
         r.write(result);          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  // constructor
   
 MArray::MArray(): Methoded(VARRAY_TYPE) {  MArray::MArray(): Methoded(VARRAY_TYPE) {
   
         // ^array::create[[copy_from]]          // ^array::copy[[copy_from]]
         add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);          add_native_method("copy", Method::CT_DYNAMIC, _copy_or_add, 0, 1);
         // ^array.add[add_from]          // ^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]]          // ^array.join[join_from[;options]]
         add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2);          add_native_method("join", Method::CT_DYNAMIC, _join, 1, 2);
   
           // ^array::create[value;value]
           add_native_method("create", Method::CT_DYNAMIC, _create_or_append, 0, 10000);
           // ^array.append[value;value]
           add_native_method("append", Method::CT_DYNAMIC, _create_or_append, 1, 10000);
           // ^array.insert[index;value...]
           add_native_method("insert", Method::CT_DYNAMIC, _insert, 2, 10000);
   
         // ^array.left(n)          // ^array.left(n)
         add_native_method("left", Method::CT_DYNAMIC, _left, 1, 1);          add_native_method("left", Method::CT_DYNAMIC, _left, 1, 1);
         // ^array.right(n)          // ^array.right(n)
Line 688  MArray::MArray(): Methoded(VARRAY_TYPE) Line 1080  MArray::MArray(): Methoded(VARRAY_TYPE)
         // ^array.mid(p;n)          // ^array.mid(p;n)
         add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2);          add_native_method("mid", Method::CT_DYNAMIC, _mid, 1, 2);
   
         // ^array::new[value;value]  
         add_native_method("new", Method::CT_DYNAMIC, _append, 0, 10000);  
         // ^array.append[value;value]  
         add_native_method("append", Method::CT_DYNAMIC, _append, 1, 10000);  
         // ^array.insert[index;value...]  
         add_native_method("insert", Method::CT_DYNAMIC, _insert, 2, 10000);  
   
         // ^array.delete[index]          // ^array.delete[index]
         add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);          add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);
         // ^array.remove[index]          // ^array.remove[index]
Line 727  MArray::MArray(): Methoded(VARRAY_TYPE) Line 1112  MArray::MArray(): Methoded(VARRAY_TYPE)
         // ^array.reverse[]          // ^array.reverse[]
         add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0);          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[first|last[;'key'|'value'|'hash']]
         // ^array._at([-+]offset)[['key'|'value'|'hash']]          // ^array._at([-+]offset)[['key'|'value'|'hash']]
         add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);          add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);
Line 734  MArray::MArray(): Methoded(VARRAY_TYPE) Line 1122  MArray::MArray(): Methoded(VARRAY_TYPE)
 #ifdef FEATURE_GET_ELEMENT4CALL  #ifdef FEATURE_GET_ELEMENT4CALL
         // aliases without "_"          // aliases without "_"
         add_native_method("keys", Method::CT_DYNAMIC, _keys, 0, 1);          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);          add_native_method("at", Method::CT_DYNAMIC, _at, 1, 2);
 #endif  #endif
   
Removed from v.1.9  
changed lines
  Added in v.1.26

E-mail: