added hawk::cap(), hawk::size()

lib/Hawk.cpp

@@ -850,13 +850,76 @@ int Hawk::Value::setMbs (Run* r, const hawk_bch_t* str)
 	return n;
 }
 
-int Hawk::Value::setArrayVal (hawk_ooi_t idx, hawk_val_t* v)
+///////////////////////////////////////////////////////////////////
+int Hawk::Value::scaleArrayed (hawk_ooi_t size)
 {
 	if (HAWK_UNLIKELY(!this->run)) return -1;
-	return this->setArrayVal(this->run, idx, v);
+	return this->scaleArrayed(this->run, size);
 }
 
-int Hawk::Value::setArrayVal (Run* r, hawk_ooi_t idx, hawk_val_t* v)
+int Hawk::Value::scaleArrayed (Run* r, hawk_ooi_t size)
+{
+	HAWK_ASSERT (r != HAWK_NULL);
+
+	if (HAWK_RTX_GETVALTYPE(r->rtx, this->val) != HAWK_VAL_ARR)
+	{
+		// the previous value is not a arr.
+		// a new arr value needs to be created first.
+		hawk_val_t* arr = hawk_rtx_makearrval(r->rtx, size); // TODO: can we change this to accept the initial value in the constructor
+		if (arr == HAWK_NULL)
+		{
+			r->hawk->retrieveError (r);
+			return -1;
+		}
+
+		hawk_rtx_refupval(r->rtx, arr);
+
+		// free the previous value
+		if (this->run)
+		{
+			// if val is not nil, this->run can't be NULL
+			hawk_rtx_refdownval(this->run->rtx, this->val);
+		}
+
+		this->run = r;
+		this->val = arr;
+	}
+	else
+	{
+		HAWK_ASSERT (run != HAWK_NULL);
+
+		// if the previous value is a arr, things are a bit simpler
+		// however it needs to check if the runtime context matches
+		// with the previous one.
+		if (this->run != r)
+		{
+			// it can't span across multiple runtime contexts
+			this->run->setError(HAWK_EINVAL);
+			this->run->hawk->retrieveError (run);
+			return -1;
+		}
+
+/* TODO: RESIZE THE EXISTING ARRAY...
+		// update the arr with a given value
+		if (hawk_rtx_setarrvalfld(r->rtx, val, idx, v) == HAWK_NULL)
+		{
+			r->hawk->retrieveError (r);
+			return -1;
+		}
+*/
+	}
+
+	return 0;
+}
+
+
+int Hawk::Value::setArrayedVal (hawk_ooi_t idx, hawk_val_t* v)
+{
+	if (HAWK_UNLIKELY(!this->run)) return -1;
+	return this->setArrayedVal(this->run, idx, v);
+}
+
+int Hawk::Value::setArrayedVal (Run* r, hawk_ooi_t idx, hawk_val_t* v)
 {
 	HAWK_ASSERT (r != HAWK_NULL);
 
@@ -917,6 +980,40 @@ int Hawk::Value::setArrayVal (Run* r, hawk_ooi_t idx, hawk_val_t* v)
 	return 0;
 }
 
