folkert/KEK
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

a few compile fixes

Browse source
This commit is contained in:
folkert van heusden 2024-05-14 19:44:32 +02:00
parent 9cd804f080
commit ccf4b6268f
Signed by untrusted user who does not match committer: folkert
GPG key ID: 6B6455EDFEED3BD1
25 changed files with 102 additions and 110 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
CMakeLists.txt
View file

@ -62,11 +62,6 @@ target_link_libraries(kek ${PANEL_LIBRARIES})
target_include_directories(kek PUBLIC ${PANEL_INCLUDE_DIRS}) target_include_directories(kek PUBLIC ${PANEL_INCLUDE_DIRS})
target_compile_options(kek PUBLIC ${PANEL_CFLAGS_OTHER}) target_compile_options(kek PUBLIC ${PANEL_CFLAGS_OTHER})
pkg_check_modules(JANSSON REQUIRED jansson)
target_link_libraries(kek ${JANSSON_LIBRARIES})
target_include_directories(kek PUBLIC ${JANSSON_INCLUDE_DIRS})
target_compile_options(kek PUBLIC ${JANSSON_CFLAGS_OTHER})
endif (NOT WIN32) endif (NOT WIN32)
if (WIN32) if (WIN32)

1
README.md
View file

@ -11,7 +11,6 @@ To build for e.g. linux:
Required: Required:
* libncursesw5-dev * libncursesw5-dev
* libjansson-dev
To build for e.g. windows: To build for e.g. windows:

14
bus.cpp
View file

