166 lines
3.4 KiB
C++
166 lines
3.4 KiB
C++
#ifndef DLANG_LIBS_TABLE_HPP
|
|
#define DLANG_LIBS_TABLE_HPP
|
|
|
|
#include <chrono>
|
|
#include <thread>
|
|
#include "../vm.hpp"
|
|
#include "../helpers.hpp"
|
|
#include "../json.hpp"
|
|
|
|
void NativeTableInsert(DlangVM* vm)
|
|
{
|
|
auto newTable = dlang_totable(vm);
|
|
auto insertTable = dlang_totable(vm);
|
|
|
|
for (const auto [key, val] : newTable->fields)
|
|
insertTable->fields[key] = val;
|
|
|
|
dlang_push(vm, StackValue(StackValueType::Table, insertTable));
|
|
}
|
|
|
|
void NativeTableRemove(DlangVM* vm)
|
|
{
|
|
auto key = dlang_tostring(vm);
|
|
auto table = dlang_totable(vm);
|
|
|
|
auto it = table->fields.find(key);
|
|
if (it != table->fields.end())
|
|
table->fields.erase(it);
|
|
|
|
dlang_push(vm, StackValue(StackValueType::Table, table));
|
|
}
|
|
|
|
nlohmann::json DlangValueToJson(const StackValue& val)
|
|
{
|
|
switch (val.type)
|
|
{
|
|
case StackValueType::Int: return std::get<double>(val.data);
|
|
case StackValueType::Bool: return std::get<bool>(val.data);
|
|
case StackValueType::String: return std::get<std::string>(val.data);
|
|
case StackValueType::NIL: return nullptr;
|
|
|
|
case StackValueType::Table:
|
|
{
|
|
auto tablePtr = std::get<std::shared_ptr<DlangTable>>(val.data);
|
|
nlohmann::json jObj = nlohmann::json::object();
|
|
|
|
for (const auto& [key, fieldVal] : tablePtr->fields)
|
|
jObj[key] = DlangValueToJson(fieldVal);
|
|
|
|
return jObj;
|
|
}
|
|
|
|
case StackValueType::List:
|
|
{
|
|
auto listPtr = std::get<std::shared_ptr<DlangList>>(val.data);
|
|
nlohmann::json jArr = nlohmann::json::array();
|
|
|
|
for (const auto& elemVal : listPtr->values)
|
|
jArr.push_back(DlangValueToJson(elemVal));
|
|
|
|
return jArr;
|
|
}
|
|
|
|
default:
|
|
return nullptr;
|
|
}
|
|
}
|
|
|
|
void PushJsonToVM(DlangVM* vm, const nlohmann::json& j)
|
|
{
|
|
if (j.is_number())
|
|
{
|
|
dlang_pushnumber(vm, j.get<double>());
|
|
}
|
|
else if (j.is_boolean())
|
|
{
|
|
dlang_pushboolean(vm, j.get<bool>());
|
|
}
|
|
else if (j.is_string())
|
|
{
|
|
dlang_pushstring(vm, j.get<std::string>());
|
|
}
|
|
else if (j.is_array())
|
|
{
|
|
dlang_newlist(vm);
|
|
auto listPtr = dlang_tolist(vm);
|
|
|
|
for (const auto& element : j)
|
|
{
|
|
PushJsonToVM(vm, element);
|
|
listPtr->values.push_back(vm->stack.pop());
|
|
}
|
|
|
|
vm->stack.push(StackValue(StackValueType::List, listPtr));
|
|
}
|
|
else if (j.is_object())
|
|
{
|
|
dlang_newtable(vm);
|
|
auto tablePtr = dlang_totable(vm);
|
|
|
|
for (auto it = j.begin(); it != j.end(); ++it)
|
|
{
|
|
PushJsonToVM(vm, it.value());
|
|
tablePtr->fields[it.key()] = vm->stack.pop();
|
|
}
|
|
|
|
vm->stack.push(StackValue(StackValueType::Table, tablePtr));
|
|
}
|
|
else
|
|
{
|
|
dlang_pushnil(vm);
|
|
}
|
|
}
|
|
|
|
void NativeJsonEncode(DlangVM* vm)
|
|
{
|
|
int indent = 0;
|
|
if (dlang_isnumber(vm))
|
|
indent = dlang_tonumber(vm);
|
|
|
|
if (!dlang_istable(vm))
|
|
{
|
|
dlang_pushnil(vm);
|
|
return;
|
|
}
|
|
|
|
nlohmann::json j = DlangValueToJson(dlang_pop(vm));
|
|
|
|
dlang_pushstring(vm, j.dump(indent));
|
|
}
|
|
|
|
void NativeJsonDecode(DlangVM* vm)
|
|
{
|
|
std::string jsonStr = dlang_tostring(vm);
|
|
|
|
try
|
|
{
|
|
nlohmann::json j = nlohmann::json::parse(jsonStr);
|
|
PushJsonToVM(vm, j);
|
|
}
|
|
catch (const nlohmann::json::parse_error& e)
|
|
{
|
|
throw std::runtime_error("JSON Parse Error: " + std::string(e.what()));
|
|
}
|
|
}
|
|
|
|
inline void openlib_table(DlangVM* vm)
|
|
{
|
|
dlang_newtable(vm);
|
|
|
|
dlang_pushcfunction(vm, NativeTableInsert);
|
|
dlang_setfield(vm, "insert");
|
|
|
|
dlang_pushcfunction(vm, NativeTableRemove);
|
|
dlang_setfield(vm, "remove");
|
|
|
|
dlang_pushcfunction(vm, NativeJsonEncode);
|
|
dlang_setfield(vm, "json_encode");
|
|
|
|
dlang_pushcfunction(vm, NativeJsonDecode);
|
|
dlang_setfield(vm, "json_decode");
|
|
|
|
dlang_setglobal(vm, "table");
|
|
}
|
|
|
|
#endif |