Compartmentalized Static Lexer Properties

Added a wrapper struct to store static properties (constants, groups, etc...).

Author: TheRealMichaelWang

src/Source.cpp

@@ -46,10 +46,12 @@ int main(int argc, char** argv) {
 	const char* working_dir = argv[0];
 	interpreter interpreter;
 
-	interpreter.new_constant("pi", new value(VALUE_TYPE_NUMERICAL, new long double(3.1415926)));
-	interpreter.new_constant("E", new value(VALUE_TYPE_NUMERICAL, new long double(2.71828182)));
+	interpreter.new_constant("pi@math", new value(VALUE_TYPE_NUMERICAL, new long double(3.1415926)));
+	interpreter.new_constant("e@math", new value(VALUE_TYPE_NUMERICAL, new long double(2.71828182)));
 
 	interpreter.import_func("quit", quit_repl);
+
+	interpreter.import_func("abs", numabs);
 	interpreter.import_func("sin@math", sine);
 	interpreter.import_func("cos@math", cosine);
 	interpreter.import_func("tan@math", tangent);

src/lexer.cpp

@@ -55,15 +55,14 @@ inline function_call_token* print_encapsulate(token* token) {
 	return new function_call_token(new identifier_token("print"), args);
 }
 
-lexer::lexer(const char* source, unsigned long source_length, std::map<unsigned long, value*>* constants, std::set<unsigned long>* group_excluded_ids) {
+lexer::lexer(const char* source, unsigned long source_length, struct lexer_state* lexer_state) {
 	this->source = source;
 	this->source_length = source_length;
 	this->position = 0;
 	this->last_char = 0;
 	this->last_tok = nullptr;
 
-	this->constants = constants;
-	this->group_excluded_ids = group_excluded_ids;
+	this->lexer_state = lexer_state;
 
 	read_char();
 	read_token();
@@ -144,9 +143,9 @@ token* lexer::read_token() {
 		case 303295209:
 			return last_tok = new token(TOKEN_END_GROUP);
 		default: {
-			if (constants->count(hash)) {
+			if (lexer_state->constants.count(hash)) {
 				delete[] id_buf;
-				return last_tok = new value_token((*constants->find(hash)).second->clone());
+				return last_tok = new value_token((*lexer_state->constants.find(hash)).second->clone());
 			}
 			return last_tok = new identifier_token(id_buf, hash);
 		}
@@ -324,22 +323,20 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 		match_tok(read_token(), TOKEN_IDENTIFIER);
 		identifier_token* id = (identifier_token*)last_tok;
 		id->no_delete();
-		group_stack.push_back((char*)id->get_identifier());
+		lexer_state->group_stack.push_back((char*)id->get_identifier());
 		delete id;
 		read_token();
 		return nullptr;
 	}
 	case TOKEN_END_GROUP:
-		if (group_stack.empty()) {
+		if (lexer_state->group_stack.empty()) {
 			throw ERROR_UNEXPECTED_TOKEN;
 		}
-		delete[] group_stack.back();
-		group_stack.pop_back();
-		for (auto i = to_exclude.begin(); i != to_exclude.end(); ++i)
-		{
-			group_excluded_ids->insert(*i);
-		}
-		to_exclude.clear();
+		delete[] lexer_state->group_stack.back();
+		lexer_state->group_stack.pop_back();
+		for (auto i = lexer_state->to_exclude.begin(); i != lexer_state->to_exclude.end(); ++i)
+			lexer_state->namespace_register.insert(*i);
+		lexer_state->to_exclude.clear();
 		read_token();
 		return nullptr; 
 	case TOKEN_CONST_KW: {
@@ -350,7 +347,7 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 		delete last_tok;
 		match_tok(read_token(), TOKEN_VALUE);
 		value_token* value_tok = (value_token*)last_tok;
-		constants->insert(std::pair<unsigned long, value*>(id->id_hash, value_tok->get_value()));
+		lexer_state->constants.insert(std::pair<unsigned long, value*>(id->id_hash, value_tok->get_value()));
 		delete id;
 		delete value_tok;
 		read_token();
@@ -539,13 +536,13 @@ variable_access_token* lexer::tokenize_var_access(identifier_token* identifier)
 }
 
 identifier_token* lexer::apply_groups(identifier_token* id, bool creating) {
-	if (group_stack.empty()) {
+	if (lexer_state->group_stack.empty()) {
 		if (creating) {
-			group_excluded_ids->insert(id->id_hash);
+			lexer_state->namespace_register.insert(id->id_hash);
 		}
 		return id;
 	}
-	else if(group_excluded_ids->count(id->id_hash)) {
+	else if(lexer_state->namespace_register.count(id->id_hash)) {
 		return id;
 	}
 
@@ -558,7 +555,7 @@ identifier_token* lexer::apply_groups(identifier_token* id, bool creating) {
 	for (size_t i = 0; i < strlen(base_id); i++)
 		chars.push_back(base_id[i]);
 
-	for (auto group_kw = group_stack.rbegin(); group_kw != group_stack.rend(); ++group_kw) {
+	for (auto group_kw = lexer_state->group_stack.rbegin(); group_kw != lexer_state->group_stack.rend(); ++group_kw) {
 		chars.push_back('@');
 		for (size_t i = 0; i < strlen(*group_kw); i++)
 			chars.push_back((*group_kw)[i]);
@@ -573,7 +570,7 @@ identifier_token* lexer::apply_groups(identifier_token* id, bool creating) {
 	identifier_token* new_id = new identifier_token(id_buf, insecure_hash(id_buf));
 
 	if (creating)
-		to_exclude.push_back(new_id->id_hash);
+		lexer_state->to_exclude.push_back(new_id->id_hash);
 
 	return new_id;
 }

src/lexer.h

@@ -10,9 +10,23 @@
 #include "builtins.h"
 #include "tokens.h"
 
+struct lexer_state {
+	std::map<unsigned long, value*> constants;
+	std::set<unsigned long> namespace_register;
+	std::list<char*> group_stack;
+	std::list<unsigned long> to_exclude;
+
+	~lexer_state() {
+		for (auto it = this->constants.begin(); it != this->constants.end(); ++it) 
+			delete (*it).second;
+		for (auto it = this->group_stack.begin(); it != this->group_stack.end(); ++it)
+			delete (*it);
+	}
+};
+
 class lexer {
 public:
-	lexer(const char* source, unsigned long source_length, std::map<unsigned long, value*>* constants, std::set<unsigned long>* group_excluded_ids);
+	lexer(const char* source, unsigned long source_length, lexer_state* lexer_state);
 	~lexer();
 
 	inline bool eos() {
@@ -31,10 +45,7 @@ class lexer {
 	char last_char;
 	token* last_tok;
 
-	std::map<unsigned long, value*>* constants;
-	std::list<char*> group_stack;
-	std::set<unsigned long>* group_excluded_ids;
-	std::list<unsigned long> to_exclude;
+	lexer_state* lexer_state;
 
 	//reads the next availible character.
 	char read_char();

src/math.cpp

@@ -2,7 +2,7 @@
 #include "builtins.h"
 #include "math.h"
 
-reference_apartment* abs(std::list<value*> arguments, garbage_collector* gc) {
+reference_apartment* numabs(std::list<value*> arguments, garbage_collector* gc) {
 	match_arg_len(arguments, 1);
 	match_arg_type(arguments.front(), VALUE_TYPE_NUMERICAL);
 	return gc->new_apartment(new value(VALUE_TYPE_NUMERICAL, new long double(abs(*arguments.front()->get_numerical()))));

src/math.h

@@ -8,7 +8,7 @@
 #include "references.h"
 #include "value.h"
 
-reference_apartment* abs(std::list<value*> arguments, garbage_collector* gc);
+reference_apartment* numabs(std::list<value*> arguments, garbage_collector* gc);
 reference_apartment* sine(std::list<value*> arguments, garbage_collector* gc);
 reference_apartment* cosine(std::list<value*> arguments, garbage_collector* gc);
 reference_apartment* tangent(std::list<value*> arguments, garbage_collector* gc);

src/runtime.cpp

@@ -1,5 +1,4 @@
 #include <fstream>
-#include "lexer.h"
 #include "collection.h"
 #include "operators.h"
 #include "runtime.h"
@@ -54,17 +53,13 @@ interpreter::~interpreter() {
 	for (auto it = this->struct_definitions.begin(); it != this->struct_definitions.end(); ++it) {
 		delete (*it).second;
 	}
-
-	for (auto it = this->constants.begin(); it != this->constants.end(); ++it) {
-		delete (*it).second;
-	}
 }
 
 long double interpreter::run(const char* source, bool interactive_mode) {
 	lexer* lexer = nullptr;
 	std::list<token*> to_execute;
 	try {
-		lexer = new class lexer(source, std::strlen(source), &constants, &group_excluded_ids);
+		lexer = new class lexer(source, std::strlen(source), &lexer_state);
 		to_execute = lexer->tokenize(interactive_mode);
 		delete lexer;
 	}
@@ -88,6 +83,8 @@ long double interpreter::run(const char* source, bool interactive_mode) {
 	}
 	catch (int runtime_error){
 		last_error = runtime_error;
+		
+		handle_runtime_err(runtime_error, last_tok);
 		//cleanup
 		while (call_stack.size() > 1)
 		{
@@ -96,7 +93,6 @@ long double interpreter::run(const char* source, bool interactive_mode) {
 		}
 		ret_val = nullptr;
 
-		handle_runtime_err(runtime_error, last_tok);
 		err = true;
 	}
 
@@ -106,7 +102,7 @@ long double interpreter::run(const char* source, bool interactive_mode) {
 	}
 
 	if (err)
-		return -1;
+		return -abs(last_error);
 	if (ret_val == nullptr)
 		return 0;
 	long double exit_code = *ret_val->get_value()->get_numerical();
@@ -145,7 +141,7 @@ void interpreter::import_func(const char* identifier, built_in_function function
 	if (built_in_functions.count(id_hash))
 		throw ERROR_FUNCTION_PROTO_ALREADY_DEFINED;
 	built_in_functions[id_hash] = function;
-	group_excluded_ids.insert(id_hash);
+	lexer_state.namespace_register.insert(id_hash);
 }
 
 void interpreter::set_ref(variable_access_token* access, reference_apartment* reference) {

src/runtime.h

@@ -15,6 +15,7 @@
 #include "garbage.h"
 #include "builtins.h"
 #include "structure.h"
+#include "lexer.h"
 #include "hash.h"
 
 class call_frame {
@@ -88,7 +89,7 @@ class interpreter {
 	void import_func(const char* identifier, built_in_function function);
 
 	inline void new_constant(const char* identifier, value* val) {
-		this->constants[insecure_hash(identifier)] = val;
+		this->lexer_state.constants[insecure_hash(identifier)] = val;
 	}
 
 	////you need the garbage collector to allocate non-primitive objects
@@ -106,9 +107,8 @@ class interpreter {
 	std::map<unsigned long, built_in_function> built_in_functions;
 
 	std::set<unsigned long> included_files;
-	std::map<unsigned long, value*> constants;
 
-	std::set<unsigned long> group_excluded_ids;
+	struct lexer_state lexer_state;
 
 	bool break_mode;