@ -81,27 +81,27 @@ bus *bus::deserialize(const JsonDocument j, console *const cnsl, std::atomic_uin
memory *m = nullptr; memory *m = nullptr;
if (j.containsKey("memory")) { if (j.containsKey("memory")) {
m = memory::deserialize(j["memory"].as<JsonDocument>()); m = memory::deserialize(j["memory"].as<JsonVariant>());
b->add_ram(m); b->add_ram(m);
} }
if (j.containsKey("kw11-l")) if (j.containsKey("kw11-l"))
b->add_KW11_L(kw11_l::deserialize(j["kw11-l"].as<JsonDocument>(), b, cnsl)); b->add_KW11_L(kw11_l::deserialize(j["kw11-l"].as<JsonVariant>(), b, cnsl));
if (j.containsKey("tty")) if (j.containsKey("tty"))
b->add_tty(tty::deserialize(j["tty"].as<JsonDocument>(), b, cnsl)); b->add_tty(tty::deserialize(j["tty"].as<JsonVariant>(), b, cnsl));
if (j.containsKey("mmu")) if (j.containsKey("mmu"))
b->add_mmu(mmu::deserialize(j["mmu"].as<JsonDocument>(), m)); b->add_mmu(mmu::deserialize(j["mmu"].as<JsonVariant>(), m));
if (j.containsKey("cpu")) if (j.containsKey("cpu"))
b->add_cpu(cpu::deserialize(j["cpu"].as<JsonDocument>(), b, event)); b->add_cpu(cpu::deserialize(j["cpu"].as<JsonVariant>(), b, event));
if (j.containsKey("rl02")) if (j.containsKey("rl02"))
b->add_rl02(rl02::deserialize(j["rl02"].as<JsonDocument>(), b)); b->add_rl02(rl02::deserialize(j["rl02"].as<JsonVariant>(), b));
if (j.containsKey("rk05")) if (j.containsKey("rk05"))
b->add_rk05(rk05::deserialize(j["rk05"].as<JsonDocument>(), b)); b->add_rk05(rk05::deserialize(j["rk05"].as<JsonVariant>(), b));
// TODO: tm11, dc11 // TODO: tm11, dc11

8
cpu.cpp
View file

@ -2434,9 +2434,9 @@ void cpu::step()
} }
} }
JsonDocument cpu::serialize() JsonVariant cpu::serialize()
{ {
JsonDocument j; JsonVariant j;
for(int set=0; set<2; set++) { for(int set=0; set<2; set++) {
for(int regnr=0; regnr<6; regnr++) for(int regnr=0; regnr<6; regnr++)
@ -2461,7 +2461,7 @@ JsonDocument cpu::serialize()
if (trap_delay.has_value()) if (trap_delay.has_value())
j["trap_delay"] = trap_delay.value(); j["trap_delay"] = trap_delay.value();
JsonDocument j_queued_interrupts; JsonVariant j_queued_interrupts;
for(auto & il: queued_interrupts) { for(auto & il: queued_interrupts) {
JsonArray ja_qi_level; JsonArray ja_qi_level;
for(auto v: il.second) for(auto v: il.second)
@ -2477,7 +2477,7 @@ JsonDocument cpu::serialize()
return j; return j;
} }
cpu *cpu::deserialize(const JsonDocument j, bus *const b, std::atomic_uint32_t *const event) cpu *cpu::deserialize(const JsonVariant j, bus *const b, std::atomic_uint32_t *const event)
{ {
cpu *c = new cpu(b, event); cpu *c = new cpu(b, event);

4
cpu.h
View file

@ -115,8 +115,8 @@ public:
explicit cpu(bus *const b, std::atomic_uint32_t *const event); explicit cpu(bus *const b, std::atomic_uint32_t *const event);
~cpu(); ~cpu();
JsonDocument serialize(); JsonVariant serialize();
static cpu *deserialize(const JsonDocument j, bus *const b, std::atomic_uint32_t *const event); static cpu *deserialize(const JsonVariant j, bus *const b, std::atomic_uint32_t *const event);
std::optional<std::string> check_breakpoint(); std::optional<std::string> check_breakpoint();
int set_breakpoint(breakpoint *const bp); int set_breakpoint(breakpoint *const bp);

2
debugger.cpp
View file

@ -548,7 +548,7 @@ struct state_writer {
void serialize_state(console *const cnsl, const bus *const b, const std::string & filename) void serialize_state(console *const cnsl, const bus *const b, const std::string & filename)
{ {
JsonDocument j = b->serialize(); JsonVariant j = b->serialize();
bool ok = false; bool ok = false;

29
disk_backend.cpp
View file

@ -58,12 +58,12 @@ bool disk_backend::store_mem_range_in_overlay(const off_t offset, const size_t n
return false; return false;
} }
JsonDocument disk_backend::serialize_overlay() const JsonVariant disk_backend::serialize_overlay() const
{ {
JsonDocument out; JsonVariant out;
for(auto & id: overlay) { for(auto & id: overlay) {
JsonDocument j_data; JsonVariant j_data;
for(size_t i=0; i<id.second.size(); i++) for(size_t i=0; i<id.second.size(); i++)
j_data.add(id.second.at(i)); j_data.add(id.second.at(i));
@ -74,28 +74,25 @@ JsonDocument disk_backend::serialize_overlay() const
return out; return out;
} }
void disk_backend::deserialize_overlay(const json_t *const j) void disk_backend::deserialize_overlay(const JsonVariant j)
{ {
json_t *input = json_object_get(j, "overlay"); if (j.containsKey("overlay") == false)
if (!input) // we can have state-dumps without overlay return; // we can have state-dumps without overlay
return;
const char *key = nullptr; for(auto kv : j.as<JsonObject>()) {
json_t *value = nullptr; uint32_t id = std::atoi(kv.key().c_str());
json_object_foreach(input, key, value) {
uint32_t id = std::atoi(key);
std::vector<uint8_t> data; std::vector<uint8_t> data;
for(size_t i=0; i<json_array_size(value); i++) for(auto v: kv.value().as<JsonArray>())
data.push_back(json_integer_value(json_array_get(value, i))); data.push_back(v);
store_object_in_overlay(id, data); store_object_in_overlay(id, data);
} }
} }
disk_backend *disk_backend::deserialize(const json_t *const j) disk_backend *disk_backend::deserialize(const JsonVariant j)
{ {
std::string type = json_string_value(json_object_get(j, "disk-backend-type")); std::string type = j["disk-backend-type"];
disk_backend *d = nullptr; disk_backend *d = nullptr;
@ -105,7 +102,7 @@ disk_backend *disk_backend::deserialize(const json_t *const j)
else if (type == "nbd") else if (type == "nbd")
d = disk_backend_nbd::deserialize(j); d = disk_backend_nbd::deserialize(j);
// should not be reached // should not be triggered
assert(d); assert(d);
d->deserialize_overlay(j); d->deserialize_overlay(j);

8
disk_backend.h
View file

@ -25,15 +25,15 @@ protected:
std::optional<std::vector<uint8_t> > get_object_from_overlay(const off_t id); std::optional<std::vector<uint8_t> > get_object_from_overlay(const off_t id);
std::optional<std::vector<uint8_t> > get_from_overlay(const off_t offset, const size_t sector_size); std::optional<std::vector<uint8_t> > get_from_overlay(const off_t offset, const size_t sector_size);
JsonDocument serialize_overlay() const; JsonVariant serialize_overlay() const;
void deserialize_overlay(const JsonDocument j); void deserialize_overlay(const JsonVariant j);
public: public:
disk_backend(); disk_backend();
virtual ~disk_backend(); virtual ~disk_backend();
virtual JsonDocument serialize() const = 0; virtual JsonVariant serialize() const = 0;
static disk_backend *deserialize(const JsonDocument j); static disk_backend *deserialize(const JsonVariant j);
virtual std::string get_identifier() const = 0; virtual std::string get_identifier() const = 0;

8
disk_backend_file.cpp
View file

@ -21,9 +21,9 @@ disk_backend_file::~disk_backend_file()
close(fd); close(fd);
} }
JsonDocument disk_backend_file::serialize() const JsonVariant disk_backend_file::serialize() const
{ {
JsonDocument j; JsonVariant j;
j["disk-backend-type"] = "file"; j["disk-backend-type"] = "file";
@ -36,11 +36,11 @@ JsonDocument disk_backend_file::serialize() const
return j; return j;
} }
disk_backend_file *disk_backend_file::deserialize(const JsonDocument j) disk_backend_file *disk_backend_file::deserialize(const JsonVariant j)
{ {
// TODO verify checksum of backend // TODO verify checksum of backend
// TODO overlay // TODO overlay
return new disk_backend_file(j["filename"]); return new disk_backend_file(j["filename"].as<std::string>());
} }
bool disk_backend_file::begin(const bool snapshots) bool disk_backend_file::begin(const bool snapshots)

4
disk_backend_file.h
View file

@ -18,8 +18,8 @@ public:
disk_backend_file(const std::string & filename); disk_backend_file(const std::string & filename);
virtual ~disk_backend_file(); virtual ~disk_backend_file();
JsonDocument serialize() const override; JsonVariant serialize() const override;
static disk_backend_file *deserialize(const JsonDocument j); static disk_backend_file *deserialize(const JsonVariant j);
std::string get_identifier() const override { return filename; } std::string get_identifier() const override { return filename; }

18
disk_backend_nbd.cpp
View file

@ -48,28 +48,26 @@ disk_backend_nbd::~disk_backend_nbd()
close(fd); close(fd);
} }
#if IS_POSIX JsonVariant disk_backend_nbd::serialize() const
json_t *disk_backend_nbd::serialize() const
{ {
json_t *j = json_object(); JsonVariant j;
json_object_set(j, "disk-backend-type", json_string("nbd")); j["disk-backend-type"] = "nbd";
json_object_set(j, "overlay", serialize_overlay()); j["overlay"] = serialize_overlay();
// TODO store checksum of backend // TODO store checksum of backend
json_object_set(j, "host", json_string(host.c_str())); j["host"] = host.c_str();
json_object_set(j, "port", json_integer(port)); j["port"] = port;
return j; return j;
} }
disk_backend_nbd *disk_backend_nbd::deserialize(const json_t *const j) disk_backend_nbd *disk_backend_nbd::deserialize(const JsonVariant j)
{ {
// TODO verify checksum of backend // TODO verify checksum of backend
return new disk_backend_nbd(json_string_value(json_object_get(j, "host")), json_integer_value(json_object_get(j, "port"))); return new disk_backend_nbd(j["host"], j["port"]);
} }
#endif
bool disk_backend_nbd::begin(const bool snapshots) bool disk_backend_nbd::begin(const bool snapshots)
{ {

6
disk_backend_nbd.h
View file

@ -22,10 +22,8 @@ public:
disk_backend_nbd(const std::string & host, const unsigned port); disk_backend_nbd(const std::string & host, const unsigned port);
virtual ~disk_backend_nbd(); virtual ~disk_backend_nbd();
#if IS_POSIX JsonVariant serialize() const override;
json_t *serialize() const override; static disk_backend_nbd *deserialize(const JsonVariant j);
static disk_backend_nbd *deserialize(const json_t *const j);
#endif
std::string get_identifier() const override { return format("%s:%d", host.c_str(), port); } std::string get_identifier() const override { return format("%s:%d", host.c_str(), port); }

6
kw11-l.cpp
View file

@ -216,16 +216,16 @@ uint8_t kw11_l::get_lf_crs()
return rc; return rc;
} }
JsonDocument kw11_l::serialize() JsonVariant kw11_l::serialize()
{ {
JsonDocument j; JsonVariant j;
j["CSR"] = lf_csr; j["CSR"] = lf_csr;
return j; return j;
} }
kw11_l *kw11_l::deserialize(const json_t *const j, bus *const b, console *const cnsl) kw11_l *kw11_l::deserialize(const JsonVariant j, bus *const b, console *const cnsl)
{ {
uint16_t CSR = j["CSR"]; uint16_t CSR = j["CSR"];

4
kw11-l.h
View file

@ -43,8 +43,8 @@ public:
void show_state(console *const cnsl) const override; void show_state(console *const cnsl) const override;
JsonDocument serialize(); JsonVariant serialize();
static kw11_l *deserialize(const JsonDocument j, bus *const b, console *const cnsl); static kw11_l *deserialize(const JsonVariant j, bus *const b, console *const cnsl);
void begin(console *const cnsl); void begin(console *const cnsl);
void operator()(); void operator()();

21
main.cpp
View file

@ -567,27 +567,32 @@ int main(int argc, char *argv[])
if (enable_bootloader) if (enable_bootloader)
set_boot_loader(b, bootloader); set_boot_loader(b, bootloader);
} }
#if IS_POSIX
else { else {
FILE *fh = fopen(deserialize.c_str(), "r"); FILE *fh = fopen(deserialize.c_str(), "r");
if (!fh) if (!fh)
error_exit(true, "Failed to open %s", deserialize.c_str()); error_exit(true, "Failed to open %s", deserialize.c_str());
json_error_t je { }; std::string j_in;
json_t *j = json_loadf(fh, 0, &je); char buffer[4096];
for(;;) {
char *rc = fgets(buffer, sizeof buffer, fh);
if (!rc)
break;
j_in += buffer;
}
fclose(fh); fclose(fh);
if (!j) JsonDocument j;
error_exit(true, "State file %s is corrupt: %s", deserialize.c_str(), je.text); DeserializationError error = deserializeJson(j, j_in);
if (error)
error_exit(true, "State file %s is corrupt: %s", error.c_str());
b = bus::deserialize(j, cnsl, &event); b = bus::deserialize(j, cnsl, &event);
json_decref(j);
myusleep(251000); myusleep(251000);
} }
#endif
if (b->getTty() == nullptr) { if (b->getTty() == nullptr) {
tty *tty_ = new tty(cnsl, b); tty *tty_ = new tty(cnsl, b);

6
memory.cpp
View file

@ -40,9 +40,9 @@ void memory::reset()
memset(m, 0x00, size); memset(m, 0x00, size);
} }
JsonDocument memory::serialize() const JsonVariant memory::serialize() const
{ {
JsonDocument j; JsonVariant j;
j["size"] = size; j["size"] = size;
@ -54,7 +54,7 @@ JsonDocument memory::serialize() const
return j; return j;
} }
memory *memory::deserialize(const JsonDocument j) memory *memory::deserialize(const JsonVariant j)
{ {
size_t size = j["size"]; size_t size = j["size"];
memory *m = new memory(size); memory *m = new memory(size);

4
memory.h
View file

@ -22,8 +22,8 @@ public:
void reset(); void reset();
JsonDocument serialize() const; JsonVariant serialize() const;
static memory *deserialize(const JsonDocument j); static memory *deserialize(const JsonVariant j);
uint16_t read_byte(const uint32_t a) const { return m[a]; } uint16_t read_byte(const uint32_t a) const { return m[a]; }
void write_byte(const uint32_t a, const uint16_t v) { if (a < size) m[a] = v; } void write_byte(const uint32_t a, const uint16_t v) { if (a < size) m[a] = v; }

18
mmu.cpp
View file

@ -504,9 +504,9 @@ uint32_t mmu::calculate_physical_address(cpu *const c, const int run_mode, const
return m_offset; return m_offset;
} }
JsonDocument mmu::add_par_pdr(const int run_mode, const bool is_d) const JsonVariant mmu::add_par_pdr(const int run_mode, const bool is_d) const
{ {
JsonDocument j; JsonVariant j;
JsonArray ja_par; JsonArray ja_par;
for(int i=0; i<8; i++) for(int i=0; i<8; i++)
@ -521,9 +521,9 @@ JsonDocument mmu::add_par_pdr(const int run_mode, const bool is_d) const
return j; return j;
} }
JsonDocument mmu::serialize() const JsonVariant mmu::serialize() const
{ {
JsonDocument j; JsonVariant j;
for(int run_mode=0; run_mode<4; run_mode++) { for(int run_mode=0; run_mode<4; run_mode++) {
if (run_mode == 2) if (run_mode == 2)
@ -544,20 +544,20 @@ JsonDocument mmu::serialize() const
return j; return j;
} }
void mmu::set_par_pdr(const JsonDocument j_in, const int run_mode, const bool is_d) void mmu::set_par_pdr(const JsonVariant j_in, const int run_mode, const bool is_d)
{ {
JsonArray j_par = j_in["par"]; JsonArray j_par = j_in["par"];
int i_par = 0; int i_par = 0;
for(auto & v: j_par) for(auto v: j_par)
pages[run_mode][is_d][i_par++].par = v; pages[run_mode][is_d][i_par++].par = v;
JsonArray j_pdr = j_in["pdr"]; JsonArray j_pdr = j_in["pdr"];
int i_pdr = 0; int i_pdr = 0;
for(auto & v: j_pdr) for(auto v: j_pdr)
pages[run_mode][is_d][i_pdr++].pdr = v; pages[run_mode][is_d][i_pdr++].pdr = v;
} }
mmu *mmu::deserialize(const JsonDocument j, memory *const mem) mmu *mmu::deserialize(const JsonVariant j, memory *const mem)
{ {
mmu *m = new mmu(); mmu *m = new mmu();
m->begin(mem); m->begin(mem);
@ -567,7 +567,7 @@ mmu *mmu::deserialize(const JsonDocument j, memory *const mem)
continue; continue;
for(int is_d=0; is_d<2; is_d++) for(int is_d=0; is_d<2; is_d++)
m->set_par_pdr(j[format("runmode_%d_d_%d", run_mode, is_d)].as<JsonDocument>(), run_mode, is_d); m->set_par_pdr(j[format("runmode_%d_d_%d", run_mode, is_d)].as<JsonVariant>(), run_mode, is_d);
} }
m->MMR0 = j["MMR0"]; m->MMR0 = j["MMR0"];

8
mmu.h
View file

@ -58,8 +58,8 @@ private:
memory *m { nullptr }; memory *m { nullptr };
JsonDocument add_par_pdr(const int run_mode, const bool is_d) const; JsonVariant add_par_pdr(const int run_mode, const bool is_d) const;
void set_par_pdr(const JsonDocument j_in, const int run_mode, const bool is_d); void set_par_pdr(const JsonVariant j_in, const int run_mode, const bool is_d);
void verify_page_access (cpu *const c, const uint16_t virt_addr, const int run_mode, const bool d, const int apf, const bool is_write); void verify_page_access (cpu *const c, const uint16_t virt_addr, const int run_mode, const bool d, const int apf, const bool is_write);
void verify_access_valid(cpu *const c, const uint32_t m_offset, const int run_mode, const bool d, const int apf, const bool is_io, const bool is_write); void verify_access_valid(cpu *const c, const uint32_t m_offset, const int run_mode, const bool d, const int apf, const bool is_io, const bool is_write);
@ -71,8 +71,8 @@ public:
void begin(memory *const m); void begin(memory *const m);
JsonDocument serialize() const; JsonVariant serialize() const;
static mmu *deserialize(const JsonDocument j, memory *const m); static mmu *deserialize(const JsonVariant j, memory *const m);
void mmudebug(const uint16_t a); void mmudebug(const uint16_t a);

8
rk05.cpp
View file

@ -281,9 +281,9 @@ void rk05::write_word(const uint16_t addr, const uint16_t v)
} }
} }
JsonDocument rk05::serialize() const JsonVariant rk05::serialize() const
{ {
JsonDocument j; JsonVariant j;
JsonArray j_backends; JsonArray j_backends;
for(auto & dbe: fhs) for(auto & dbe: fhs)
@ -296,12 +296,12 @@ JsonDocument rk05::serialize() const
return j; return j;
} }
rk05 *rk05::deserialize(const JsonDocument j, bus *const b) rk05 *rk05::deserialize(const JsonVariant j, bus *const b)
{ {
rk05 *r = new rk05(b, nullptr, nullptr); rk05 *r = new rk05(b, nullptr, nullptr);
r->begin(); r->begin();
for(auto j_backend: j["backends"]) for(auto j_backend: j["backends"].as<JsonArray>())
r->access_disk_backends()->push_back(disk_backend::deserialize(j_backend)); r->access_disk_backends()->push_back(disk_backend::deserialize(j_backend));
for(int regnr=0; regnr<7; regnr++) for(int regnr=0; regnr<7; regnr++)

4
rk05.h
View file

@ -49,8 +49,8 @@ public:
void show_state(console *const cnsl) const override; void show_state(console *const cnsl) const override;
JsonDocument serialize() const; JsonVariant serialize() const;
static rk05 *deserialize(const JsonDocument j, bus *const b); static rk05 *deserialize(const JsonVariant j, bus *const b);
uint8_t read_byte(const uint16_t addr) override; uint8_t read_byte(const uint16_t addr) override;
uint16_t read_word(const uint16_t addr) override; uint16_t read_word(const uint16_t addr) override;

8
rl02.cpp
View file

@ -72,9 +72,9 @@ void rl02::show_state(console *const cnsl) const
cnsl->put_string_lf(format("sector: %d", sector)); cnsl->put_string_lf(format("sector: %d", sector));
} }
JsonDocument rl02::serialize() const JsonVariant rl02::serialize() const
{ {
JsonDocument j; JsonVariant j;
JsonArray j_backends; JsonArray j_backends;
for(auto & dbe: fhs) for(auto & dbe: fhs)
@ -94,13 +94,13 @@ JsonDocument rl02::serialize() const
return j; return j;
} }
rl02 *rl02::deserialize(const JsonDocument j, bus *const b) rl02 *rl02::deserialize(const JsonVariant j, bus *const b)
{ {
rl02 *r = new rl02(b, nullptr, nullptr); rl02 *r = new rl02(b, nullptr, nullptr);
r->begin(); r->begin();
JsonArray j_backends = j["backends"]; JsonArray j_backends = j["backends"];
for(auto & v: j_backends) for(auto v: j_backends)
r->access_disk_backends()->push_back(disk_backend::deserialize(v)); r->access_disk_backends()->push_back(disk_backend::deserialize(v));
for(int regnr=0; regnr<4; regnr++) for(int regnr=0; regnr<4; regnr++)

4
rl02.h
View file

@ -56,8 +56,8 @@ public:
void show_state(console *const cnsl) const override; void show_state(console *const cnsl) const override;
JsonDocument serialize() const; JsonVariant serialize() const;
static rl02 *deserialize(const JsonDocument j, bus *const b); static rl02 *deserialize(const JsonVariant j, bus *const b);
uint8_t read_byte(const uint16_t addr) override; uint8_t read_byte(const uint16_t addr) override;
uint16_t read_word(const uint16_t addr) override; uint16_t read_word(const uint16_t addr) override;

10
tty.cpp
View file

@ -194,9 +194,9 @@ void tty::write_word(const uint16_t addr, uint16_t v)
registers[(addr - PDP11TTY_BASE) / 2] = v; registers[(addr - PDP11TTY_BASE) / 2] = v;
} }
JsonDocument tty::serialize() JsonVariant tty::serialize()
{ {
JsonDocument j; JsonVariant j;
JsonArray ja_reg; JsonArray ja_reg;
for(size_t i=0; i<4; i++) for(size_t i=0; i<4; i++)
@ -205,13 +205,13 @@ JsonDocument tty::serialize()
JsonArray ja_buf; JsonArray ja_buf;
for(auto c: chars) for(auto c: chars)
ja_buf.add(c); ja_buf.add(static_cast<signed char>(c));
j["input-buffer"] = ja_buf; j["input-buffer"] = ja_buf;
return j; return j;
} }
tty *tty::deserialize(const json_t *const j, bus *const b, console *const cnsl) tty *tty::deserialize(const JsonVariant j, bus *const b, console *const cnsl)
{ {
tty *out = new tty(cnsl, b); tty *out = new tty(cnsl, b);
@ -222,7 +222,7 @@ tty *tty::deserialize(const json_t *const j, bus *const b, console *const cnsl)
JsonArray ja_buf = j["input-buffer"]; JsonArray ja_buf = j["input-buffer"];
for(auto v: ja_buf) for(auto v: ja_buf)
out->chars.push_back(v); out->chars.push_back(v.as<signed char>());
return out; return out;
} }

4
tty.h
View file

@ -52,8 +52,8 @@ public:
tty(console *const c, bus *const b); tty(console *const c, bus *const b);
virtual ~tty(); virtual ~tty();
JsonDocument serialize(); JsonVariant serialize();
static tty *deserialize(const JsonDocument j, bus *const b, console *const cnsl); static tty *deserialize(const JsonVariant j, bus *const b, console *const cnsl);
void reset(); void reset();