--- parser3/src/classes/array.C	2024/09/10 19:15:48	1.1
+++ parser3/src/classes/array.C	2024/09/22 18:23:22	1.10
@@ -17,7 +17,7 @@
 #include "pa_vbool.h"
 #include "pa_vmethod_frame.h"
 
-volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.1 2024/09/10 19:15:48 moko Exp $";
+volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.10 2024/09/22 18:23:22 moko Exp $";
 
 // class
 
@@ -33,37 +33,178 @@ public:
 
 DECLARE_CLASS_VAR(array, new MArray);
 
+const char* const PARAM_ARRAY_OR_HASH = "param must be array or hash";
+const char* const PARAM_INDEX = "index must be integer";
+
 // methods
 
 static void _create_or_add(Request& r, MethodParams& params) {
 	if(params.count()) {
-		Value& vsrc=params.as_no_junction(0, PARAM_MUST_BE_HASH);
+		Value& vsrc=params.as_no_junction(0, PARAM_ARRAY_OR_HASH);
 		VArray& self=GET_SELF(r, VArray);
 		ArrayValue& self_array=self.array();
 
-		if(VArray* src=static_cast<VArray*>(vsrc.as(VARRAY_TYPE))) {
-			ArrayValue& src_array =src->array();
-			if(&src_array==&self_array) // same: doing nothing
-				return;
+		if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
+			if(src==&self)
+				throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");
+			self_array.append(src->array());
 		} else {
 			HashStringValue* src_hash=vsrc.get_hash();
-			if(src_hash)
-				for(HashStringValue::Iterator i(*src_hash); i; i.next())
+			if(!src_hash)
+				return;
+			for(HashStringValue::Iterator i(*src_hash); i; i.next()){
+				self_array.put(VArray::index(i.key()), i.value());
+			}
+		}
+		self.invalidate();
+	}
+}
+
+static ArrayValue::Action_options get_action_options(Request& r, MethodParams& params, size_t options_index) {
+	ArrayValue::Action_options result;
+	if(params.count() <= options_index)
+		return result;
+
+	HashStringValue* options=params.as_hash(options_index);
+	if(!options)
+		return result;
+
+	result.defined=true;
+	int valid_options=0;
+
+	if(Value* voffset=options->get(sql_offset_name)) {
+		valid_options++;
+		int offset=r.process(*voffset).as_int();
+		result.offset=offset < 0 ? 0 : offset;
+	}
+	if(Value* vlimit=options->get(sql_limit_name)) {
+		valid_options++;
+		int limit=r.process(*vlimit).as_int();
+		result.limit=limit < 0 ? 0: limit;
+	}
+
+	if(valid_options!=options->count())
+		throw Exception(PARSER_RUNTIME, 0, CALLED_WITH_INVALID_OPTION);
+
+	return result;
+}
+
+static void _join(Request& r, MethodParams& params) {
+	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);
+	ArrayValue& self_array=self.array();
+
+	if(VArray* src=dynamic_cast<VArray*>(&vsrc)) {
+		if(src==&self)
+			throw Exception(PARSER_RUNTIME, 0, "source and destination are the same array");
+
+		if(o.defined){
+			for(ArrayValue::Iterator i(src->array()); i; i.next()){
+				if(i.value()){
+					if(o.offset > 0){
+						o.offset--;
+						continue;
+					}
+					if(o.limit-- == 0)
+						break;
 					self_array+=i.value();
+				}
+			}
+		} else {
+			for(ArrayValue::Iterator i(src->array()); i; i.next()){
+				if(i.value())
+					self_array+=i.value();
+			}
+		}
+	} else {
+		HashStringValue* src_hash=vsrc.get_hash();
+		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.clear_hash();
 	}
+	self.invalidate();
 }
 
 static void _sql(Request& r, MethodParams& params) {}
 
-static void _sub(Request& r, MethodParams& params) {}
 
-static void _union(Request& r, MethodParams& params) {}
+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();
+			}
+		}
+		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(sn<used){
+			mid(r, used-sn, sn);
+		} else {
+			mid(r);
+		}
+	} else {
+		mid(r, 0, 0);
+	}
+}
 
