Fixed issues #19, #20, #21

*Made classes/structs private if applicable
*Revamped grouping

Author: TheRealMichaelWang

src/lexer.cpp

@@ -143,10 +143,6 @@ token* lexer::read_token() {
 		case 303295209:
 			return last_tok = new token(TOKEN_END_GROUP);
 		default: {
-			if (lexer_state->constants.count(hash)) {
-				delete[] id_buf;
-				return last_tok = new value_token((*lexer_state->constants.find(hash)).second->clone());
-			}
 			return last_tok = new identifier_token(id_buf, hash);
 		}
 		}
@@ -309,9 +305,10 @@ std::list<token*> lexer::tokenize(bool interactive_mode) {
 		if(tok != nullptr)
 			tokens.push_back(tok);
 	}
-	if (!eos()) {
+	if (!eos())
 		match_tok(last_tok, TOKEN_CLOSE_BRACE);
-	}
+	if (interactive_mode)
+		lexer_state->group_all_references();
 	return tokens;
 }
 
@@ -330,6 +327,7 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 		return nullptr;
 	}
 	case TOKEN_END_GROUP:{
+		delete last_tok;
 		lexer_state->pop_group();
 
 		read_token();
@@ -340,16 +338,29 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 		delete last_tok; 
 		match_tok(read_token(), TOKEN_IDENTIFIER);
 		identifier_token* id = (identifier_token*)last_tok;
+		lexer_state->declare_id(id, GROUP_TYPE_VAR);
 		match_tok(read_token(), TOKEN_SET);
 		delete last_tok;
 		match_tok(read_token(), TOKEN_VALUE);
 		value_token* value_tok = (value_token*)last_tok;
-		lexer_state->constants.insert(std::pair<unsigned long, value*>(id->id_hash, value_tok->get_value()));
+		lexer_state->constants[id->id_hash] = value_tok;
 		delete id;
-		delete value_tok;
 		read_token();
 		return nullptr;
 	}
+	case TOKEN_STATIC_KW: {
+		delete last_tok;
+		match_tok(read_token(), TOKEN_IDENTIFIER);
+		identifier_token* id = (identifier_token*)last_tok;
+		lexer_state->declare_id(id, GROUP_TYPE_VAR);
+		match_tok(read_token(), TOKEN_SET);
+		delete last_tok;
+		read_token();
+		token* val_tok = tokenize_expression();
+		std::list<token*> modifiers;
+		modifiers.push_back(id);
+		return new set_token(new variable_access_token(modifiers), val_tok, true);
+	}
 	case TOKEN_BREAK: {
 		token* tok = last_tok;
 		read_token();
@@ -362,8 +373,10 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 		char* buf = new char[create_str->values.size() + 1];
 		unsigned char size = 0;
 		for (auto it = create_str->values.begin(); it != create_str->values.end(); ++it) {
-			value_token* val = (value_token*)*it;
-			buf[size++] = *val->get_value()->get_char();
+			value_token* val_tok = (value_token*)*it;
+			value* val = val_tok->get_value();
+			buf[size++] = *val->get_char();
+			delete val;
 		}
 		buf[size] = 0;
 		delete create_str;
@@ -428,6 +441,7 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 		delete last_tok;
 		match_tok(read_token(), TOKEN_IDENTIFIER);
 		identifier_token* proto_id = (identifier_token*)last_tok;
+		lexer_state->declare_id(proto_id, GROUP_TYPE_STRUCT);
 		match_tok(read_token(), TOKEN_OPEN_BRACE);
 		delete last_tok;
 		std::list<identifier_token*> properties;
@@ -440,13 +454,13 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 			throw ERROR_UNEXPECTED_END;
 		delete last_tok;
 		read_token();
-		lexer_state->declare_id(proto_id);
 		return new structure_prototype(proto_id, properties);
 	}
 	case TOKEN_FUNC_KW: {
 		delete last_tok;
 		match_tok(read_token(), TOKEN_IDENTIFIER);
 		identifier_token* proto_id = (identifier_token*)last_tok;
+		lexer_state->declare_id(proto_id, GROUP_TYPE_FUNC);
 		match_tok(read_token(), TOKEN_OPEN_PARAM);
 		delete last_tok;
 		std::list<identifier_token*> params;
@@ -458,26 +472,14 @@ token* lexer::tokenize_statement(bool interactive_mode) {
 			}
 			match_tok(last_tok, TOKEN_IDENTIFIER);
 			params.push_back((identifier_token*)last_tok);
+			lexer_state->declare_id((identifier_token*)last_tok, GROUP_TYPE_VAR);
 		}
 		if (eos())
 			throw ERROR_UNEXPECTED_TOKEN;
 		delete last_tok;
 		read_token();
-		lexer_state->declare_id(proto_id);
 		return new function_prototype(proto_id, params, tokenize_body()); 
 	}
