tidyups, PUSH,POP statements

Author: braindigitalis

include/tokenizer.h

@@ -118,6 +118,8 @@
 	T(UNTIL) \
 	T(DIM) \
 	T(REDIM) \
+	T(PUSH) \
+	T(POP) \
 	T(MOUNT)
 
 /*

include/ubasic.h

@@ -125,42 +125,48 @@ typedef struct ub_proc_fn_def {
  * @brief An array of integers
  */
 typedef struct ub_var_int_array {
+	uint64_t itemcount;
 	const char* varname;
 	int64_t* values;
-	uint64_t itemcount;
 	struct ub_var_int_array* next;
 } ub_var_int_array;
 
 /**
  * @brief An array of strings
  */
 typedef struct ub_var_string_array {
+	uint64_t itemcount;
 	const char* varname;
 	const char** values;
-	uint64_t itemcount;
 	struct ub_var_string_array* next;
 } ub_var_string_array;
 
 /**
  * @brief An array of real (double)
  */
 typedef struct ub_var_double_array {
+	uint64_t itemcount;
 	const char* varname;
 	double* values;
-	uint64_t itemcount;
 	struct ub_var_double_array* next;
 } ub_var_double_array;
 
+/**
+ * @brief A generic array, we can use
+ * this to represent any array regardless
+ * of its contained type.
+ */
+typedef struct ub_var_generic_array {
+	uint64_t itemcount;
+	const char* varname;
+	void* values_inaccesible;
+	struct ub_var_generic_array* next;
+} ub_var_generic_array;
+
 /**
  * @brief Line reference in program.
- * Each program has a doubly linked list of these,
- * stored in ascending order. Once we iterate the
- * list past the search number we know we don't have
- * to search any further.
- * 
- * TODO: If search number is < current line number,
- * search backwards instead and stop when previous
- * number is before search.
+ * Each program has a hashmap of these so it can find a line number
+ * in O(1) time.
  */
 typedef struct ub_line_ref {
 	uint32_t line_number;
@@ -181,61 +187,183 @@ typedef struct ub_line_ref {
 #define STRINGIFY(x) AUX(x)
 
 /**
- * @brief BASIC program context
- * Every instance of a BASIC program has one of these,
- * also certain structures such as procedures will clone
- * the context and run on the clone until the procedure
- * completes. Cloned contexts share variables and you
- * should never call ubasic_destroy() on them!
+ * @brief BASIC program context.
+ * Every instance of a BASIC program has one of these,* also certain structures
+ * such as functions will clone the context and run on the clone until the function
+ * completes. Cloned contexts share variables and you should never call
+ * ubasic_destroy() on them!
  */
 typedef struct ubasic_ctx {
+	/**
+	 * @brief Pointer to the start of the next token
+	 * Always between program_ptr and program_ptr + strlen(program_ptr)
+	 */
         char const* ptr;
+	/**
+	 * @brief Pointer to the character after the next token.
+	 * Always between program_ptr and program_ptr + strlen(program_ptr)
+	 */
 	char const* nextptr;
+	/**
+	 * @brief Numeric form of the token between ptr and nextptr.
+	 * Should always be a value within the enum token_t
+	 */
         int current_token;
+	/**
+	 * @brief Current line number
+	 */
 	int64_t current_linenum;
+	/**
+	 * @brief True if the program has thrown an error and should end.
+	 * This may not actually cause termination of the program if we are
+	 * inside an EVAL at the time.
+	 */
 	bool errored;
+	/**
+	 * @brief True if the program has ended, e.g. it reached an explicit
+	 * END statement, or fell off the end of the program to the terminating
+	 * null char.
+	 */
         bool ended;
+	/**
+	 * @brief The whole program text, untokenized.
+	 * May have been "cleaned" by an initial preprocessing phase which removes
+	 * unneccesary spacing etc.
+	 */
         char* program_ptr;
-
+	/**
+	 * @brief A context-local string buffer used for parsing function/procedure
+	 * parameter lists.
+	 */
         char string[MAX_STRINGLEN];
-
+	/**
+	 * @brief Local integer variable stack for variables declared within a
+	 * function or procedure scope.
+	 */
 	struct ub_var_int* local_int_variables[MAX_CALL_STACK_DEPTH];
+	/**
+	 * @brief Local string variable stack for variables declared within a
+	 * function or procedure scope.
+	 */
 	struct ub_var_string* local_string_variables[MAX_CALL_STACK_DEPTH];
+	/**
+	 * @brief Local real (double) variable stack for variables declared
+	 * within a function or procedure scope.
+	 */
 	struct ub_var_double* local_double_variables[MAX_CALL_STACK_DEPTH];
-
-        uint64_t gosub_stack[MAX_CALL_STACK_DEPTH];
-        uint64_t gosub_stack_ptr;
-
+	/**
+	 * @brief Call stack, holds the return line numbers for each
+	 * level of calls to a procedure, function or GOSUB
+	 */
+        uint64_t call_stack[MAX_CALL_STACK_DEPTH];
+	/**
+	 * @brief How far up the call stack we are. The call stack pointer
+	 * starts at 0, and can go as high as MAX_CALL_STACK_DEPTH - 1
+	 */
+        uint64_t call_stack_ptr;
+	/**
+	 * @brief Repeat stack, holds the return line numbers for each
+	 * level of REPEAT...UNTIL loop.
+	 */
         uint64_t repeat_stack[MAX_LOOP_STACK_DEPTH];
+	/**
+	 * @brief How far up the REPEAT...UNTIL stack we are. The repeat
+	 * stack pointer starts at 0, and can go as high as
+	 * MAX_LOOP_STACK_DEPTH - 1
+	 */
         uint64_t repeat_stack_ptr;
-
-	int oldlen;
+	/**
+	 * @brief Previous program length, before an EVAL statement.
+	 * An EVAL statement appends additional lines to the program
+	 * beyond its original end, storing the previous size in this
+	 * value. If this value is non-zero an EVAL is in progress,
+	 * otherwise no EVAL is executing.
+	 */
+	size_t oldlen;
+	/**
+	 * @brief The return line number for an EVAL statement
+	 */
 	int64_t eval_linenum;
-
+	/**
+	 * @brief FOR stack, holds the return line numbers for each
+	 * level of FOR...NEXT loop.
+	 */
         struct for_state for_stack[MAX_LOOP_STACK_DEPTH];
+	/**
+	 * @brief How far up the FOR...NEXT stack we are. The FOR
+	 * stack pointer starts at 0, and can go as high as
+	 * MAX_LOOP_STACK_DEPTH - 1
+	 */
         uint64_t for_stack_ptr;
-
+	/**
+	 * @brief Definitions for procedures and functions in the program
+	 */
 	struct ub_proc_fn_def* defs;
-
+	/**
+	 * @brief Global integer variable list
+	 */
         struct ub_var_int* int_variables;
+	/**
+	 * @brief Global string variable list
+	 */
 	struct ub_var_string* str_variables;
+	/**
+	 * @brief Global double variable list
+	 */
 	struct ub_var_double* double_variables;
-
+	/**
+	 * @brief Global integer array variable list
+	 */
 	struct ub_var_int_array* int_array_variables;
+	/**
+	 * @brief Global string array variable list
+	 */
 	struct ub_var_string_array* string_array_variables;
+	/**
+	 * @brief Global double array variable list
+	 */
 	struct ub_var_double_array* double_array_variables;
-
+	/**
+	 * @brief I/O Console
+	 */
 	struct console* cons;
-
+	/**
+	 * @brief Function return type expected.
+	 * This is only relavent when executing a function atomically.
+	 */
 	ub_return_type fn_type;
+	/**
+	 * @brief Function return value pointer.
+	 * This is only relavent when executing a function atomically.
+	 */
 	void* fn_return;
+	/**
+	 * @brief Bracket depth when parsing function or procedure
+	 * parameter lists.
+	 */
 	int bracket_depth;
+	/**
+	 * @brief Item start pointer when parsing function or procedure
+	 * parameter lists.
+	 */
 	char const* item_begin;
+	/**
+	 * @brief Linked list of function parameters when parsing function
+	 * or procedure parameter lists.
+	 */
 	struct ub_param* param;
-
-	int32_t graphics_colour;	// Current GCOL
-
-	struct hashmap* lines;		// Hash map of line number to char pointers
+	/**
+	 * @brief Current graphics colour (GCOL) for graphics drawing commands
+	 */
+	int32_t graphics_colour;
+	/**
+	 * @brief Hashmap of lines for O(1) lookup of line numbers
+	 */
+	struct hashmap* lines;
+	/**
+	 * @brief Block IF...THEN...ELSE depth
+	 */
+	uint64_t if_nest_level;
 } ubasic_ctx;
 
 /**
@@ -301,7 +429,7 @@ typedef struct ubasic_str_fn
 	[[maybe_unused]] char const* item_begin = ctx->ptr;
 
 /**
- * @brief Get a function parameter of type
+ * @brief Get a function parameter of type.
  * @param type Type of function parameter to get, fills one of the variables
  * strval, doubleval or intval.
  */
@@ -358,7 +486,6 @@ typedef struct ubasic_str_fn
 	} \
 }
 
