--- parser3/src/classes/array.C	2024/10/04 05:12:05	1.17
+++ parser3/src/classes/array.C	2024/10/27 13:53:08	1.29
@@ -17,7 +17,7 @@
 #include "pa_vbool.h"
 #include "pa_vmethod_frame.h"
 
-volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.17 2024/10/04 05:12:05 moko Exp $";
+volatile const char * IDENT_ARRAY_C="$Id: array.C,v 1.29 2024/10/27 13:53:08 moko Exp $";
 
 // class
 
@@ -38,7 +38,7 @@ const char* const PARAM_INDEX = "index m
 
 // methods
 
-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);
@@ -63,7 +63,7 @@ static void _create_or_add(Request& r, M
 				self_array.put(VArray::index(i.key()), i.value());
 			}
 		}
-		self.invalidate();
+		self_array.invalidate();
 	}
 }
 
@@ -145,7 +145,7 @@ static void _join(Request& r, MethodPara
 			}
 		}
 	}
-	self.invalidate();
+	self_array.invalidate();
 }
 
 #ifndef DOXYGEN
@@ -494,7 +494,9 @@ static void _sql(Request& r, MethodParam
 	VArray& self=GET_SELF(r, VArray);
 	ArrayValue& array=self.array();
 
-	array.clear(); self.invalidate(); // just in case if called as method
+	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);
@@ -544,7 +546,7 @@ static void _right(Request& r, MethodPar
 
 	if(sn>0){
 		size_t used=GET_SELF(r, VArray).array().used();
-		if(sn<used){
+		if((size_t)sn<used){
 			mid(r, used-sn, sn);
 		} else {
 			mid(r);
@@ -555,15 +557,11 @@ static void _right(Request& r, MethodPar
 }
 
 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);
+
 	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)
@@ -610,44 +608,63 @@ 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; i<count; i++){
-		array+=&r.process(params[i]);
+	if(array.count()){
+		for(int i=0; i<count; i++){
+			array+=&r.process(params[i]);
+			array.change_used(+1); // after each element, since an exception can occur
+		}
+	} 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) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& array=self.array();
+	ArrayValue& array=GET_SELF(r, VArray).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]));
+		array.change_used(+1); // after each element, since an exception can occur
 	}
-	self.invalidate();
 }
 
 static void _delete(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	if(params.count()>0)
-		self.array().clear(VArray::index(params.as_int(0, PARAM_INDEX, r)));
-	else
-		self.array().clear();
-	self.invalidate();
+	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) {
-	VArray& self=GET_SELF(r, VArray);
-	self.array().remove(VArray::index(params.as_int(0, PARAM_INDEX, r)));
-	self.invalidate();
+	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) {
@@ -860,7 +877,7 @@ static void _sort(Request& r, MethodPara
 		for(pos=0; pos<count; pos++)
 			array+=seq[pos].array_data;
 
-	self.invalidate();
+	array.confirm_all_used();
 	delete[] seq;
 }
 
@@ -877,8 +894,7 @@ static Value& SingleElementHash(String::
 }
 
 static void _at(Request& r, MethodParams& params) {
-	VArray& self=GET_SELF(r, VArray);
-	ArrayValue& array=self.array();
+	ArrayValue& array=GET_SELF(r, VArray).array();
 	size_t count=array.used(); // not array.count()
 
 	int pos=0;
@@ -908,35 +924,35 @@ static void _at(Request& r, MethodParams
 	}
 
 	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()){
+			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 {
+			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;
 				}
+			}
 		}
 	}
 }
@@ -1025,7 +1041,7 @@ static void _select(Request& r, MethodPa
 	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());
@@ -1038,18 +1054,42 @@ 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::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.left(n)
 	add_native_method("left", Method::CT_DYNAMIC, _left, 1, 1);
 	// ^array.right(n)
@@ -1058,17 +1098,12 @@ MArray::MArray(): Methoded(VARRAY_TYPE)
 	// ^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);
-
-	// ^array.delete[index]
+	// ^array.delete(index) or ^array.delete[index]
 	add_native_method("delete", Method::CT_DYNAMIC, _delete, 0, 1);
-	// ^array.remove[index]
+	// ^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]
 	add_native_method("contains", Method::CT_DYNAMIC, _contains, 1, 1);
@@ -1097,6 +1132,9 @@ 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']]
 	add_native_method("_at", Method::CT_DYNAMIC, _at, 1, 2);