+bool Hawk::Value::isArrayed () const
+{
+	HAWK_ASSERT (val != HAWK_NULL);
+	return HAWK_RTX_GETVALTYPE(this->run->rtx, val) == HAWK_VAL_ARR;
+}
+
+
+int Hawk::Value::getArrayed (hawk_ooi_t idx, Value* v) const
+{
+	HAWK_ASSERT (val != HAWK_NULL);
+
+	// not a map. v is just nil. not an error
+	if (HAWK_RTX_GETVALTYPE(this->run->rtx, val) != HAWK_VAL_ARR)
+	{
+		v->clear ();
+		return 0;
+	}
+
+	// get the value from the map.
+	hawk_val_t* fv = hawk_rtx_getarrvalfld(this->run->rtx, val, idx);
+
+	// the key is not found. it is not an error. v is just nil
+	if (fv == HAWK_NULL)
+	{
+		v->clear ();
+		return 0;
+	}
+
+	// if v.set fails, it should return an error
+	return v->setVal(this->run, fv);
+}
+
+///////////////////////////////////////////////////////////////////
+
 int Hawk::Value::setIndexedVal (const Index& idx, hawk_val_t* v)
 {
 	if (HAWK_UNLIKELY(!this->run)) return -1;

lib/Hawk.hpp

@@ -1076,8 +1076,17 @@ public:
 		int setMbs (const hawk_bch_t* str);
 		int setMbs (Run* r, const hawk_bch_t* str);
 
-		int setArrayVal (hawk_ooi_t idx, hawk_val_t* v);
+		int setArrayedVal (hawk_ooi_t idx, hawk_val_t* v);
-		int setArrayVal (Run* r, hawk_ooi_t idx, hawk_val_t* v);
+		int setArrayedVal (Run* r, hawk_ooi_t idx, hawk_val_t* v);
+
+		int scaleArrayed (hawk_ooi_t size);
+		int scaleArrayed (Run* r, hawk_ooi_t size);
+
+		bool isArrayed () const;
+		int getArrayed (
+			hawk_ooi_t    idx, ///< array index
+			Value*        val  ///< value holder
+		) const;
 
 		int setIndexedVal (const Index& idx, hawk_val_t* v);
 		int setIndexedVal (Run* r, const Index& idx, hawk_val_t* v);
@@ -1102,7 +1111,7 @@ public:
 		int setIndexedMbs (Run* r, const Index&  idx, const hawk_bch_t* str);
 
 		///
-		/// The isIndexed() function determines if a value is arrayed.
+		/// The isIndexed() function determines if a value is a map.
 		/// \return true if indexed, false if not.
 		///
 		bool isIndexed () const;
@@ -1113,7 +1122,7 @@ public:
 		/// \return 0 on success, -1 on failure
 		///
 		int getIndexed (
-			const Index&  idx, ///< array index
+			const Index&  idx, ///< map index
 			Value*        val  ///< value holder
 		) const;
 

lib/fnc-prv.h

@@ -58,7 +58,7 @@ hawk_fnc_t* hawk_findfncwithucs (hawk_t* hawk, const hawk_ucs_t* name);
 /* EXPORT is required for linking on windows as they are referenced by mod-str.c */
 HAWK_EXPORT int hawk_fnc_gsub    (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 HAWK_EXPORT int hawk_fnc_index   (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
-HAWK_EXPORT int hawk_fnc_length  (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
+HAWK_EXPORT int hawk_fnc_length  (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int mode);
 HAWK_EXPORT int hawk_fnc_match   (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 HAWK_EXPORT int hawk_fnc_rindex  (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 HAWK_EXPORT int hawk_fnc_split   (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);

lib/fnc.c

@@ -24,11 +24,12 @@
 
 #include "hawk-prv.h"
 
+static int fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
+static int fnc_asorti (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 static int fnc_close (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 static int fnc_fflush (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 static int fnc_int (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
-static int fnc_asort (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
+static int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
-static int fnc_asorti (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 static int fnc_match (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi);
 
 #define A_MAX HAWK_TYPE_MAX(hawk_oow_t)
@@ -61,7 +62,7 @@ static hawk_fnc_t sysfnctab[] =
 	/* string functions */
 	{ {HAWK_T("gsub"),     4}, 0, { {2,     3, HAWK_T("xvr")},    hawk_fnc_gsub,     0 }, HAWK_NULL},
 	{ {HAWK_T("index"),    5}, 0, { {2,     3, HAWK_NULL},        hawk_fnc_index,    0 }, HAWK_NULL},
-	{ {HAWK_T("length"),   6}, 1, { {0,     1, HAWK_NULL},        hawk_fnc_length,   0 }, HAWK_NULL},
+	{ {HAWK_T("length"),   6}, 1, { {0,     1, HAWK_NULL},        fnc_length,        0 }, HAWK_NULL},
 	{ {HAWK_T("match"),    5}, 0, { {2,     3, HAWK_T("vxr")},    fnc_match,         0 }, HAWK_NULL},
 	{ {HAWK_T("split"),    5}, 0, { {2,     3, HAWK_T("vrx")},    hawk_fnc_split,    0 }, HAWK_NULL},
 	{ {HAWK_T("sprintf"),  7}, 0, { {1, A_MAX, HAWK_NULL},        hawk_fnc_sprintf,  0 }, HAWK_NULL},
@@ -677,7 +678,7 @@ int hawk_fnc_rindex (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 	return index_or_rindex(rtx, 1);
 }
 
-int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi, int mode)
 {
 	hawk_oow_t nargs;
 	hawk_val_t* v;
@@ -703,11 +704,37 @@ int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			case HAWK_VAL_MAP:
 				/* map size */
 				len = HAWK_MAP_SIZE(((hawk_val_map_t*)v)->map);
+				switch (mode)
+				{
+					case 2: /* capacity */
+						len = hawk_map_getcapa(((hawk_val_map_t*)v)->map);
+						break;
+
+					case 1: /* size */
+					case 0: /* length */
+					default:
+						len = HAWK_MAP_SIZE(((hawk_val_map_t*)v)->map);
+						break;
+				}
 				break;
 
 			case HAWK_VAL_ARR: /* returns the number of set items instead of the last index + 1 */
+				switch (mode)
+				{
+					case 2: /* capacity */
+						len = HAWK_ARR_SIZE(((hawk_val_arr_t*)v)->arr);
+						break;
+
+					case 1: /* size */
+						len = HAWK_ARR_SIZE(((hawk_val_arr_t*)v)->arr);
+						break;
+
+					case 0: /* length */
+					default:
 						len = HAWK_ARR_TALLY(((hawk_val_arr_t*)v)->arr);
 						break;
+				}
+				break;
 
 			case HAWK_VAL_BCHR:
 				len = 1;
@@ -729,18 +756,23 @@ int hawk_fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 			default:
 				/* convert to string and get length */
 				str = hawk_rtx_valtooocstrdup(rtx, v, &len);
-				if (!str) return -1;
+				if (HAWK_UNLIKELY(!str)) return -1;
 				hawk_rtx_freemem(rtx, str);
 		}
 	}
 
 	v = hawk_rtx_makeintval(rtx, len);
-	if (!v) return -1;
+	if (HAWK_UNLIKELY(!v)) return -1;
 
 	hawk_rtx_setretval(rtx, v);
 	return 0;
 }
 
+int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	return hawk_fnc_length(rtx, fi, 0);
+}
+
 int hawk_fnc_substr (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
 	hawk_oow_t nargs;

lib/mod-hawk.c

@@ -339,6 +339,24 @@ static int fnc_gcrefs (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 
 /* -------------------------------------------------------------------------- */
 
+static int fnc_cap (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	/* capacity */
+	return hawk_fnc_length (rtx, fi, 2);
+}
+
+static int fnc_size (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	/* similar to length, but it returns the ubound + 1 for the array */
+	return hawk_fnc_length (rtx, fi, 1);
+}
+
+static int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	return hawk_fnc_length (rtx, fi, 0);
+}
+/* -------------------------------------------------------------------------- */
+
 static int fnc_array (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
 	hawk_val_t* tmp;
@@ -521,6 +539,7 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	/* keep this table sorted for binary search in query(). */
 	{ HAWK_T("array"),            { { 0, A_MAX, HAWK_NULL     },  fnc_array,                 0 } },
 	{ HAWK_T("call"),             { { 1, A_MAX, HAWK_T("vR")  },  fnc_call,                  0 } },
+	{ HAWK_T("cap"),              { { 1, 1,     HAWK_NULL     },  fnc_cap,                   0 } },
 	{ HAWK_T("cmgr_exists"),      { { 1, 1,     HAWK_NULL     },  fnc_cmgr_exists,           0 } },
 	{ HAWK_T("function_exists"),  { { 1, 1,     HAWK_NULL     },  fnc_function_exists,       0 } },
 	{ HAWK_T("gc"),               { { 0, 1,     HAWK_NULL     },  fnc_gc,                    0 } },
@@ -532,8 +551,10 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("isarray"),          { { 1, 1,     HAWK_NULL     },  fnc_isarr,                 0 } },
 	{ HAWK_T("ismap"),            { { 1, 1,     HAWK_NULL     },  fnc_ismap,                 0 } },
 	{ HAWK_T("isnil"),            { { 1, 1,     HAWK_NULL     },  fnc_isnil,                 0 } },
+	{ HAWK_T("length"),           { { 1, 1,     HAWK_NULL     },  fnc_length,                0 } },
 	{ HAWK_T("map"),              { { 0, A_MAX, HAWK_NULL     },  fnc_map,                   0 } },
 	{ HAWK_T("modlibdirs"),       { { 0, 0,     HAWK_NULL     },  fnc_modlibdirs,            0 } },
+	{ HAWK_T("size"),             { { 1, 1,     HAWK_NULL     },  fnc_size,                  0 } },
 	{ HAWK_T("type"),             { { 1, 1,     HAWK_NULL     },  fnc_type,                  0 } },
 	{ HAWK_T("typename"),         { { 1, 1,     HAWK_NULL     },  fnc_typename,              0 } }
 };

lib/mod-str.c

@@ -25,6 +25,11 @@
 #include "mod-str.h"
 #include "hawk-prv.h"
 
+static int fnc_length (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
+{
+	return hawk_fnc_length(rtx, fi, 0);
+}
+
 static int fnc_normspace (hawk_rtx_t* rtx, const hawk_fnc_info_t* fi)
 {
 	/* normalize spaces
@@ -763,7 +768,7 @@ static hawk_mod_fnc_tab_t fnctab[] =
 	{ HAWK_T("isspace"),       { { 1, 1, HAWK_NULL },      fnc_isspace,           0 } },
 	{ HAWK_T("isupper"),       { { 1, 1, HAWK_NULL },      fnc_isupper,           0 } },
 	{ HAWK_T("isxdigit"),      { { 1, 1, HAWK_NULL },      fnc_isxdigit,          0 } },
-	{ HAWK_T("length"),        { { 1, 1, HAWK_NULL },      hawk_fnc_length,       0 } },
+	{ HAWK_T("length"),        { { 1, 1, HAWK_NULL },      fnc_length,            0 } },
 	{ HAWK_T("ltrim"),         { { 1, 1, HAWK_NULL },      fnc_ltrim,             0 } },
 	{ HAWK_T("match"),         { { 2, 4, HAWK_T("vxvr") }, hawk_fnc_match,        0 } },
 	{ HAWK_T("normspace"),     { { 1, 1, HAWK_NULL },      fnc_normspace,         0 } }, /* deprecated, use trim("xxx", str::TRIM_PAC_SPACES) */