From 669d8c139e61579decbfc7799d3818e637373258 Mon Sep 17 00:00:00 2001 From: folkert van heusden Date: Mon, 13 May 2024 21:32:33 +0200 Subject: [PATCH] wip --- bus.cpp | 72 ++++++++++++---------------------- bus.h | 5 ++- cpu.cpp | 91 +++++++++++++++++++++---------------------- cpu.h | 5 ++- disk_backend_file.cpp | 5 +-- 5 files changed, 78 insertions(+), 100 deletions(-) diff --git a/bus.cpp b/bus.cpp index 730930b..a8e3d53 100644 --- a/bus.cpp +++ b/bus.cpp @@ -1,6 +1,7 @@ // (C) 2018-2024 by Folkert van Heusden // Released under MIT license +#include #include #include #include @@ -44,91 +45,68 @@ bus::~bus() delete dc11_; } -#if IS_POSIX -json_t *bus::serialize() const +JsonDocument bus::serialize() const { - json_t *j_out = json_object(); + JsonDocument j_out; if (m) - json_object_set(j_out, "memory", m->serialize()); + j_out["memory"] = m->serialize(); if (kw11_l_) - json_object_set(j_out, "kw11-l", kw11_l_->serialize()); + j_out["kw11-l"] = kw11_l_->serialize(); if (tty_) - json_object_set(j_out, "tty", tty_->serialize()); + j_out["tty"] = tty_->serialize(); if (mmu_) - json_object_set(j_out, "mmu", mmu_->serialize()); + j_out["mmu"] = mmu_->serialize(); if (c) - json_object_set(j_out, "cpu", c->serialize()); + j_out["cpu"] = c->serialize(); if (rl02_) - json_object_set(j_out, "rl02", rl02_->serialize()); + j_out["rl02"] = rl02_->serialize(); if (rk05_) - json_object_set(j_out, "rk05", rk05_->serialize()); + j_out["rk05"] = rk05_->serialize(); // TODO: tm11, dc11 return j_out; } -bus *bus::deserialize(const json_t *const j, console *const cnsl, std::atomic_uint32_t *const event) +bus *bus::deserialize(const JsonDocument j, console *const cnsl, std::atomic_uint32_t *const event) { bus *b = new bus(); - json_t *temp = nullptr; - memory *m = nullptr; - temp = json_object_get(j, "memory"); - if (temp) { - m = memory::deserialize(temp); + if (j.containsKey("memory")) { + m = memory::deserialize(j["memory"]); b->add_ram(m); } - temp = json_object_get(j, "kw11-l"); - if (temp) { - kw11_l *kw11_l_ = kw11_l::deserialize(temp, b, cnsl); - b->add_KW11_L(kw11_l_); - } + if (j.containsKey("kw11-l")) + b->add_KW11_L(kw11_l::deserialize(j["kw11-l"], b, cnsl)); - temp = json_object_get(j, "tty"); - if (temp) { - tty *tty_ = tty::deserialize(temp, b, cnsl); - b->add_tty(tty_); - } + if (j.containsKey("tty")) + b->add_tty(tty::deserialize(j["tty"], b, cnsl)); - temp = json_object_get(j, "mmu"); - if (temp) { - mmu *mmu_ = mmu::deserialize(temp, m); - b->add_mmu(mmu_); - } + if (j.containsKey("mmu")) + b->add_mmu(mmu::deserialize(j["mmu"], m)); - temp = json_object_get(j, "cpu"); - if (temp) { - cpu *cpu_ = cpu::deserialize(temp, b, event); - b->add_cpu(cpu_); - } + if (j.containsKey("cpu")) + b->add_cpu(cpu::deserialize(j["cpu"], b, event)); - temp = json_object_get(j, "rl02"); - if (temp) { - rl02 *rl02_ = rl02::deserialize(temp, b); - b->add_rl02(rl02_); - } + if (j.containsKey("rl02")) + b->add_rl02(rl02::deserialize(j["rl02"], b)); - temp = json_object_get(j, "rk05"); - if (temp) { - rk05 *rk05_ = rk05::deserialize(temp, b); - b->add_rk05(rk05_); - } + if (j.containsKey("rk05")) + b->add_rk05(rk05::deserialize(j["rk05"], b)); // TODO: tm11, dc11 return b; } -#endif void bus::show_state(console *const cnsl) const { diff --git a/bus.h b/bus.h index e9b3050..07d517e 100644 --- a/bus.h +++ b/bus.h @@ -3,6 +3,7 @@ #pragma once +#include #include #include #include @@ -80,8 +81,8 @@ public: ~bus(); #if IS_POSIX - json_t *serialize() const; - static bus *deserialize(const json_t *const j, console *const cnsl, std::atomic_uint32_t *const event); + JsonDocument serialize() const; + static bus *deserialize(const JsonDocument j, console *const cnsl, std::atomic_uint32_t *const event); #endif void reset(); diff --git a/cpu.cpp b/cpu.cpp index 6eca7c0..508a9e1 100644 --- a/cpu.cpp +++ b/cpu.cpp @@ -2434,89 +2434,88 @@ void cpu::step() } } -#if IS_POSIX -json_t *cpu::serialize() +JsonDocument cpu::serialize() { - json_t *j = json_object(); + JsonDocument j; for(int set=0; set<2; set++) { for(int regnr=0; regnr<6; regnr++) - json_object_set(j, format("register-%d-%d", set, regnr).c_str(), json_integer(regs0_5[set][regnr])); + j[format("register-%d-%d", set, regnr)] = regs0_5[set][regnr]; } for(int spnr=0; spnr<4; spnr++) - json_object_set(j, format("sp-%d", spnr).c_str(), json_integer(sp[spnr])); + j[format("sp-%d", spnr)] = sp[spnr]; + + j["pc"] = pc; + j["instruction_start"] = instruction_start; + j["psw"] = psw; + j["fpsr"] = fpsr; + j["stackLimitRegister"] = stackLimitRegister; + j["processing_trap_depth"] = processing_trap_depth; + j["instruction_count"] = instruction_count; + j["running_since"] = running_since; + j["wait_time"] = wait_time; + j["it_is_a_trap"] = it_is_a_trap; + j["debug_mode"] = debug_mode; - json_object_set(j, "pc", json_integer(pc)); - json_object_set(j, "instruction_start", json_integer(instruction_start)); - json_object_set(j, "psw", json_integer(psw)); - json_object_set(j, "fpsr", json_integer(fpsr)); - json_object_set(j, "stackLimitRegister", json_integer(stackLimitRegister)); - json_object_set(j, "processing_trap_depth", json_integer(processing_trap_depth)); - json_object_set(j, "instruction_count", json_integer(instruction_count)); - json_object_set(j, "running_since", json_integer(running_since)); - json_object_set(j, "wait_time", json_integer(wait_time)); - json_object_set(j, "it_is_a_trap", json_boolean(it_is_a_trap)); - json_object_set(j, "debug_mode", json_boolean(debug_mode)); if (trap_delay.has_value()) - json_object_set(j, "trap_delay", json_integer(trap_delay.value())); + j["trap_delay"] = trap_delay.value(); - json_t *j_queued_interrupts = json_object(); + JsonDocument j_queued_interrupts; for(auto & il: queued_interrupts) { - json_t *ja_qi_level = json_array(); - for(auto & v: il.second) - json_array_append(ja_qi_level, json_integer(v)); + JsonArray ja_qi_level; + for(auto v: il.second) + ja_qi_level.add(v); - json_object_set(j_queued_interrupts, format("%d", il.first).c_str(), ja_qi_level); + j_queued_interrupts[format("%d", il.first)] = ja_qi_level; } - json_object_set(j, "queued_interrupts", j_queued_interrupts); - json_object_set(j, "any_queued_interrupts", json_boolean(any_queued_interrupts)); + j["queued_interrupts"] = j_queued_interrupts; + + j["any_queued_interrupts"] = bool(any_queued_interrupts); return j; } -cpu *cpu::deserialize(const json_t *const j, bus *const b, std::atomic_uint32_t *const event) +cpu *cpu::deserialize(const JsonDocument j, bus *const b, std::atomic_uint32_t *const event) { cpu *c = new cpu(b, event); for(int set=0; set<2; set++) { for(int regnr=0; regnr<6; regnr++) - c->regs0_5[set][regnr] = json_integer_value(json_object_get(j, format("register-%d-%d", set, regnr).c_str())); + c->regs0_5[set][regnr] = j[format("register-%d-%d", set, regnr)]; } for(int spnr=0; spnr<4; spnr++) - c->sp[spnr] = json_integer_value(json_object_get(j, format("sp-%d", spnr).c_str())); + c->sp[spnr] = j[format("sp-%d", spnr)]; - c->pc = json_integer_value(json_object_get(j, "pc")); - c->instruction_start = json_integer_value(json_object_get(j, "instruction_start")); - c->psw = json_integer_value(json_object_get(j, "psw")); - c->fpsr = json_integer_value(json_object_get(j, "fpsr")); - c->stackLimitRegister = json_integer_value(json_object_get(j, "stackLimitRegister")); - c->processing_trap_depth = json_integer_value(json_object_get(j, "processing_trap_depth")); - c->instruction_count = json_integer_value(json_object_get(j, "instruction_count")); + c->pc = j["pc"]; + c->instruction_start = j["instruction_start"]; + c->psw = j["psw"]; + c->fpsr = j["fpsr"]; + c->stackLimitRegister = j["stackLimitRegister"]; + c->processing_trap_depth = j["processing_trap_depth"]; + c->instruction_count = j["instruction_count"]; c->running_since = get_us(); c->wait_time = 0; - c->it_is_a_trap = json_boolean_value(json_object_get(j, "it_is_a_trap")); - c->debug_mode = json_boolean_value(json_object_get(j, "debug_mode")); - json_t *temp = json_object_get(j, "trap_delay"); - if (temp) - c->trap_delay = json_integer_value(temp); + c->it_is_a_trap = j["it_is_a_trap"]; + c->debug_mode = j["debug_mode"]; + + if (j.containsKey("trap_delay")) + c->trap_delay = j["trap_delay"]; else c->trap_delay.reset(); - c->any_queued_interrupts = json_boolean_value(json_object_get(j, "any_queued_interrupts")); + + c->any_queued_interrupts = j["any_queued_interrupts"].as(); c->init_interrupt_queue(); - json_t *j_queued_interrupts = json_object_get(j, "queued_interrupts"); for(int level=0; level<8; level++) { auto it = c->queued_interrupts.find(level); - json_t *ja_qi_level = json_object_get(j_queued_interrupts, format("%d", level).c_str()); - - for(size_t i=0; isecond.insert(json_integer_value(json_array_get(ja_qi_level, i))); + JsonArrayConst ja_qi_level = j["queued_interrupts"][format("%d", level)].as(); + for(auto v : ja_qi_level) + it->second.insert(v.as()); } return c; } -#endif diff --git a/cpu.h b/cpu.h index 56e37eb..969db08 100644 --- a/cpu.h +++ b/cpu.h @@ -3,6 +3,7 @@ #pragma once +#include #include #include #include @@ -115,8 +116,8 @@ public: ~cpu(); #if IS_POSIX - json_t *serialize(); - static cpu *deserialize(const json_t *const j, bus *const b, std::atomic_uint32_t *const event); + JsonDocument serialize(); + static cpu *deserialize(const JsonDocument j, bus *const b, std::atomic_uint32_t *const event); #endif std::optional check_breakpoint(); diff --git a/disk_backend_file.cpp b/disk_backend_file.cpp index b8c55c9..3d2446b 100644 --- a/disk_backend_file.cpp +++ b/disk_backend_file.cpp @@ -21,8 +21,7 @@ disk_backend_file::~disk_backend_file() close(fd); } -#if IS_POSIX -json_t *disk_backend_file::serialize() const +JsonDocument disk_backend_file::serialize() const { json_t *j = json_object(); @@ -39,9 +38,9 @@ json_t *disk_backend_file::serialize() const disk_backend_file *disk_backend_file::deserialize(const json_t *const j) { // TODO verify checksum of backend + // TODO overlay return new disk_backend_file(json_string_value(json_object_get(j, "filename"))); } -#endif bool disk_backend_file::begin(const bool snapshots) {