1 files changed, 74 insertions, 74 deletions

diff --git a/src/ls_internal.c b/src/ls_internal.c
index 670b1dc..f739a3d 100644
--- a/src/ls_internal.c
+++ b/src/ls_internal.c
@@ -21,7 +21,7 @@
 // --- PRIVATE MACROS ----------------------------------------------------------
 
 /// Check a return code and throw if it is an error.
-#define CHECK_THROW(ctx, v) do {ls_error_t _e = (v); _throw_err((ctx), _e);} \
+#define CHECK_THROW(self, v) do {ls_error_t _e = (v); _throw_err((self), _e);} \
 	while (0)
 
 #define IS_WORD_CHAR(ch) (isalpha((ch)) || (ch) == '_' || (ch) >= 0x80)
@@ -37,28 +37,28 @@
 // --- PRIVATE VARIABLES -------------------------------------------------------
 // --- PUBLIC FUNCTIONS --------------------------------------------------------
 
-void ls_init_ctx(ls_context_t * ctx, ls_value_t * pool, size_t szpool)
+void ls_init(ls_t * self, ls_value_t * pool, size_t szpool)
 {
-	ctx->error = LS_OK;
+	self->error = LS_OK;
 
-	ctx->pool = pool;
+	self->pool = pool;
 
 	if (pool)
 	{
-		ctx->pool[szpool - 1].ty = LS_TY_PRISTINE;
-		ctx->pool[szpool - 1].next = NULL;
-		ctx->pool[szpool - 1].prev = NULL;
+		self->pool[szpool - 1].ty = LS_TY_PRISTINE;
+		self->pool[szpool - 1].next = NULL;
+		self->pool[szpool - 1].prev = NULL;
 
 		for (size_t i = 0; i < szpool - 1; i++)
 		{
-			ctx->pool[i].ty = LS_TY_PRISTINE;
-			ctx->pool[i].next = &ctx->pool[i + 1];
-			ctx->pool[i].prev = NULL;
+			self->pool[i].ty = LS_TY_PRISTINE;
+			self->pool[i].next = &self->pool[i + 1];
+			self->pool[i].prev = NULL;
 		}
 
-		ctx->callstack = ctx->pool;
-		ctx->pool = ctx->pool->next;
-		*ctx->callstack = (ls_value_t) {
+		self->callstack = self->pool;
+		self->pool = self->pool->next;
+		*self->callstack = (ls_value_t) {
 			.ty = LS_TY_SCTX_CALL,
 			.prev = NULL,
 			.next = NULL,
@@ -69,14 +69,14 @@ void ls_init_ctx(ls_context_t * ctx, ls_value_t * pool, size_t szpool)
 		};
 	}
 
-	ctx->funcs = NULL;
-	ctx->labels = NULL;
-	ctx->pc = 0;
-	ctx->stop = false;
+	self->funcs = NULL;
+	self->labels = NULL;
+	self->pc = 0;
+	self->stop = false;
 
 	for (size_t i = 0; i < LS_LABEL_CACHE_SIZE; i++)
-		ctx->label_cache[i].pc = LS_ADDR_NULL;
-	ctx->label_cache_i = 0;
+		self->label_cache[i].pc = LS_ADDR_NULL;
+	self->label_cache_i = 0;
 }
 
 ls_kw_t ls_convert_kw(char const * word)
@@ -108,52 +108,52 @@ ls_kw_t ls_convert_kw(char const * word)
 	return LS_NOT_A_KW;
 }
 
-void ls_throw_err(ls_context_t * ctx, ls_error_t e)
+void ls_throw_err(ls_t * self, ls_error_t e)
 {
 	if (e)
 	{
-		ctx->error = e;
-		longjmp(ctx->error_jmp_buf, 1);
+		self->error = e;
+		longjmp(self->error_jmp_buf, 1);
 	}
 }
 
-ls_uchar ls_fetch_rel(ls_context_t * ctx, int offset)
+ls_uchar ls_fetch_rel(ls_t * self, int offset)
 {
-	if (ctx->pc + offset > UINT16_MAX || ctx->pc + offset < 0)
-		ls_throw_err(ctx, LS_INTERNAL_ERROR);
-	return ls_fetch(ctx, (ls_addr_t)(ctx->pc + offset));
+	if (self->pc + offset > UINT16_MAX || self->pc + offset < 0)
+		ls_throw_err(self, LS_INTERNAL_ERROR);
+	return ls_fetch(self, (ls_addr_t)(self->pc + offset));
 }
 