-static void _intersection(Request& r, MethodParams& params) {}
+static void _mid(Request& r, MethodParams& params) {
+	const String& string=GET_SELF(r, VString).string();
 
-static void _intersects(Request& r, MethodParams& params) {}
+	int begin=params.as_int(0, "p must be int", r);
+	if(begin<0)
+		throw Exception(PARSER_RUNTIME, 0,  "p(%d) must be >=0", begin);
+
+	size_t end;
+	size_t length=0;
+
+	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;
@@ -88,30 +229,131 @@ static void _keys(Request& r, MethodPara
 	r.write(*new VTable(table));
 }
 
-static void _count(Request& r, MethodParams&) {
-	r.write(*new VInt(GET_SELF(r, VArray).count()));
+static void _count(Request& r, MethodParams& params) {
+	ArrayValue& array=GET_SELF(r, VArray).array();
+	if(params.count()>0){
+		const String& what=params.as_string(0, PARAMETER_MUST_BE_STRING);
+		if(!what.is_empty()){
+			if(what != "all")
+				throw Exception(PARSER_RUNTIME, &what, "param must be empty or 'all'");
+			return r.write(*new VInt(array.count()));
+		}
+	}
+	r.write(*new VInt(array.used()));
+}
+
+static void _append(Request& r, MethodParams& params) {
+	VArray& self=GET_SELF(r, VArray);
+	ArrayValue& array=self.array();
+
+	int count=params.count();
+
+	for(int i=0; i<count; i++){
+		array+=&r.process(params[i]);
+	}
+	self.invalidate();
+}
+
+static void _insert(Request& r, MethodParams& params) {
+	VArray& self=GET_SELF(r, VArray);
+	ArrayValue& array=self.array();
+
+	int count=params.count();
+	size_t index=VArray::index(params.as_int(0, PARAM_INDEX, r));
+
+	for(int i=1; i<count; i++){
+		array.insert(index++, &r.process(params[i]));
+	}
+	self.invalidate();
 }
 
 static void _delete(Request& r, MethodParams& params) {
+	VArray& self=GET_SELF(r, VArray);
 	if(params.count()>0)
-		GET_SELF(r, VArray).clear(VArray::index(params.as_int(0, "index must be integer", r)));
+		self.array().clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
 	else
-		GET_SELF(r, VArray).clear();
+		self.array().clear();
+	self.invalidate();
+}
+
+static void _remove(Request& r, MethodParams& params) {
+	VArray& self=GET_SELF(r, VArray);
+	self.array().remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));
+	self.invalidate();
 }
 
 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(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* 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* body_code=&params.as_junction(2, "body must be code");
+	Value* delim_maybe_code=params.count()>3 ? &params[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();
+
+	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());
+
+			Value& sv_processed=r.process(*body_code);
+			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(r.process(*delim_maybe_code));
+				else
+					need_delim=true;
+			}
+
+			r.write(sv_processed);
+
+			if(skip.check_break())
+				break;
+		}
+	} 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());
+
+			r.process_write(*body_code);
+
+			if(r.check_skip_break())
+				break;
+		}
+	}
+}
+
 static void _foreach(Request& r, MethodParams& params) {
 	InCycle temp(r);
 
 	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* body_code=&params.as_junction(2, "body must be code");
-	Value* delim_maybe_code=params.count()>3?&params[3]:0;
+	Value* delim_maybe_code=params.count()>3 ? &params[3] : 0;
 	Value& caller=*r.get_method_frame()->caller();
 
 	if(key_var_name->is_empty()) key_var_name=0;
@@ -168,19 +410,6 @@ static void _foreach(Request& r, MethodP
 	}
 }
 