-	case TOKEN_STATIC_KW: {
-		delete last_tok;
-		match_tok(read_token(), TOKEN_IDENTIFIER);
-		identifier_token* id = (identifier_token*)last_tok; 
-		match_tok(read_token(), TOKEN_SET);
-		delete last_tok;
-		read_token();
-		token* val_tok = tokenize_expression();
-		std::list<token*> modifiers;
-		modifiers.push_back(id);
-		return new set_token(new variable_access_token(modifiers), val_tok, true);
-	}
 	}
 	throw ERROR_UNEXPECTED_TOKEN;
 }
@@ -556,11 +558,15 @@ token* lexer::tokenize_value() {
 			match_tok(last_tok, TOKEN_CLOSE_PARAM);
 			delete last_tok;
 			read_token();
-			this->lexer_state->reference_id(identifier);
+			this->lexer_state->reference_id(identifier, GROUP_TYPE_FUNC);
 			return new function_call_token(identifier, arguments);
 		}
 		else 
 		{
+			if(last_tok->type == TOKEN_SET)
+				this->lexer_state->declare_id(identifier, GROUP_TYPE_VAR);
+			else
+				this->lexer_state->reference_id(identifier, GROUP_TYPE_VAR);
 			variable_access_token* var_access = tokenize_var_access(identifier);
 			if (last_tok->type == OP_INCRIMENT) {
 				delete last_tok;
@@ -578,12 +584,19 @@ token* lexer::tokenize_value() {
 				token* to_set = tokenize_expression();
 				return new set_token(var_access, to_set, false);
 			}
+
+			if (var_access->modifiers.size() <= 1 && lexer_state->constants.count(identifier->id_hash)) {
+				unsigned long hash = identifier->id_hash;
+				delete var_access;
+				return new value_token(lexer_state->constants[hash]->get_value());
+			}
 			return var_access;
 		}
 	}
 	else if (last_tok->type == TOKEN_REF_KW) {
 		delete last_tok;
 		match_tok(read_token(), TOKEN_IDENTIFIER);
+		lexer_state->reference_id((identifier_token*)last_tok, GROUP_TYPE_VAR);
 		get_reference_token* get_ref_tok = new get_reference_token(tokenize_var_access());
 		return get_ref_tok;
 	}
@@ -622,7 +635,7 @@ token* lexer::tokenize_value() {
 		delete last_tok;
 		match_tok(read_token(), TOKEN_IDENTIFIER);
 		create_struct_token* new_struct = new create_struct_token((identifier_token*)last_tok);
-		this->lexer_state->reference_id(new_struct->identifier);
+		this->lexer_state->reference_id(new_struct->identifier, GROUP_TYPE_STRUCT);
 		read_token();
 		return new_struct;
 	}
@@ -656,29 +669,4 @@ token* lexer::tokenize_expression(unsigned char min) {
 		lhs = new binary_operator_token(lhs, rhs, op);
 	}
 	return lhs;
-}
-
-void group::proc_id(identifier_token* id) {
-	std::list<char> chars;
-
-	for (int i = 0; i < strlen(id->get_identifier()); i++)
-		chars.push_back(id->get_identifier()[i]);
-
-	group* current = this;
-	while (current != nullptr)
-	{
-		chars.push_back('@');
-		for (int i = 0; i < strlen(identifier->get_identifier()); i++)
-			chars.push_back(identifier->get_identifier()[i]);
-		current = current->parent;
-	}
-
-	char* new_buf = new char[chars.size() + 1];
-	unsigned long in = 0;
-	for (auto i = chars.begin(); i != chars.end(); ++i) {
-		new_buf[in++] = *i;
-	}
-	new_buf[in] = 0;
-
-	id->set_c_str(new_buf);
 }

src/lexer.h

@@ -10,58 +10,107 @@
 #include "builtins.h"
 #include "tokens.h"
 
