strlen elimination

Author: braindigitalis

.idea/.name

@@ -65,6 +65,7 @@ int64_t basic_get_int_array_variable(const char* var, int64_t index, struct basi
  * @param var The variable name.
  * @param index The index in the array.
  * @param ctx The BASIC context.
+ * @param out_len
  * @return The value at the specified index.
  */
 const char* basic_get_string_array_variable(const char* var, int64_t index, struct basic_ctx* ctx, size_t* out_len);
@@ -75,6 +76,7 @@ const char* basic_get_string_array_variable(const char* var, int64_t index, stru
  * @param var The variable name.
  * @param size The size of the array.
  * @param ctx The BASIC context.
+ * @param var_length
  * @return True if the array was successfully dimensioned, false otherwise.
  */
 bool basic_dim_string_array(const char* var, int64_t size, struct basic_ctx* ctx, size_t var_length);
@@ -85,6 +87,7 @@ bool basic_dim_string_array(const char* var, int64_t size, struct basic_ctx* ctx
  * @param var The variable name.
  * @param size The size of the array.
  * @param ctx The BASIC context.
+ * @param var_length
  * @return True if the array was successfully dimensioned, false otherwise.
  */
 bool basic_dim_int_array(const char* var, int64_t size, struct basic_ctx* ctx, size_t var_length);
@@ -95,6 +98,7 @@ bool basic_dim_int_array(const char* var, int64_t size, struct basic_ctx* ctx, s
  * @param var The variable name.
  * @param size The size of the array.
  * @param ctx The BASIC context.
+ * @param var_length
  * @return True if the array was successfully dimensioned, false otherwise.
  */
 bool basic_dim_double_array(const char* var, int64_t size, struct basic_ctx* ctx, size_t var_length);

include/basic/array.h

@@ -356,6 +356,13 @@ typedef struct basic_ctx {
 	 */
 	void* fn_return;
 
+	/**
+	 * @brief When the return value in fn_return is RT_STRING, this contains the length of that string.
+	 *
+	 * At all other times it contains 0.
+	 */
+	size_t fn_return_len;
+
 	/**
 	 * @brief Current graphics color for graphical operations (e.g., drawing lines, shapes).
 	 */
@@ -613,9 +620,10 @@ void basic_eval_double_fn(const char* fn_name, struct basic_ctx* ctx, double* re
  *
  * @param fn_name The name of the function to evaluate.
  * @param ctx The BASIC context.
+ * @param out_len
  * @return The evaluated string result of the function.
  */
-const char* basic_eval_str_fn(const char* fn_name, struct basic_ctx* ctx);
+const char* basic_eval_str_fn(const char* fn_name, struct basic_ctx* ctx, size_t* out_len);
 
 /**
  * @brief Check if a function name corresponds to a built-in double (floating-point) function.
@@ -664,9 +672,10 @@ void free_local_heap(struct basic_ctx* ctx);
  * @brief Check if a function name corresponds to a built-in double (floating-point) function.
  *
  * @param fn_name The name of the function to check.
+ * @param L
  * @return True if the function is a built-in double function, false otherwise.
  */
-bool is_builtin_double_fn(const char* fn_name);
+bool is_builtin_double_fn(const char* fn_name, size_t L);
 
 /**
  * @brief Free function definitions and associated resources in the BASIC context.

include/basic/context.h

@@ -157,7 +157,8 @@ typedef enum ub_return_type {
  * containing the name of the parameter and a pointer to the next parameter.
  */
 typedef struct ub_param {
-	const char *name; ///< Name of the parameter
+	const char *name; ///< Name of the parameter variable
+	size_t name_len; ///< Length of parameter variable name
 	struct ub_param *next; ///< Pointer to the next parameter
 } ub_param;
 

include/basic/structs.h

@@ -236,6 +236,8 @@ typedef struct cpu_caps {
 	char vendor[13];
 	/** @brief CPU brand string */
 	char brand[49];
+	/** @brief Length of brand string */
+	size_t brand_len;
 	/** @brief True if a hypervisor is present */
 	bool hypervisor_present;
 	/** @brief Hypervisor vendor string */

include/rr-cpuid.h

@@ -9,8 +9,6 @@
 
 extern bool debug;
 
-/* Add near the top of basic/function.c, after extern bool debug */
-
 struct builtin_int_entry {
 	const char *name;
 	size_t name_length;
@@ -395,7 +393,7 @@ bool extract_comma_list(struct ub_proc_fn_def* def, struct basic_ctx* ctx, int*
 		ctx->current_token = get_next_token(ctx);
 		*oldptr = 0;
 		if (*param && (*param)->name) {
-			size_t len = strlen((*param)->name);
+			size_t len = (*param)->name_len;
 			if ((*param)->name[len - 1] == '$') {
 				const char* save_ptr = ctx->ptr;
 				size_t v_len;
@@ -429,10 +427,11 @@ bool extract_comma_list(struct ub_proc_fn_def* def, struct basic_ctx* ctx, int*
 	return true;
 }
 
-const char* basic_eval_str_fn(const char* fn_name, struct basic_ctx* ctx)
+const char* basic_eval_str_fn(const char* fn_name, struct basic_ctx* ctx, size_t* out_len)
 {
 	struct ub_proc_fn_def* def = basic_find_fn(fn_name + 2, ctx);
 	const char* rv = "";
+	*out_len = 0;
 	if (def) {
 		if (!new_stack_frame(ctx)) {
 			return "";
@@ -480,6 +479,7 @@ const char* basic_eval_str_fn(const char* fn_name, struct basic_ctx* ctx)
 			if (!rv) {
 				return "";
 			}
+			*out_len = atomic->fn_return_len;
 		}
 
 		ctx->int_variables           = atomic->int_variables;
@@ -819,7 +819,7 @@ bool basic_parse_fn(struct basic_ctx* ctx)
 				tokenizer_error_printf(ctx, "Out of memory parsing functions");
 				return false;
 			}
-			def.name_length = strlen(name);
+			def.name_length = ni;
 			def.type = type;
 			def.line = currentline;
 			def.params = NULL;
@@ -842,6 +842,7 @@ bool basic_parse_fn(struct basic_ctx* ctx)
 							return false;
 						}
 						par->next = NULL;
+						par->name_len = pni;
 						par->name = buddy_strdup(ctx->allocator, pname);
 						if (!par->name) {
 							tokenizer_error_printf(ctx, "Out of memory parsing function parameters");
@@ -926,15 +927,9 @@ void basic_free_defs(struct basic_ctx* ctx)
 	ctx->defs = NULL;
 }
 
-bool is_builtin_double_fn(const char* fn_name)
+bool is_builtin_double_fn(const char* fn_name, size_t L)
 {
-	struct builtin_double_entry key = {
-		.name = fn_name,
-		.name_length = strlen(fn_name),
-		.handler = NULL
-	};
-
-	return hashmap_get(builtin_double_map, &key) != NULL;
+	return hashmap_get(builtin_double_map, &(struct builtin_double_entry){ .name = fn_name, .name_length = L, .handler = NULL }) != NULL;
 }
 
 void proc_statement(struct basic_ctx* ctx)
@@ -1017,9 +1012,10 @@ void eq_statement(struct basic_ctx* ctx)
 	basic_debug("eq_statement\n");
 	accept_or_return(EQUALS, ctx);
 
+	ctx->fn_return_len = 0;
 	if (ctx->fn_type == RT_STRING) {
 		basic_debug("eq_statement return string\n");
-		ctx->fn_return = (void*)str_expr(ctx, NULL);
+		ctx->fn_return = (void*)str_expr(ctx, &ctx->fn_return_len);
 	} else if (ctx->fn_type == RT_FLOAT) {
 		basic_debug("eq_statement return double\n");
 		double_expr(ctx, (void*)&ctx->fn_return);
@@ -1033,8 +1029,6 @@ void eq_statement(struct basic_ctx* ctx)
 		dprintf("EQ statement: fn type??? %d\n", ctx->fn_type);
 	}
 
-	//accept_or_return(NEWLINE, ctx);
-
 	ctx->ended = true;
 }
 

src/basic/function.c

@@ -172,21 +172,8 @@ int64_t basic_memfind(struct basic_ctx* ctx)
 
 char* basic_cpugetbrand(struct basic_ctx* ctx, size_t* out_len)
 {
-	PARAMS_START;
-	PARAMS_GET_ITEM(BIP_INT);
-	bool trim = intval;
-	PARAMS_END("CPUGETBRAND$", "");
-
-	const char *bufferp = cpu_caps.brand;
-
-	if (trim) {
-		while (*bufferp == ' ') {
-			bufferp++;
-		}
-	}
-
-	*out_len = strlen(bufferp);
-	return (char *)gc_strdup(ctx, bufferp);
+	*out_len = cpu_caps.brand_len;
+	return (char *)gc_strdup(ctx, cpu_caps.brand);
 }
 
 char* basic_cpugetvendor(struct basic_ctx* ctx, size_t* out_len)

src/basic/lowlevel.c

@@ -326,10 +326,11 @@ struct basic_ctx *basic_init(const char *program, uint32_t pid, const char *file
 	ctx->double_array_variables = hashmap_new_with_allocator(varmap_malloc, varmap_realloc, varmap_free, sizeof(struct ub_var_double_array), 0, SEED0, SEED1, varmap_hash, varmap_compare, varmap_elfree_double_array, ctx->allocator);
 	ctx->oldlen = 0;
 	ctx->fn_return = NULL;
+	ctx->fn_return_len = 0;
 	memset(ctx->fn_type_stack, 0, sizeof(ctx->fn_type_stack));
-	memset(ctx->local_int_variables, NULL, sizeof(ctx->local_int_variables));
-	memset(ctx->local_string_variables, NULL, sizeof(ctx->local_string_variables));
-	memset(ctx->local_double_variables, NULL, sizeof(ctx->local_double_variables));
+	memset(ctx->local_int_variables, 0, sizeof(ctx->local_int_variables));
+	memset(ctx->local_string_variables, 0, sizeof(ctx->local_string_variables));
+	memset(ctx->local_double_variables, 0, sizeof(ctx->local_double_variables));
 	// We allocate 5000 bytes extra on the end of the program for EVAL space,
 	// as EVAL appends to the program on lines EVAL_LINE and EVAL_LINE + 1.
 	ctx->program_ptr = buddy_malloc(ctx->allocator, strlen(program) + 5000);
@@ -589,6 +590,7 @@ struct basic_ctx *basic_clone(struct basic_ctx *old) {
 	ctx->sounds = old->sounds;
 	ctx->oldlen = old->oldlen;
 	ctx->fn_return = NULL;
+	ctx->fn_return_len = 0;
 	ctx->program_ptr = old->program_ptr;
 	ctx->for_stack_ptr = old->for_stack_ptr;
 	ctx->call_stack_ptr = old->call_stack_ptr;

src/basic/main.c

@@ -88,9 +88,9 @@ struct hashmap *basic_get_map_by_handle(struct basic_ctx *ctx, int64_t handle)
 	return found->map;
 }
 
-map_value_t *basic_get_map_value(struct hashmap *map, const char *key)
+static map_value_t *basic_get_map_value(struct hashmap *map, const char *key, size_t key_len)
 {
-	return hashmap_get(map, &(map_value_t){ .name = key, .name_length = strlen(key) });
+	return hashmap_get(map, &(map_value_t){ .name = key, .name_length = key_len });
 }
 
 void basic_free_map_up_value(struct basic_ctx *ctx, up_value *value)
@@ -161,7 +161,7 @@ int64_t basic_maphas(struct basic_ctx *ctx)
 		return 0;
 	}
 
-	return basic_get_map_value(map, key) ? 1 : 0;
+	return basic_get_map_value(map, key, strlength) ? 1 : 0;
 }
 
 int64_t basic_mapget(struct basic_ctx *ctx)
@@ -181,7 +181,7 @@ int64_t basic_mapget(struct basic_ctx *ctx)
 		return 0;
 	}
 
-	entry = basic_get_map_value(map, key);
+	entry = basic_get_map_value(map, key, strlength);
 	if (!entry) {
 		tokenizer_error_printf(ctx, "No such MAP key '%s'", key);
 		return 0;
@@ -213,7 +213,7 @@ void basic_mapgetr(struct basic_ctx *ctx, double* rv)
 		return;
 	}
 
-	entry = basic_get_map_value(map, key);
+	entry = basic_get_map_value(map, key, strlength);
 	if (!entry) {
 		tokenizer_error_printf(ctx, "No such MAP key '%s'", key);
 		*rv = 0;
@@ -250,7 +250,7 @@ char *basic_mapgets(struct basic_ctx *ctx, size_t* out_len)
 		return "";
 	}
 
-	map_value_t* entry = basic_get_map_value(map, key);
+	map_value_t* entry = basic_get_map_value(map, key, strlength);
 	if (!entry) {
 		tokenizer_error_printf(ctx, "No such MAP key '%s'", key);
 		return "";
@@ -267,23 +267,19 @@ char *basic_mapgets(struct basic_ctx *ctx, size_t* out_len)
 
 void mapset_statement(struct basic_ctx *ctx)
 {
-	int64_t handle;
-	const char *key;
-	struct hashmap *map;
-	map_value_t *found;
 	map_value_t new_entry;
 	up_value value;
 
 	accept_or_return(MAPSET, ctx);
-	handle = expr(ctx);
+	int64_t handle = expr(ctx);
 	accept_or_return(COMMA, ctx);
 	size_t elen;
-	key = str_expr(ctx, &elen);
+	const char* key = str_expr(ctx, &elen);
 	accept_or_return(COMMA, ctx);
 	up_eval_value(ctx, &value);
 	accept_or_return(NEWLINE, ctx);
 
-	map = basic_get_map_by_handle(ctx, handle);
+	struct hashmap* map = basic_get_map_by_handle(ctx, handle);
 	if (!map) {
 		tokenizer_error_print(ctx, "Invalid MAP");
 		return;
@@ -298,7 +294,7 @@ void mapset_statement(struct basic_ctx *ctx)
 		value.v.s.ptr = dup;
 	}
 
-	found = basic_get_map_value(map, key);
+	map_value_t* found = basic_get_map_value(map, key, elen);
 	if (found) {
 		if (found->value.kind != value.kind) {
 			if (!(found->value.kind == UP_INT && value.kind == UP_REAL)) {
@@ -330,7 +326,7 @@ void mapset_statement(struct basic_ctx *ctx)
 
 	memset(&new_entry, 0, sizeof(new_entry));
 	new_entry.name = buddy_strdup(ctx->allocator, key);
-	new_entry.name_length = strlen(key);
+	new_entry.name_length = elen;
 	if (!new_entry.name) {
 		basic_free_map_up_value(ctx, &value);
 		tokenizer_error_print(ctx, "Out of memory");
@@ -356,7 +352,6 @@ void mapset_statement(struct basic_ctx *ctx)
 
 void mapfree_statement(struct basic_ctx *ctx)
 {
-	basic_map_handle_entry *found;
 
 	accept_or_return(MAPFREE, ctx);
 	int64_t handle = expr(ctx);
@@ -367,7 +362,7 @@ void mapfree_statement(struct basic_ctx *ctx)
 		return;
 	}
 
-	found = hashmap_delete(ctx->maps, &(basic_map_handle_entry){ .id = handle});
+	basic_map_handle_entry* found = hashmap_delete(ctx->maps, &(basic_map_handle_entry){.id = handle});
 	if (!found) {
 		tokenizer_error_print(ctx, "Invalid MAP");
 		return;

src/basic/map.c

@@ -129,7 +129,7 @@ static up_value up_factor(struct basic_ctx *ctx) {
 				return up_make_real(d);
 			}
 
-			if (is_builtin_double_fn(name)) {
+			if (is_builtin_double_fn(name, L)) {
 				/* Unsuffixed builtin known to return REAL */
 				double d = 0.0;
 				basic_get_numeric_variable(name, ctx, &d);