-
 /*
  * Validation functions
  */
@@ -415,6 +542,22 @@ char* ubasic_inkey(struct ubasic_ctx* ctx);
 char* ubasic_insocket(struct ubasic_ctx* ctx);
 char* ubasic_upper(struct ubasic_ctx* ctx);
 char* ubasic_lower(struct ubasic_ctx* ctx);
+
+/*
+ * File I/O functions
+ */
+void openin_statement(struct ubasic_ctx* ctx);
+void openup_statement(struct ubasic_ctx* ctx);
+void openout_statement(struct ubasic_ctx* ctx);
+void read_statement(struct ubasic_ctx* ctx);
+void close_statement(struct ubasic_ctx* ctx);
+void eof_statement(struct ubasic_ctx* ctx);
+void delete_statement(struct ubasic_ctx* ctx);
+void mkdir_statement(struct ubasic_ctx* ctx);
+void mount_statement(struct ubasic_ctx* ctx);
+void rmdir_statement(struct ubasic_ctx* ctx);
+void write_statement(struct ubasic_ctx* ctx);
+
 /*
  * Builtin real (double) functions
  */
@@ -472,6 +615,15 @@ void ubasic_set_string_array(const char* var, const char* value, struct ubasic_c
 void ubasic_set_double_array(const char* var, double value, struct ubasic_ctx* ctx);
 void dim_statement(struct ubasic_ctx* ctx);
 void redim_statement(struct ubasic_ctx* ctx);
+void pop_statement(struct ubasic_ctx* ctx);
+void push_statement(struct ubasic_ctx* ctx);
+int64_t arr_expr_set_index(struct ubasic_ctx* ctx, const char* varname);
+bool ubasic_pop_string_array(const char* var, int64_t pop_pos, struct ubasic_ctx* ctx);
+bool ubasic_pop_int_array(const char* var, int64_t pop_pos, struct ubasic_ctx* ctx);
+bool ubasic_pop_double_array(const char* var, int64_t pop_pos, struct ubasic_ctx* ctx);
+bool ubasic_push_string_array(const char* var, int64_t push_pos, struct ubasic_ctx* ctx);
+bool ubasic_push_int_array(const char* var, int64_t push_pos, struct ubasic_ctx* ctx);
+bool ubasic_push_double_array(const char* var, int64_t push_pos, struct ubasic_ctx* ctx);
 
 /*
  * Integer expression evaluation
@@ -490,3 +642,8 @@ void double_relation(struct ubasic_ctx* ctx, double* res);
  */
 const char* str_expr(struct ubasic_ctx* ctx);
 int64_t str_relation(struct ubasic_ctx* ctx);
+
+/*
+ * Misc functions
+ */
+char* printable_syntax(struct ubasic_ctx* ctx);

src/debugger.c

@@ -55,7 +55,7 @@ void init_debug()
 		symbol_fail();
 		return;
 	} else {
-		unsigned char* filecontent = (unsigned char*)kmalloc(filesize);
+		unsigned char* filecontent = kmalloc(filesize);
 		if (!fs_read_file(symfile, 0, filesize, filecontent)) {
 			symbol_fail();
 			kfree(filecontent);
@@ -72,7 +72,7 @@ void init_debug()
 		uint32_t offset = 0;
 		uint32_t symcount = 0;
 		uint32_t sizebytes = 0;
-		symbol_table = (symbol_t*)kmalloc(sizeof(symbol_t));
+		symbol_table = kmalloc(sizeof(symbol_t));
 		symbol_t* thisentry = symbol_table;
 
 		while (offset < filesize) {
@@ -106,11 +106,11 @@ void init_debug()
 			uint32_t length = strlen(symbol) + 1;
 
 			if (*type == 'T') {
-				thisentry->name = (char*)kmalloc(length);
+				thisentry->name = kmalloc(length);
 				memcpy(thisentry->name, symbol, length);
 				thisentry->address = hextoint(symbol_address);
 				thisentry->type = *type;
-				symbol_t* next = (symbol_t*)kmalloc(sizeof(symbol_t));
+				symbol_t* next = kmalloc(sizeof(symbol_t));
 				next->next = NULL;
 				thisentry->next = next;
 				thisentry = thisentry->next;

src/devfs.c

@@ -34,7 +34,7 @@ void init_devfs()
 	devfs->rmdir = NULL;
 	devfs->rm = NULL;
 	register_filesystem(devfs);
-	devfs_entries = (fs_directory_entry_t*)kmalloc(sizeof(fs_directory_entry_t));
+	devfs_entries = kmalloc(sizeof(fs_directory_entry_t));
 	devfs_entries->next = NULL;
 	devfs_entries->size = 0;
 	devfs_entries->flags = 0;