-struct group {
-private:
-	std::set<unsigned long> declerations;
-	std::list<identifier_token*> to_process;
-	identifier_token* identifier;
+#define GROUP_TYPE_STRUCT 0
+#define GROUP_TYPE_FUNC 1
+#define GROUP_TYPE_VAR 2
 
-	void proc_id(identifier_token* id);
+struct lexer_state {
+private:
+	struct identifier_system
+	{
+		std::set<unsigned long> declerations;
+		std::list<identifier_token*> references;
+	};
+
+	struct group {
+	private:
+		identifier_system id_systems[3];
+		identifier_token* identifier;
+
+		inline void proc_id(identifier_token* id) {
+			std::list<char> chars;
+
+			for (int i = 0; i < strlen(id->get_identifier()); i++)
+				chars.push_back(id->get_identifier()[i]);
+
+			group* current = this;
+			while (current != nullptr)
+			{
+				chars.push_back('@');
+				for (int i = 0; i < strlen(current->identifier->get_identifier()); i++)
+					chars.push_back(current->identifier->get_identifier()[i]);
+				current = current->parent;
+			}
+
+			char* new_buf = new char[chars.size() + 1];
+			unsigned long in = 0;
+			for (auto i = chars.begin(); i != chars.end(); ++i) {
+				new_buf[in++] = *i;
+			}
+			new_buf[in] = 0;
+
+			id->set_c_str(new_buf);
+		}
+	public:
+		group* parent;
 
-public:
-	group* parent;
+		group(struct identifier_token* identifier, group* parent = nullptr) {
+			this->identifier = identifier;
+			this->parent = parent;
+		}
 
-	group(struct identifier_token* identifier, group* parent = nullptr) {
-		this->identifier = identifier;
-		this->parent = parent;
-	}
+		inline void proc_decleration(identifier_token* id, unsigned char type) {
+			id_systems[type].declerations.insert(id->id_hash);
+			proc_id(id);
+		}
 
-	inline void proc_decleration(identifier_token* id) {
-		declerations.insert(id->id_hash);
-		proc_id(id);
-	}
+		inline void proc_reference(identifier_token* id, unsigned char type) {
+			id_systems[type].references.push_back(id);
+		}
 
-	inline void proc_reference(identifier_token* id) {
-		to_process.push_back(id);
-	}
+		inline void group_references(bool remall = false) {
+			for (unsigned char type = 0; type < 3; type++)
+			{
+				std::list<std::list<identifier_token*>::iterator> to_remove;
+				for (auto i = id_systems[type].references.begin(); i != id_systems[type].references.end(); ++i) {
+					if (id_systems[type].declerations.count((*i)->id_hash)) {
+						proc_id(*i);
+						if (!remall)
+							to_remove.push_back(i);
+					}
+				}
+				if (remall)
+					id_systems[type].references.clear();
+				else
+					for (auto i = to_remove.begin(); i != to_remove.end(); ++i) {
+						id_systems[type].references.erase(*i);
+					}
+			}
+		}
 
-	~group() {
-		for (auto i = to_process.begin(); i != to_process.end(); ++i) {
-			if (declerations.count((*i)->id_hash))
-				proc_id(*i);
+		~group() {
+			group_references(true);
+			delete identifier;
 		}
-	}
-};
+	};
 
-struct lexer_state {
-private:
 	group* top_group = nullptr;
 public:
-	std::map<unsigned long, value*> constants;
+	std::map<unsigned long, value_token*> constants;
 
 	~lexer_state() {
 		for (auto it = this->constants.begin(); it != this->constants.end(); ++it) 
 			delete (*it).second;
 	}
 
-	inline void declare_id(identifier_token* id) {
+	inline void declare_id(identifier_token* id, unsigned char type) {
 		if (top_group != nullptr)
-			top_group->proc_decleration(id);
+			top_group->proc_decleration(id, type);
 	}
 
-	inline void reference_id(identifier_token* id) {
+	inline void reference_id(identifier_token* id, unsigned char type) {
 		if (top_group != nullptr)
-			top_group->proc_reference(id);
+			top_group->proc_reference(id, type);
 	}
 
 	inline group* current_group() {
@@ -77,6 +126,14 @@ struct lexer_state {
 		top_group = top_group->parent;
 		delete to_delete;
 	}
+
+	inline void group_all_references() {
+		group* current = top_group;
+		while (current != nullptr) {
+			current->group_references();
+			current = current->parent;
+		}
+	}
 };
 
 class lexer {

src/objects.cpp

@@ -76,7 +76,7 @@ int structure::hash() {
 	return hash;
 }
 
-collection::collection(unsigned long size, garbage_collector* gc) : collection(size, new reference_apartment(new value(VALUE_TYPE_COLLECTION, this))) {
+collection::collection(unsigned long size, garbage_collector* gc) : collection(size, gc->new_apartment(new value(VALUE_TYPE_COLLECTION, this))) {
 	for (unsigned long i = 0; i < size; i++)
 	{
 		this->inner_collection[i] = gc->new_apartment(new value(VALUE_TYPE_NULL, nullptr));

src/runtime.cpp

@@ -1,6 +1,7 @@
 #include <fstream>
 #include "collection.h"
 #include "operators.h"
+#include "garbage.h"
 #include "runtime.h"
 #include "hash.h"
 
@@ -102,7 +103,9 @@ long double interpreter::run(const char* source, bool interactive_mode) {
 		ret_val = nullptr;
 		err = true;
 	}
-	
+
+	garbage_collector.sweep(false);
+
 	for (auto it = to_execute.begin(); it != to_execute.end(); ++it) {
 		if ((*it)->type != TOKEN_FUNC_PROTO && (*it)->type != TOKEN_STRUCT_PROTO)
 			destroy_top_lvl_tok(*it);

src/runtime.h

@@ -89,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->lexer_state.constants[insecure_hash(identifier)] = val;
+		this->lexer_state.constants[insecure_hash(identifier)] = new value_token(val);
 	}
 
 private: