Add files via upload

Author: vztpv

main.cpp

@@ -0,0 +1,355 @@
+
+#include "mimalloc.h"
+
+#include <vector>
+#include <string>
+#include <string_view>
+#include <iostream>
+#include <cstdint>
+#include <unordered_map>
+
+#include "claujson.h"
+
+namespace clau {
+
+	enum class OrderType : uint64_t { NONE = 0, 
+		ADD, // todo.. number? binary operation?
+		RETURN, EXIT, 
+		VARIABLE, 
+		IF, WHILE, COND_END, EQ, NOTEQ,
+		STRING, INT, UINT, FLOAT, BOOL, NULL_, 
+		PRINT, 
+		NEW_LOCAL_ARRAY, NEW_LOCAL_OBJECT,
+		CD, // ? and dir?
+		SIZE };
+	
+	struct Order {
+		union {
+			OrderType type;    // OrderType
+			uint64_t pos; // pos of data in DataVector.
+		};
+
+		Order(OrderType type) : type(type) { }
+		Order(uint64_t pos) : pos(pos) { }
+	};
+
+	class TapeA {
+	private:
+		std::vector<Order> m_order_list;
+	public:
+		void write(Order e) {
+			m_order_list.push_back(e);
+		}
+
+		const Order& operator[](uint64_t idx) const {
+			return m_order_list[idx];
+		}
+
+		uint64_t size() const {
+			return m_order_list.size();
+		}
+	};
+
+	class TapeB {
+	private:
+		std::vector<claujson::_Value> m_data_list;
+	public:
+		void write(claujson::_Value e) {
+			m_data_list.push_back(std::move(e));
+		}
+
+		const claujson::_Value& operator[](uint64_t idx) const {
+			return m_data_list[idx];
+		}
+	};
+
+	struct VM_Func {
+		TapeA m_order_tape;
+		TapeB m_data_tape;
+	};
+
+	class Explorer {
+	private:
+		claujson::_Value* root = nullptr;
+		std::vector<std::pair<uint64_t, claujson::Structured*>> _stack;
+
+	public:
+		Explorer(claujson::_Value* root) : root(root) {
+			if (root->is_primitive()) {
+				_stack.push_back({ 0, nullptr });
+			}
+			else {
+				_stack.push_back({ 0, root->as_structured_ptr() });
+			}
+		}
+		Explorer() {
+			//
+		}
+
+	private:
+
+		claujson::Structured* Now() {
+			return _stack.back().second;
+		}
+
+		const claujson::Structured* Now() const {
+			return _stack.back().second;
+		}
+
+	public:
+		bool IsPrimitiveRoot() const {
+			return root->is_primitive();
+		}
+
+		uint64_t GetIdx() const {
+			if (_stack.empty()) { return 0; }
+			return _stack.back().first;
+		}
+
+		void SetIdx(const uint64_t idx) {
+			if (_stack.empty()) { return; }
+			_stack.back().first = idx;
+		}
+
+		claujson::_Value& Get() {
+			if (IsPrimitiveRoot()) {
+				return *root;
+			}
+			return Now()->get_value_list(GetIdx());	
+		}
+
+		const claujson::_Value& Get() const {
+			if (IsPrimitiveRoot()) {
+				return *root;
+			}
+			return Now()->get_value_list(GetIdx());
+		}
+
+		const claujson::_Value& GetKey() const {
+			static claujson::_Value nkey(nullptr, false);
+			if (!Now() || Now()->is_array()) {
+				return nkey;
+			}
+			return Now()->get_const_key_list(GetIdx());
+		}
+
+		void ChangeKey(claujson::Value new_key) {
+			if (Now()) {
+				Now()->change_key(GetKey(), std::move(new_key));
+			}
+		}
+
+		void Delete() {
+			if (Now()) {
+				Now()->erase(GetIdx(), true);
+			}
+		}
+
+		void Enter() {
+			if (Get().is_structured()) {
+				_stack.push_back({ 0, Get().as_structured_ptr() });
+			}
+		}
+
+		void Quit() {
+			if (_stack.empty()) {
+				return;
+			}
+			_stack.pop_back();
+		}
+
+		// Group <- Array or Object!
+		bool IsLastElementInGroup() { // END Of GROUP?
+			if (IsPrimitiveRoot()) {
+				return true;
+			}
+			if (nullptr == Now()) {
+				return true;
+			}
+			return GetIdx() >= Now()->get_data_size();
+		}
+
+		bool Next() {
+			if (!IsLastElementInGroup()) {
+				SetIdx(GetIdx() + 1);
+				return true;
+			}
+			return false;
+		}
+		
+		// goto using json pointer?, dir is STRING or UNSIGNED_INTEGER
+		void Goto(const std::vector<claujson::_Value>& dir) {
+
+		}
+
+		void Dump(std::ofstream& out) {
+			while (!IsLastElementInGroup()) {
+				if (GetKey().is_str()) {
+					out << GetKey() << " : ";
+				}
+				if (Get().is_primitive()) {
+					out << Get() << " ";
+				}
+				else {
+					if (Get().is_array()) {
+						out << " [ ";
+					}
+					else {
+						out << " { ";
+					}
+
+					Enter();
+
+					Explorer temp = *this;
+					temp.Dump(out);
+
+					Quit();
+
+					if (Get().is_array()) {
+						out << " ] \n";
+					}
+					else {
+						out << " } \n";
+					}
+				}
+				Next();
+			}
+		}
+	};
+
+	// VM to edit json data.
+	class VM {
+	private:
+		std::unordered_map<std::string, VM_Func> functions;
+	private:
+		std::vector<claujson::_Value> m_stack; // for calcul? 3+4  ?
+		claujson::Value m_root;
+		Explorer m_explorer;
+	public:
+		VM(claujson::Value v) : m_root(std::move(v)) {
+			m_explorer = &m_root.Get();
+		}
+	public:
+		// Register VM Function.
+		void Register(const std::string& name, TapeA&& order_tape, TapeB&& data_tape) {
+			functions.insert(std::make_pair(name, VM_Func{ std::move(order_tape), std::move(data_tape) }));
+		}
+		void Run(const std::string& start_func_name = "main") {
+			const VM_Func& now_func = functions[start_func_name];
+			uint64_t program_counter = 0;
+
+			while (program_counter < now_func.m_order_tape.size()) {
+				switch (now_func.m_order_tape[program_counter].type) {
+				// RETURN
+				case OrderType::EXIT:
+					program_counter++;
+					return;
+					break;
+				// STRING, INT, UINT, FLOAT, BOOL, NULL_
+				case OrderType::INT:
+					if (now_func.m_data_tape[now_func.m_order_tape[program_counter + 1].pos].is_int()) {
+						program_counter++;
+						m_stack.push_back(claujson::_Value(now_func.m_data_tape[now_func.m_order_tape[program_counter].pos].get_integer()));
+					}
+					else {
+						// log, error !
+					}
+					program_counter++;
+					break;
+				// + - * / % 
+				case OrderType::ADD:
+				{
+					claujson::_Value x, y, z;
+					y = std::move(m_stack.back()); m_stack.pop_back();
+					x = std::move(m_stack.back()); m_stack.pop_back();
+
+					if (x.type() == y.type()) {
+						switch (x.type()) {
+						case claujson::_ValueType::INT:
+							z = claujson::_Value(x.get_integer() + y.get_integer());
+							break;
+						case claujson::_ValueType::UINT:
+							z = claujson::_Value(x.get_unsigned_integer() + y.get_unsigned_integer());
+							break;
+						case claujson::_ValueType::FLOAT:
+							z = claujson::_Value(x.get_floating() + y.get_floating());
+							break;
+						default:
+							//
+							break;
+						}
+					}
+					m_stack.push_back(std::move(z));
+				}
+					program_counter++;
+					break;
+				// PRINT, 
+				case OrderType::PRINT:
+					std::cout << m_stack.back();
+					m_stack.pop_back();
+					program_counter++;
+					break;
+			    // VARIALBLE..
+				
+
+
+				// manipulate Explorer?
+
+
+				default:
+					std::cout << "error";
+					break;
+				}
+			}
+		}
+
+		void ExplorerDump(std::ofstream& out) {
+			m_explorer.Dump(out);
+		}
+	};
+}
+
+
+int main(void)
+{
+	claujson::parser p(16);
+	claujson::Document d;
+	p.parse("citylots.json", d, 16); // chk exception process..
+
+	clau::VM vm_test(std::move(d.Get()));
+	{
+		clau::TapeA test;
+		test.write(clau::OrderType::INT);
+		test.write(0);
+		test.write(clau::OrderType::INT);
+		test.write(1);
+		test.write(clau::OrderType::ADD);
+		test.write(clau::OrderType::PRINT);
+		test.write(clau::OrderType::EXIT);
+
+		clau::TapeB test2;
+		test2.write(claujson::_Value(10));
+		test2.write(claujson::_Value(20));
+	
+		vm_test.Register("main", std::move(test), std::move(test2));
+	}
+
+	try {
+		vm_test.Run();
+		{
+			std::ofstream out;
+			out.open("save.json", std::ios::binary);
+			if (out) {
+				vm_test.ExplorerDump(out);
+				out.close();
+			}
+		}
+	}
+	catch (...) {
+		return -1;
+	}
+
+	return 0;
+}
+
+