-
-enum AtResultType {
-	AtResultTypeValue = 0,
-	AtResultTypeKey = 1,
-	AtResultTypeHash = 2
-};
-
-inline 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 Array_seq_item : public PA_Allocated {
 	Value *array_data;
@@ -220,7 +449,7 @@ static void _sort(Request& r, MethodPara
 
 	VArray& self=GET_SELF(r, VArray);
 	ArrayValue& array=self.array();
-	int count=self.count(); // not array.count()
+	int count=array.used(); // not array.count()
 
 	Array_seq_item* seq=new Array_seq_item[count];
 	int pos=0;
@@ -266,10 +495,22 @@ static void _sort(Request& r, MethodPara
 	delete[] seq;
 }
 
+enum AtResultType {
+	AtResultTypeValue = 0,
+	AtResultTypeKey = 1,
+	AtResultTypeHash = 2
+};
+
+inline Value& SingleElementHash(String::Body akey, Value* avalue) {
+	Value& result=*new VHash;
+	result.put_element(*new String(akey, String::L_TAINTED), avalue);
+	return result;
+}
+
 static void _at(Request& r, MethodParams& params) {
 	VArray& self=GET_SELF(r, VArray);
 	ArrayValue& array=self.array();
-	size_t count=self.count();
+	size_t count=array.used(); // not array.count()
 
 	int pos=0;
 
@@ -368,30 +609,29 @@ static void _select(Request& r, MethodPa
 	ArrayValue& result_array=result->array();
 
 	if(limit>0){
-
 		if(reverse){
 			for(ArrayValue::ReverseIterator i(source_array); i; ){
-				Value *value=i.prev(); // here for correct i.key()
-				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, value);
-
-				bool condition=r.process(vcondition).as_bool();
+				if(Value *value=i.prev()){ // here for correct i.key()
+					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, value);
 
-				if(r.check_skip_break())
-					break;
+					bool condition=r.process(vcondition).as_bool();
 
-				if(condition){
-					result_array+=value;
-					if(!--limit)
+					if(r.check_skip_break())
 						break;
+
+					if(condition){
+						result_array+=value;
+						if(!--limit)
+							break;
+					}
 				}
 			}
 		} else {
 			for(ArrayValue::Iterator i(source_array); i; i.next() ){
-				Value *value=i.value();
-				if(value){
+				if(Value *value=i.value()){
 					if(key_var_name)
 						r.put_element(caller, *key_var_name, new VString(*new String(i.key(), String::L_TAINTED)));
 					if(value_var_name)
@@ -416,52 +656,52 @@ static void _select(Request& r, MethodPa
 }
 
 static void _reverse(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& source_array=self.array();
-	size_t count=source_array.count();
+	ArrayValue& source_array=GET_SELF(r, VArray).array();
 
-	VArray& result=*new VArray(count);
+	VArray& result=*new VArray(source_array.count());
 	ArrayValue& result_array=result.array();
 
-	for(ArrayValue::Iterator i(source_array); i; ){
-		Value *v=i.next();
-		if(v){
-			result_array.fit(count-i.index() /* no -1 as .next() is called */, v);
-		}
+	for(ArrayValue::ReverseIterator i(source_array); i; ){
+		result_array+=i.prev();
 	}
 
 	r.write(result);
 }
 
 
-static void _rename(Request& r, MethodParams& params) {}
-
 // constructor
 
 MArray::MArray(): Methoded(VARRAY_TYPE) {
-//	set_base(hash_class);
 
 	// ^array::create[[copy_from]]
 	add_native_method("create", Method::CT_DYNAMIC, _create_or_add, 0, 1);
 	// ^array.add[add_from]
 	add_native_method("add", Method::CT_DYNAMIC, _create_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);
-	// ^a.union[b] = array
-	add_native_method("union", Method::CT_DYNAMIC, _union, 1, 1);
-	// ^a.intersection[b][options array] = array
-	add_native_method("intersection", Method::CT_DYNAMIC, _intersection, 1, 2);
-	// ^a.intersects[b] = bool
-	add_native_method("intersects", Method::CT_DYNAMIC, _intersects, 1, 1);
+	// ^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::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);
 
-	// ^a.delete[key]
+	// ^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);
 
-	// ^a.contains[key]
+	// ^array.contains[index]
 	add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);
-	// backward
-	add_native_method("contain", Method::CT_DYNAMIC, _contains, 1, 1);
 
 	// ^array::sql[query][options array]
 	add_native_method("sql", Method::CT_DYNAMIC, _sql, 1, 2);
@@ -469,30 +709,28 @@ MArray::MArray(): Methoded(VARRAY_TYPE)
 	// ^array._keys[[column name]]
 	add_native_method("_keys", Method::CT_DYNAMIC, _keys, 0, 1);
 
-	// ^array._count[]
-	add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 0);
+	// ^array._count[[all]]
+	add_native_method("_count", Method::CT_DYNAMIC, _count, 0, 1);
 
-	// ^array.foreach[key;value]{code}[delim]
-	add_native_method("foreach", Method::CT_DYNAMIC, _foreach, 2+1, 2+1+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, 3, 3+1);
 
-	// ^array.sort[key;value]{string-key-maker}[[asc|desc]]
-	// ^array.sort[key;value](numeric-key-maker)[[asc|desc]]
+	// ^array.sort[index;value]{string-key-maker}[[asc|desc]]
+	// ^array.sort[index;value](numeric-key-maker)[[asc|desc]]
 	add_native_method("sort", Method::CT_DYNAMIC, _sort, 3, 4);
 
-	// ^array.select[key;value](bool-condition)[options array]
+	// ^array.select[index;value](bool-condition)[options hash]
 	add_native_method("select", Method::CT_DYNAMIC, _select, 3, 4);
 
 	// ^array.reverse[]
 	add_native_method("reverse", Method::CT_DYNAMIC, _reverse, 0, 0);
 
-	// ^array._at[first|last[;'key'|'value'|'array']]
-	// ^array._at([-+]offset)[['key'|'value'|'array']]
+	// ^array._at[first|last[;'key'|'value'|'hash']]
+	// ^array._at([-+]offset)[['key'|'value'|'hash']]
 	add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);
 
-	// ^array.rename[from;to]
-	// ^array.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);