-ls_uchar ls_fetch(ls_context_t * ctx, ls_addr_t pc)
+ls_uchar ls_fetch(ls_t * self, ls_addr_t pc)
 {
-	int rc = ctx->fetcher(ctx->fetcher_ctx, pc);
+	int rc = self->fetcher(self->fetcher_arg, pc);
 	if (rc == -LS_NO_MORE_PROGRAM)
 		return 0;
 	else if (rc > 0)
 		return (ls_uchar) rc;
 	else
-		ls_throw_err(ctx, -rc);
+		ls_throw_err(self, -rc);
 	return 0;
 }
 
-ls_value_t * ls_alloc(ls_context_t * ctx)
+ls_value_t * ls_alloc(ls_t * self)
 {
-	if (!ctx->pool)
-		ls_throw_err(ctx, LS_OUT_OF_MEMORY);
+	if (!self->pool)
+		ls_throw_err(self, LS_OUT_OF_MEMORY);
 
-	ls_value_t * v = ctx->pool;
-	ctx->pool = v->next;
+	ls_value_t * v = self->pool;
+	self->pool = v->next;
 	return v;
 }
 
-void ls_free(ls_context_t * ctx, ls_value_t * v)
+void ls_free(ls_t * self, ls_value_t * v)
 {
 	v->ty = LS_TY_NOT_ALLOC;
-	v->next = ctx->pool;
-	ctx->pool = v;
+	v->next = self->pool;
+	self->pool = v;
 }
 
-void ls_free_val(ls_context_t * ctx, ls_value_t * v)
+void ls_free_val(ls_t * self, ls_value_t * v)
 {
 	ls_value_t * child;
 
@@ -174,16 +174,16 @@ void ls_free_val(ls_context_t * ctx, ls_value_t * v)
 	for (; child; child = next)
 	{
 		next = child->next;
-		ls_free(ctx, child);
+		ls_free(self, child);
 	}
 
-	ls_free(ctx, v);
+	ls_free(self, v);
 }
 
-size_t ls_mem_avail(ls_context_t * ctx)
+size_t ls_mem_avail(ls_t * self)
 {
 	size_t count = 0;
-	ls_value_t * iter = ctx->pool;
+	ls_value_t * iter = self->pool;
 
 	while (iter)
 	{
@@ -194,9 +194,9 @@ size_t ls_mem_avail(ls_context_t * ctx)
 	return count;
 }
 
-ls_value_t * ls_find_var(ls_context_t * ctx, char const * name)
+ls_value_t * ls_find_var(ls_t * self, char const * name)
 {
-	for (ls_value_t * scope  = ctx->callstack; scope; scope = scope->prev)
+	for (ls_value_t * scope  = self->callstack; scope; scope = scope->prev)
 	{
 		for (ls_value_t * var = scope->next; var; var = var->next)
 		{
@@ -214,51 +214,51 @@ ls_value_t * ls_find_var(ls_context_t * ctx, char const * name)
 	return NULL;
 }
 
-ls_value_t * ls_new_var(ls_context_t * ctx, char const * name)
+ls_value_t * ls_new_var(ls_t * self, char const * name)
 {
-	ls_value_t * var = ls_alloc(ctx);
+	ls_value_t * var = ls_alloc(self);
 	var->ty = LS_TY_INT_VAR;
 	memset(var->body.int_var.ident, 0, LS_IDENT_LEN);
 	strncpy(var->body.int_var.ident, name, LS_IDENT_LEN);
 	var->body.int_var.value = 0;
 
-	var->next = ctx->callstack->next;
-	ctx->callstack->next = var;
+	var->next = self->callstack->next;
+	self->callstack->next = var;
 
 	return var;
 }
 
-ls_int_t ls_read_int_var(ls_context_t * ctx, ls_value_t * var)
+ls_int_t ls_read_int_var(ls_t * self, ls_value_t * var)
 {
 	if (var->ty == LS_TY_INT_VAR)
 		return var->body.int_var.value;
 	else
-		ls_throw_err(ctx, LS_TYPE_MISMATCH);
+		ls_throw_err(self, LS_TYPE_MISMATCH);
 
 	// Unreachable
 	return 0;
 }
 
-void ls_write_int_var(ls_context_t * ctx, ls_value_t * var, ls_int_t val)
+void ls_write_int_var(ls_t * self, ls_value_t * var, ls_int_t val)
 {
 	if (var->ty == LS_TY_VAR)
 	{
 		if (var->body.var.value)
-			ls_free(ctx, var->body.var.value);
+			ls_free(self, var->body.var.value);
 		var->ty = LS_TY_INT_VAR;
 	}
 
 	if (var->ty != LS_TY_INT_VAR)
-		ls_throw_err(ctx, LS_INTERNAL_ERROR);
+		ls_throw_err(self, LS_INTERNAL_ERROR);
 
 	var->body.int_var.value = val;
 }
 
-void ls_write_var(ls_context_t * ctx, ls_value_t * var, ls_value_t * val)
+void ls_write_var(ls_t * self, ls_value_t * var, ls_value_t * val)
 {
 	if (val->ty == LS_TY_INT)
 	{
-		ls_write_int_var(ctx, var, val->body.integer.value);
+		ls_write_int_var(self, var, val->body.integer.value);
 	}
 	else
 	{
@@ -269,66 +269,66 @@ void ls_write_var(ls_context_t * ctx, ls_value_t * var, ls_value_t * val)
 		}
 
 		if (var->body.var.value)
-			ls_free_val(ctx, var->body.var.value);
+			ls_free_val(self, var->body.var.value);
 
-		var->body.var.value = ls_alloc(ctx);
+		var->body.var.value = ls_alloc(self);
 		memcpy(var->body.var.value, val, sizeof(ls_value_t));
 	}
 }
 
-bool ls_exec_line(ls_context_t * ctx)
+bool ls_exec_line(ls_t * self)
 {
 	ls_token_t tok = {.ty = LS_TOK_STATEMENT_SEP};
 
 	while (tok.ty == LS_TOK_STATEMENT_SEP)
-		ls_lex(ctx, &tok);
+		ls_lex(self, &tok);
 
-	if (ctx->line_trace_hook)
-		ctx->line_trace_hook(ctx);
+	if (self->line_trace_hook)
+		self->line_trace_hook(self);
 
 	if (tok.ty == LS_TOK_STR_LABEL)
 	{
 		// TODO: handle string labels
-		ls_lex(ctx, &tok);
+		ls_lex(self, &tok);
 	}
 	else if (tok.ty == LS_TOK_NUM_LABEL)
 	{
-		ls_lex(ctx, &tok);
+		ls_lex(self, &tok);
 	}
 
 	// LET is handled here because of the slight complexity of implicit-LET
 	if (tok.ty == LS_TOK_KEYWORD && tok.body.keyword_val == LS_KW_LET)
 	{
-		ls_lex(ctx, &tok);
+		ls_lex(self, &tok);
 		if (tok.ty != LS_TOK_WORD)
-			ls_throw_err(ctx, LS_SYNTAX_ERROR);
+			ls_throw_err(self, LS_SYNTAX_ERROR);
 	}
 
 	// Now both implicit and explicit LET can be handled
 	if (tok.ty == LS_TOK_WORD)
 	{
-		ls_value_t * var = ls_find_var(ctx, tok.body.word_val);
+		ls_value_t * var = ls_find_var(self, tok.body.word_val);
 
 		ls_token_t tok_eq;
-		ls_lex(ctx, &tok_eq);
+		ls_lex(self, &tok_eq);
 		if (tok_eq.ty != LS_TOK_OPERATOR
 				|| tok_eq.body.oper_val != OPER_EQ)
-			ls_throw_err(ctx, LS_SYNTAX_ERROR);
+			ls_throw_err(self, LS_SYNTAX_ERROR);
 
 		ls_value_t val;
-		ls_eval_expr(ctx, &val, NULL);
+		ls_eval_expr(self, &val, NULL);
 
 		if (val.ty != LS_TY_INT)
-			ls_throw_err(ctx, LS_TYPE_MISMATCH);
+			ls_throw_err(self, LS_TYPE_MISMATCH);
 
 		if (!var)
-			var = ls_new_var(ctx, tok.body.word_val);
+			var = ls_new_var(self, tok.body.word_val);
 
-		ls_write_int_var(ctx, var, val.body.integer.value);
+		ls_write_int_var(self, var, val.body.integer.value);
 	}
 	else if (tok.ty == LS_TOK_KEYWORD)
 	{
-		ls_kwmap[tok.body.keyword_val - LS_KW_OFFSET].fun(ctx);
+		ls_kwmap[tok.body.keyword_val - LS_KW_OFFSET].fun(self);
 	}
 	else if (tok.ty == LS_TOK_STATEMENT_SEP)
 	{
@@ -340,7 +340,7 @@ bool ls_exec_line(ls_context_t * ctx)
 	}
 	else
 	{
-		ls_throw_err(ctx, LS_SYNTAX_ERROR);
+		ls_throw_err(self, LS_SYNTAX_ERROR);
 	}
 
 	return true;