diff --git a/page/public/emulator-worker.js b/page/public/emulator-worker.js index a4983757..91f9725f 100644 --- a/page/public/emulator-worker.js +++ b/page/public/emulator-worker.js @@ -1,11 +1,16 @@ var logLines = []; var lastFlush = new Date().getTime(); +var msgQueue = []; + onmessage = async (event) => { const data = event.data; if (data.message == "run") { const payload = data.data; runEmulation(payload.filesystem, payload.file, payload.options); + } else if (data.message == "event") { + const payload = data.data; + msgQueue.push(payload); } }; @@ -32,14 +37,8 @@ function notifyExit(code) { self.close(); } -var msgQueue = []; - -setInterval(() => { - msgQueue.push("OI YEAH BABY :D"); -}, 2100); - function handleMessage(message) { - console.log("MSG from C++: " + message); + postMessage({ message: "event", data: message }); } function getMessageFromQueue() { @@ -52,9 +51,9 @@ function getMessageFromQueue() { function runEmulation(filesystem, file, options) { globalThis.Module = { - arguments: [...options, "-e", "./root", file], + arguments: ["./root", file], onRuntimeInitialized: function () { - /*filesystem.forEach((e) => { + filesystem.forEach((e) => { if (e.name.endsWith("/")) { FS.mkdir(e.name.slice(0, -1)); } else { @@ -66,7 +65,7 @@ function runEmulation(filesystem, file, options) { } FS.createDataFile("/" + dirs.join("/"), file, buffer, true, true); } - });*/ + }); }, print: logLine, printErr: logLine, diff --git a/page/src/Playground.tsx b/page/src/Playground.tsx index e86061e7..6e018ef5 100644 --- a/page/src/Playground.tsx +++ b/page/src/Playground.tsx @@ -116,6 +116,9 @@ export function Playground() { + diff --git a/page/src/emulator.ts b/page/src/emulator.ts index 0ea8fc5b..61a0024f 100644 --- a/page/src/emulator.ts +++ b/page/src/emulator.ts @@ -112,6 +112,24 @@ export class Emulator { }); } + pause() { + this.sendEvent( + new fbDebugger.DebugEventT( + fbDebugger.Event.PauseRequest, + new fbDebugger.PauseRequestT(), + ), + ); + } + + resume() { + this.sendEvent( + new fbDebugger.DebugEventT( + fbDebugger.Event.RunRequest, + new fbDebugger.RunRequestT(), + ), + ); + } + _onMessage(event: MessageEvent) { if (event.data.message == "log") { this.logHandler(event.data.data); diff --git a/page/src/fb/debugger.ts b/page/src/fb/debugger.ts index 347b04f6..ffde813b 100644 --- a/page/src/fb/debugger.ts +++ b/page/src/fb/debugger.ts @@ -4,5 +4,8 @@ export { DebugEvent, DebugEventT } from './debugger/debug-event.js'; export { Event } from './debugger/event.js'; -export { PauseEvent, PauseEventT } from './debugger/pause-event.js'; -export { RunEvent, RunEventT } from './debugger/run-event.js'; +export { GetStateRequest, GetStateRequestT } from './debugger/get-state-request.js'; +export { GetStateResponse, GetStateResponseT } from './debugger/get-state-response.js'; +export { PauseRequest, PauseRequestT } from './debugger/pause-request.js'; +export { RunRequest, RunRequestT } from './debugger/run-request.js'; +export { State } from './debugger/state.js'; diff --git a/page/src/fb/debugger/debug-event.ts b/page/src/fb/debugger/debug-event.ts index a34e10e9..96367434 100644 --- a/page/src/fb/debugger/debug-event.ts +++ b/page/src/fb/debugger/debug-event.ts @@ -5,8 +5,10 @@ import * as flatbuffers from 'flatbuffers'; import { Event, unionToEvent, unionListToEvent } from '../debugger/event.js'; -import { PauseEvent, PauseEventT } from '../debugger/pause-event.js'; -import { RunEvent, RunEventT } from '../debugger/run-event.js'; +import { GetStateRequest, GetStateRequestT } from '../debugger/get-state-request.js'; +import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-response.js'; +import { PauseRequest, PauseRequestT } from '../debugger/pause-request.js'; +import { RunRequest, RunRequestT } from '../debugger/run-request.js'; export class DebugEvent implements flatbuffers.IUnpackableObject { @@ -94,7 +96,7 @@ unpackTo(_o: DebugEventT): void { export class DebugEventT implements flatbuffers.IGeneratedObject { constructor( public eventType: Event = Event.NONE, - public event: PauseEventT|RunEventT|null = null + public event: GetStateRequestT|GetStateResponseT|PauseRequestT|RunRequestT|null = null ){} diff --git a/page/src/fb/debugger/event.ts b/page/src/fb/debugger/event.ts index 1949c08e..6d5d0bbb 100644 --- a/page/src/fb/debugger/event.ts +++ b/page/src/fb/debugger/event.ts @@ -2,37 +2,45 @@ /* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ -import { PauseEvent, PauseEventT } from '../debugger/pause-event.js'; -import { RunEvent, RunEventT } from '../debugger/run-event.js'; +import { GetStateRequest, GetStateRequestT } from '../debugger/get-state-request.js'; +import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-response.js'; +import { PauseRequest, PauseRequestT } from '../debugger/pause-request.js'; +import { RunRequest, RunRequestT } from '../debugger/run-request.js'; export enum Event { NONE = 0, - PauseEvent = 1, - RunEvent = 2 + PauseRequest = 1, + RunRequest = 2, + GetStateRequest = 3, + GetStateResponse = 4 } export function unionToEvent( type: Event, - accessor: (obj:PauseEvent|RunEvent) => PauseEvent|RunEvent|null -): PauseEvent|RunEvent|null { + accessor: (obj:GetStateRequest|GetStateResponse|PauseRequest|RunRequest) => GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null +): GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null { switch(Event[type]) { case 'NONE': return null; - case 'PauseEvent': return accessor(new PauseEvent())! as PauseEvent; - case 'RunEvent': return accessor(new RunEvent())! as RunEvent; + case 'PauseRequest': return accessor(new PauseRequest())! as PauseRequest; + case 'RunRequest': return accessor(new RunRequest())! as RunRequest; + case 'GetStateRequest': return accessor(new GetStateRequest())! as GetStateRequest; + case 'GetStateResponse': return accessor(new GetStateResponse())! as GetStateResponse; default: return null; } } export function unionListToEvent( type: Event, - accessor: (index: number, obj:PauseEvent|RunEvent) => PauseEvent|RunEvent|null, + accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|RunRequest) => GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null, index: number -): PauseEvent|RunEvent|null { +): GetStateRequest|GetStateResponse|PauseRequest|RunRequest|null { switch(Event[type]) { case 'NONE': return null; - case 'PauseEvent': return accessor(index, new PauseEvent())! as PauseEvent; - case 'RunEvent': return accessor(index, new RunEvent())! as RunEvent; + case 'PauseRequest': return accessor(index, new PauseRequest())! as PauseRequest; + case 'RunRequest': return accessor(index, new RunRequest())! as RunRequest; + case 'GetStateRequest': return accessor(index, new GetStateRequest())! as GetStateRequest; + case 'GetStateResponse': return accessor(index, new GetStateResponse())! as GetStateResponse; default: return null; } } diff --git a/page/src/fb/debugger/get-state-request.ts b/page/src/fb/debugger/get-state-request.ts new file mode 100644 index 00000000..8ec9ff10 --- /dev/null +++ b/page/src/fb/debugger/get-state-request.ts @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + + + +export class GetStateRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):GetStateRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsGetStateRequest(bb:flatbuffers.ByteBuffer, obj?:GetStateRequest):GetStateRequest { + return (obj || new GetStateRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsGetStateRequest(bb:flatbuffers.ByteBuffer, obj?:GetStateRequest):GetStateRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new GetStateRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startGetStateRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endGetStateRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createGetStateRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + GetStateRequest.startGetStateRequest(builder); + return GetStateRequest.endGetStateRequest(builder); +} + +unpack(): GetStateRequestT { + return new GetStateRequestT(); +} + + +unpackTo(_o: GetStateRequestT): void {} +} + +export class GetStateRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return GetStateRequest.createGetStateRequest(builder); +} +} diff --git a/page/src/fb/debugger/get-state-response.ts b/page/src/fb/debugger/get-state-response.ts new file mode 100644 index 00000000..f429791b --- /dev/null +++ b/page/src/fb/debugger/get-state-response.ts @@ -0,0 +1,86 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + +import { State } from '../debugger/state.js'; + + +export class GetStateResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):GetStateResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsGetStateResponse(bb:flatbuffers.ByteBuffer, obj?:GetStateResponse):GetStateResponse { + return (obj || new GetStateResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsGetStateResponse(bb:flatbuffers.ByteBuffer, obj?:GetStateResponse):GetStateResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new GetStateResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +state():State { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : State.None; +} + +mutate_state(value:State):boolean { + const offset = this.bb!.__offset(this.bb_pos, 4); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint32(this.bb_pos + offset, value); + return true; +} + +static startGetStateResponse(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addState(builder:flatbuffers.Builder, state:State) { + builder.addFieldInt32(0, state, State.None); +} + +static endGetStateResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createGetStateResponse(builder:flatbuffers.Builder, state:State):flatbuffers.Offset { + GetStateResponse.startGetStateResponse(builder); + GetStateResponse.addState(builder, state); + return GetStateResponse.endGetStateResponse(builder); +} + +unpack(): GetStateResponseT { + return new GetStateResponseT( + this.state() + ); +} + + +unpackTo(_o: GetStateResponseT): void { + _o.state = this.state(); +} +} + +export class GetStateResponseT implements flatbuffers.IGeneratedObject { +constructor( + public state: State = State.None +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return GetStateResponse.createGetStateResponse(builder, + this.state + ); +} +} diff --git a/page/src/fb/debugger/pause-event.ts b/page/src/fb/debugger/pause-event.ts deleted file mode 100644 index ea56222b..00000000 --- a/page/src/fb/debugger/pause-event.ts +++ /dev/null @@ -1,56 +0,0 @@ -// automatically generated by the FlatBuffers compiler, do not modify - -/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ - -import * as flatbuffers from 'flatbuffers'; - - - -export class PauseEvent implements flatbuffers.IUnpackableObject { - bb: flatbuffers.ByteBuffer|null = null; - bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):PauseEvent { - this.bb_pos = i; - this.bb = bb; - return this; -} - -static getRootAsPauseEvent(bb:flatbuffers.ByteBuffer, obj?:PauseEvent):PauseEvent { - return (obj || new PauseEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static getSizePrefixedRootAsPauseEvent(bb:flatbuffers.ByteBuffer, obj?:PauseEvent):PauseEvent { - bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new PauseEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb); -} - -static startPauseEvent(builder:flatbuffers.Builder) { - builder.startObject(0); -} - -static endPauseEvent(builder:flatbuffers.Builder):flatbuffers.Offset { - const offset = builder.endObject(); - return offset; -} - -static createPauseEvent(builder:flatbuffers.Builder):flatbuffers.Offset { - PauseEvent.startPauseEvent(builder); - return PauseEvent.endPauseEvent(builder); -} - -unpack(): PauseEventT { - return new PauseEventT(); -} - - -unpackTo(_o: PauseEventT): void {} -} - -export class PauseEventT implements flatbuffers.IGeneratedObject { -constructor(){} - - -pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return PauseEvent.createPauseEvent(builder); -} -} diff --git a/page/src/fb/debugger/pause-request.ts b/page/src/fb/debugger/pause-request.ts new file mode 100644 index 00000000..1aa4564c --- /dev/null +++ b/page/src/fb/debugger/pause-request.ts @@ -0,0 +1,56 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +import * as flatbuffers from 'flatbuffers'; + + + +export class PauseRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):PauseRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsPauseRequest(bb:flatbuffers.ByteBuffer, obj?:PauseRequest):PauseRequest { + return (obj || new PauseRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsPauseRequest(bb:flatbuffers.ByteBuffer, obj?:PauseRequest):PauseRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new PauseRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static startPauseRequest(builder:flatbuffers.Builder) { + builder.startObject(0); +} + +static endPauseRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createPauseRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + PauseRequest.startPauseRequest(builder); + return PauseRequest.endPauseRequest(builder); +} + +unpack(): PauseRequestT { + return new PauseRequestT(); +} + + +unpackTo(_o: PauseRequestT): void {} +} + +export class PauseRequestT implements flatbuffers.IGeneratedObject { +constructor(){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return PauseRequest.createPauseRequest(builder); +} +} diff --git a/page/src/fb/debugger/run-event.ts b/page/src/fb/debugger/run-request.ts similarity index 51% rename from page/src/fb/debugger/run-event.ts rename to page/src/fb/debugger/run-request.ts index 9502e4d5..d974c1ae 100644 --- a/page/src/fb/debugger/run-event.ts +++ b/page/src/fb/debugger/run-request.ts @@ -6,22 +6,22 @@ import * as flatbuffers from 'flatbuffers'; -export class RunEvent implements flatbuffers.IUnpackableObject { +export class RunRequest implements flatbuffers.IUnpackableObject { bb: flatbuffers.ByteBuffer|null = null; bb_pos = 0; - __init(i:number, bb:flatbuffers.ByteBuffer):RunEvent { + __init(i:number, bb:flatbuffers.ByteBuffer):RunRequest { this.bb_pos = i; this.bb = bb; return this; } -static getRootAsRunEvent(bb:flatbuffers.ByteBuffer, obj?:RunEvent):RunEvent { - return (obj || new RunEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +static getRootAsRunRequest(bb:flatbuffers.ByteBuffer, obj?:RunRequest):RunRequest { + return (obj || new RunRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } -static getSizePrefixedRootAsRunEvent(bb:flatbuffers.ByteBuffer, obj?:RunEvent):RunEvent { +static getSizePrefixedRootAsRunRequest(bb:flatbuffers.ByteBuffer, obj?:RunRequest):RunRequest { bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); - return (obj || new RunEvent()).__init(bb.readInt32(bb.position()) + bb.position(), bb); + return (obj || new RunRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); } singleStep():boolean { @@ -40,7 +40,7 @@ mutate_single_step(value:boolean):boolean { return true; } -static startRunEvent(builder:flatbuffers.Builder) { +static startRunRequest(builder:flatbuffers.Builder) { builder.startObject(1); } @@ -48,37 +48,37 @@ static addSingleStep(builder:flatbuffers.Builder, singleStep:boolean) { builder.addFieldInt8(0, +singleStep, +false); } -static endRunEvent(builder:flatbuffers.Builder):flatbuffers.Offset { +static endRunRequest(builder:flatbuffers.Builder):flatbuffers.Offset { const offset = builder.endObject(); return offset; } -static createRunEvent(builder:flatbuffers.Builder, singleStep:boolean):flatbuffers.Offset { - RunEvent.startRunEvent(builder); - RunEvent.addSingleStep(builder, singleStep); - return RunEvent.endRunEvent(builder); +static createRunRequest(builder:flatbuffers.Builder, singleStep:boolean):flatbuffers.Offset { + RunRequest.startRunRequest(builder); + RunRequest.addSingleStep(builder, singleStep); + return RunRequest.endRunRequest(builder); } -unpack(): RunEventT { - return new RunEventT( +unpack(): RunRequestT { + return new RunRequestT( this.singleStep() ); } -unpackTo(_o: RunEventT): void { +unpackTo(_o: RunRequestT): void { _o.singleStep = this.singleStep(); } } -export class RunEventT implements flatbuffers.IGeneratedObject { +export class RunRequestT implements flatbuffers.IGeneratedObject { constructor( public singleStep: boolean = false ){} pack(builder:flatbuffers.Builder): flatbuffers.Offset { - return RunEvent.createRunEvent(builder, + return RunRequest.createRunRequest(builder, this.singleStep ); } diff --git a/page/src/fb/debugger/state.ts b/page/src/fb/debugger/state.ts new file mode 100644 index 00000000..01be2fac --- /dev/null +++ b/page/src/fb/debugger/state.ts @@ -0,0 +1,9 @@ +// automatically generated by the FlatBuffers compiler, do not modify + +/* eslint-disable @typescript-eslint/no-unused-vars, @typescript-eslint/no-explicit-any, @typescript-eslint/no-non-null-assertion */ + +export enum State { + None = 0, + Running = 1, + Paused = 2 +} diff --git a/src/debugger/event_handler.cpp b/src/debugger/event_handler.cpp index e701c621..b6d65591 100644 --- a/src/debugger/event_handler.cpp +++ b/src/debugger/event_handler.cpp @@ -40,16 +40,64 @@ namespace debugger return {std::move(e)}; } + void send_event(const Debugger::DebugEventT& event) + { + flatbuffers::FlatBufferBuilder fbb{}; + fbb.Finish(Debugger::DebugEvent::Pack(fbb, &event)); + + const std::string_view buffer(reinterpret_cast(fbb.GetBufferPointer()), fbb.GetSize()); + const auto message = base64::to_base64(buffer); + + send_message(message); + } + + template + requires(!std::is_same_v, Debugger::DebugEventT>) + void send_event(T event) + { + Debugger::DebugEventT e{}; + e.event.Set(std::move(event)); + send_event(e); + } + + Debugger::State translate_state(const emulation_state state) + { + switch (state) + { + case emulation_state::paused: + return Debugger::State_Paused; + + case emulation_state::none: + case emulation_state::running: + return Debugger::State_Running; + + default: + return Debugger::State_None; + } + } + + void handle_get_state_request(const event_context& c) + { + Debugger::GetStateResponseT stateResponse{}; + stateResponse.state = translate_state(c.state); + + send_event(stateResponse); + } + void handle_event(event_context& c, const Debugger::DebugEventT& e) { switch (e.event.type) { - case Debugger::Event_PauseEvent: - c.win_emu.emu().stop(); + case Debugger::Event_PauseRequest: + c.state = emulation_state::paused; break; - case Debugger::Event_RunEvent: - c.resume = true; + case Debugger::Event_RunRequest: + c.state = emulation_state::running; + break; + + case Debugger::Event_GetStateRequest: + handle_get_state_request(c); break; default: @@ -58,7 +106,7 @@ namespace debugger } } - void handle_events(event_context& c) + void handle_events_once(event_context& c) { while (true) { @@ -73,4 +121,19 @@ namespace debugger handle_event(c, *e); } } + + void handle_events(event_context& c) + { + while (true) + { + handle_events_once(c); + + if (c.state != emulation_state::paused) + { + break; + } + + suspend_execution(2ms); + } + } } \ No newline at end of file diff --git a/src/debugger/event_handler.hpp b/src/debugger/event_handler.hpp index acdb3fa3..0e052fe6 100644 --- a/src/debugger/event_handler.hpp +++ b/src/debugger/event_handler.hpp @@ -4,10 +4,17 @@ namespace debugger { + enum class emulation_state + { + none, + running, + paused, + }; + struct event_context { windows_emulator& win_emu; - bool resume{false}; + emulation_state state{emulation_state::none}; }; void handle_events(event_context& c); diff --git a/src/debugger/events.fbs b/src/debugger/events.fbs index 15095c10..76c502ed 100644 --- a/src/debugger/events.fbs +++ b/src/debugger/events.fbs @@ -1,14 +1,28 @@ namespace Debugger; -table PauseEvent {} +table GetStateRequest {} -table RunEvent { +enum State : uint32 { + None = 0, + Running, + Paused, +} + +table GetStateResponse { + state: State; +} + +table PauseRequest {} + +table RunRequest { single_step: bool; } union Event { - PauseEvent, - RunEvent, + PauseRequest, + RunRequest, + GetStateRequest, + GetStateResponse, } table DebugEvent { diff --git a/src/debugger/events_generated.hxx b/src/debugger/events_generated.hxx index 3e9be171..82cc1b9f 100644 --- a/src/debugger/events_generated.hxx +++ b/src/debugger/events_generated.hxx @@ -15,47 +15,94 @@ static_assert(FLATBUFFERS_VERSION_MAJOR == 25 && namespace Debugger { -struct PauseEvent; -struct PauseEventBuilder; -struct PauseEventT; +struct GetStateRequest; +struct GetStateRequestBuilder; +struct GetStateRequestT; -struct RunEvent; -struct RunEventBuilder; -struct RunEventT; +struct GetStateResponse; +struct GetStateResponseBuilder; +struct GetStateResponseT; + +struct PauseRequest; +struct PauseRequestBuilder; +struct PauseRequestT; + +struct RunRequest; +struct RunRequestBuilder; +struct RunRequestT; struct DebugEvent; struct DebugEventBuilder; struct DebugEventT; -enum Event : uint8_t { - Event_NONE = 0, - Event_PauseEvent = 1, - Event_RunEvent = 2, - Event_MIN = Event_NONE, - Event_MAX = Event_RunEvent +enum State : uint32_t { + State_None = 0, + State_Running = 1, + State_Paused = 2, + State_MIN = State_None, + State_MAX = State_Paused }; -inline const Event (&EnumValuesEvent())[3] { +inline const State (&EnumValuesState())[3] { + static const State values[] = { + State_None, + State_Running, + State_Paused + }; + return values; +} + +inline const char * const *EnumNamesState() { + static const char * const names[4] = { + "None", + "Running", + "Paused", + nullptr + }; + return names; +} + +inline const char *EnumNameState(State e) { + if (::flatbuffers::IsOutRange(e, State_None, State_Paused)) return ""; + const size_t index = static_cast(e); + return EnumNamesState()[index]; +} + +enum Event : uint8_t { + Event_NONE = 0, + Event_PauseRequest = 1, + Event_RunRequest = 2, + Event_GetStateRequest = 3, + Event_GetStateResponse = 4, + Event_MIN = Event_NONE, + Event_MAX = Event_GetStateResponse +}; + +inline const Event (&EnumValuesEvent())[5] { static const Event values[] = { Event_NONE, - Event_PauseEvent, - Event_RunEvent + Event_PauseRequest, + Event_RunRequest, + Event_GetStateRequest, + Event_GetStateResponse }; return values; } inline const char * const *EnumNamesEvent() { - static const char * const names[4] = { + static const char * const names[6] = { "NONE", - "PauseEvent", - "RunEvent", + "PauseRequest", + "RunRequest", + "GetStateRequest", + "GetStateResponse", nullptr }; return names; } inline const char *EnumNameEvent(Event e) { - if (::flatbuffers::IsOutRange(e, Event_NONE, Event_RunEvent)) return ""; + if (::flatbuffers::IsOutRange(e, Event_NONE, Event_GetStateResponse)) return ""; const size_t index = static_cast(e); return EnumNamesEvent()[index]; } @@ -64,24 +111,40 @@ template struct EventTraits { static const Event enum_value = Event_NONE; }; -template<> struct EventTraits { - static const Event enum_value = Event_PauseEvent; +template<> struct EventTraits { + static const Event enum_value = Event_PauseRequest; }; -template<> struct EventTraits { - static const Event enum_value = Event_RunEvent; +template<> struct EventTraits { + static const Event enum_value = Event_RunRequest; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_GetStateRequest; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_GetStateResponse; }; template struct EventUnionTraits { static const Event enum_value = Event_NONE; }; -template<> struct EventUnionTraits { - static const Event enum_value = Event_PauseEvent; +template<> struct EventUnionTraits { + static const Event enum_value = Event_PauseRequest; }; -template<> struct EventUnionTraits { - static const Event enum_value = Event_RunEvent; +template<> struct EventUnionTraits { + static const Event enum_value = Event_RunRequest; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_GetStateRequest; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_GetStateResponse; }; struct EventUnion { @@ -114,74 +177,184 @@ struct EventUnion { static void *UnPack(const void *obj, Event type, const ::flatbuffers::resolver_function_t *resolver); ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr) const; - Debugger::PauseEventT *AsPauseEvent() { - return type == Event_PauseEvent ? - reinterpret_cast(value) : nullptr; + Debugger::PauseRequestT *AsPauseRequest() { + return type == Event_PauseRequest ? + reinterpret_cast(value) : nullptr; } - const Debugger::PauseEventT *AsPauseEvent() const { - return type == Event_PauseEvent ? - reinterpret_cast(value) : nullptr; + const Debugger::PauseRequestT *AsPauseRequest() const { + return type == Event_PauseRequest ? + reinterpret_cast(value) : nullptr; } - Debugger::RunEventT *AsRunEvent() { - return type == Event_RunEvent ? - reinterpret_cast(value) : nullptr; + Debugger::RunRequestT *AsRunRequest() { + return type == Event_RunRequest ? + reinterpret_cast(value) : nullptr; } - const Debugger::RunEventT *AsRunEvent() const { - return type == Event_RunEvent ? - reinterpret_cast(value) : nullptr; + const Debugger::RunRequestT *AsRunRequest() const { + return type == Event_RunRequest ? + reinterpret_cast(value) : nullptr; + } + Debugger::GetStateRequestT *AsGetStateRequest() { + return type == Event_GetStateRequest ? + reinterpret_cast(value) : nullptr; + } + const Debugger::GetStateRequestT *AsGetStateRequest() const { + return type == Event_GetStateRequest ? + reinterpret_cast(value) : nullptr; + } + Debugger::GetStateResponseT *AsGetStateResponse() { + return type == Event_GetStateResponse ? + reinterpret_cast(value) : nullptr; + } + const Debugger::GetStateResponseT *AsGetStateResponse() const { + return type == Event_GetStateResponse ? + reinterpret_cast(value) : nullptr; } }; bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Event type); bool VerifyEventVector(::flatbuffers::Verifier &verifier, const ::flatbuffers::Vector<::flatbuffers::Offset> *values, const ::flatbuffers::Vector *types); -struct PauseEventT : public ::flatbuffers::NativeTable { - typedef PauseEvent TableType; +struct GetStateRequestT : public ::flatbuffers::NativeTable { + typedef GetStateRequest TableType; }; -struct PauseEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef PauseEventT NativeTableType; - typedef PauseEventBuilder Builder; +struct GetStateRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GetStateRequestT NativeTableType; + typedef GetStateRequestBuilder Builder; bool Verify(::flatbuffers::Verifier &verifier) const { return VerifyTableStart(verifier) && verifier.EndTable(); } - PauseEventT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(PauseEventT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PauseEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + GetStateRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GetStateRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; -struct PauseEventBuilder { - typedef PauseEvent Table; +struct GetStateRequestBuilder { + typedef GetStateRequest Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; - explicit PauseEventBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + explicit GetStateRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - ::flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline ::flatbuffers::Offset CreatePauseEvent( +inline ::flatbuffers::Offset CreateGetStateRequest( ::flatbuffers::FlatBufferBuilder &_fbb) { - PauseEventBuilder builder_(_fbb); + GetStateRequestBuilder builder_(_fbb); return builder_.Finish(); } -::flatbuffers::Offset CreatePauseEvent(::flatbuffers::FlatBufferBuilder &_fbb, const PauseEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateGetStateRequest(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -struct RunEventT : public ::flatbuffers::NativeTable { - typedef RunEvent TableType; +struct GetStateResponseT : public ::flatbuffers::NativeTable { + typedef GetStateResponse TableType; + Debugger::State state = Debugger::State_None; +}; + +struct GetStateResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef GetStateResponseT NativeTableType; + typedef GetStateResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_STATE = 4 + }; + Debugger::State state() const { + return static_cast(GetField(VT_STATE, 0)); + } + bool mutate_state(Debugger::State _state = static_cast(0)) { + return SetField(VT_STATE, static_cast(_state), 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_STATE, 4) && + verifier.EndTable(); + } + GetStateResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(GetStateResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct GetStateResponseBuilder { + typedef GetStateResponse Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_state(Debugger::State state) { + fbb_.AddElement(GetStateResponse::VT_STATE, static_cast(state), 0); + } + explicit GetStateResponseBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreateGetStateResponse( + ::flatbuffers::FlatBufferBuilder &_fbb, + Debugger::State state = Debugger::State_None) { + GetStateResponseBuilder builder_(_fbb); + builder_.add_state(state); + return builder_.Finish(); +} + +::flatbuffers::Offset CreateGetStateResponse(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct PauseRequestT : public ::flatbuffers::NativeTable { + typedef PauseRequest TableType; +}; + +struct PauseRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef PauseRequestT NativeTableType; + typedef PauseRequestBuilder Builder; + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + verifier.EndTable(); + } + PauseRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(PauseRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PauseRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct PauseRequestBuilder { + typedef PauseRequest Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + explicit PauseRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + : fbb_(_fbb) { + start_ = fbb_.StartTable(); + } + ::flatbuffers::Offset Finish() { + const auto end = fbb_.EndTable(start_); + auto o = ::flatbuffers::Offset(end); + return o; + } +}; + +inline ::flatbuffers::Offset CreatePauseRequest( + ::flatbuffers::FlatBufferBuilder &_fbb) { + PauseRequestBuilder builder_(_fbb); + return builder_.Finish(); +} + +::flatbuffers::Offset CreatePauseRequest(::flatbuffers::FlatBufferBuilder &_fbb, const PauseRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct RunRequestT : public ::flatbuffers::NativeTable { + typedef RunRequest TableType; bool single_step = false; }; -struct RunEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { - typedef RunEventT NativeTableType; - typedef RunEventBuilder Builder; +struct RunRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef RunRequestT NativeTableType; + typedef RunRequestBuilder Builder; enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { VT_SINGLE_STEP = 4 }; @@ -196,38 +369,38 @@ struct RunEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { VerifyField(verifier, VT_SINGLE_STEP, 1) && verifier.EndTable(); } - RunEventT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - void UnPackTo(RunEventT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; - static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RunEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + RunRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(RunRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RunRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; -struct RunEventBuilder { - typedef RunEvent Table; +struct RunRequestBuilder { + typedef RunRequest Table; ::flatbuffers::FlatBufferBuilder &fbb_; ::flatbuffers::uoffset_t start_; void add_single_step(bool single_step) { - fbb_.AddElement(RunEvent::VT_SINGLE_STEP, static_cast(single_step), 0); + fbb_.AddElement(RunRequest::VT_SINGLE_STEP, static_cast(single_step), 0); } - explicit RunEventBuilder(::flatbuffers::FlatBufferBuilder &_fbb) + explicit RunRequestBuilder(::flatbuffers::FlatBufferBuilder &_fbb) : fbb_(_fbb) { start_ = fbb_.StartTable(); } - ::flatbuffers::Offset Finish() { + ::flatbuffers::Offset Finish() { const auto end = fbb_.EndTable(start_); - auto o = ::flatbuffers::Offset(end); + auto o = ::flatbuffers::Offset(end); return o; } }; -inline ::flatbuffers::Offset CreateRunEvent( +inline ::flatbuffers::Offset CreateRunRequest( ::flatbuffers::FlatBufferBuilder &_fbb, bool single_step = false) { - RunEventBuilder builder_(_fbb); + RunRequestBuilder builder_(_fbb); builder_.add_single_step(single_step); return builder_.Finish(); } -::flatbuffers::Offset CreateRunEvent(::flatbuffers::FlatBufferBuilder &_fbb, const RunEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +::flatbuffers::Offset CreateRunRequest(::flatbuffers::FlatBufferBuilder &_fbb, const RunRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); struct DebugEventT : public ::flatbuffers::NativeTable { typedef DebugEvent TableType; @@ -248,11 +421,17 @@ struct DebugEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { return GetPointer(VT_EVENT); } template const T *event_as() const; - const Debugger::PauseEvent *event_as_PauseEvent() const { - return event_type() == Debugger::Event_PauseEvent ? static_cast(event()) : nullptr; + const Debugger::PauseRequest *event_as_PauseRequest() const { + return event_type() == Debugger::Event_PauseRequest ? static_cast(event()) : nullptr; } - const Debugger::RunEvent *event_as_RunEvent() const { - return event_type() == Debugger::Event_RunEvent ? static_cast(event()) : nullptr; + const Debugger::RunRequest *event_as_RunRequest() const { + return event_type() == Debugger::Event_RunRequest ? static_cast(event()) : nullptr; + } + const Debugger::GetStateRequest *event_as_GetStateRequest() const { + return event_type() == Debugger::Event_GetStateRequest ? static_cast(event()) : nullptr; + } + const Debugger::GetStateResponse *event_as_GetStateResponse() const { + return event_type() == Debugger::Event_GetStateResponse ? static_cast(event()) : nullptr; } void *mutable_event() { return GetPointer(VT_EVENT); @@ -269,12 +448,20 @@ struct DebugEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const DebugEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); }; -template<> inline const Debugger::PauseEvent *DebugEvent::event_as() const { - return event_as_PauseEvent(); +template<> inline const Debugger::PauseRequest *DebugEvent::event_as() const { + return event_as_PauseRequest(); } -template<> inline const Debugger::RunEvent *DebugEvent::event_as() const { - return event_as_RunEvent(); +template<> inline const Debugger::RunRequest *DebugEvent::event_as() const { + return event_as_RunRequest(); +} + +template<> inline const Debugger::GetStateRequest *DebugEvent::event_as() const { + return event_as_GetStateRequest(); +} + +template<> inline const Debugger::GetStateResponse *DebugEvent::event_as() const { + return event_as_GetStateResponse(); } struct DebugEventBuilder { @@ -310,51 +497,100 @@ inline ::flatbuffers::Offset CreateDebugEvent( ::flatbuffers::Offset CreateDebugEvent(::flatbuffers::FlatBufferBuilder &_fbb, const DebugEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); -inline PauseEventT *PauseEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr(new PauseEventT()); +inline GetStateRequestT *GetStateRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new GetStateRequestT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void PauseEvent::UnPackTo(PauseEventT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { +inline void GetStateRequest::UnPackTo(GetStateRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; } -inline ::flatbuffers::Offset PauseEvent::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PauseEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return CreatePauseEvent(_fbb, _o, _rehasher); +inline ::flatbuffers::Offset GetStateRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateGetStateRequest(_fbb, _o, _rehasher); } -inline ::flatbuffers::Offset CreatePauseEvent(::flatbuffers::FlatBufferBuilder &_fbb, const PauseEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateGetStateRequest(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PauseEventT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; - return Debugger::CreatePauseEvent( + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GetStateRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return Debugger::CreateGetStateRequest( _fbb); } -inline RunEventT *RunEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { - auto _o = std::unique_ptr(new RunEventT()); +inline GetStateResponseT *GetStateResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new GetStateResponseT()); UnPackTo(_o.get(), _resolver); return _o.release(); } -inline void RunEvent::UnPackTo(RunEventT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { +inline void GetStateResponse::UnPackTo(GetStateResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = state(); _o->state = _e; } +} + +inline ::flatbuffers::Offset GetStateResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateGetStateResponse(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateGetStateResponse(::flatbuffers::FlatBufferBuilder &_fbb, const GetStateResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const GetStateResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _state = _o->state; + return Debugger::CreateGetStateResponse( + _fbb, + _state); +} + +inline PauseRequestT *PauseRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new PauseRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void PauseRequest::UnPackTo(PauseRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; +} + +inline ::flatbuffers::Offset PauseRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const PauseRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreatePauseRequest(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreatePauseRequest(::flatbuffers::FlatBufferBuilder &_fbb, const PauseRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const PauseRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + return Debugger::CreatePauseRequest( + _fbb); +} + +inline RunRequestT *RunRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new RunRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void RunRequest::UnPackTo(RunRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { (void)_o; (void)_resolver; { auto _e = single_step(); _o->single_step = _e; } } -inline ::flatbuffers::Offset RunEvent::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RunEventT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { - return CreateRunEvent(_fbb, _o, _rehasher); +inline ::flatbuffers::Offset RunRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const RunRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateRunRequest(_fbb, _o, _rehasher); } -inline ::flatbuffers::Offset CreateRunEvent(::flatbuffers::FlatBufferBuilder &_fbb, const RunEventT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { +inline ::flatbuffers::Offset CreateRunRequest(::flatbuffers::FlatBufferBuilder &_fbb, const RunRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { (void)_rehasher; (void)_o; - struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RunEventT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const RunRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; auto _single_step = _o->single_step; - return Debugger::CreateRunEvent( + return Debugger::CreateRunRequest( _fbb, _single_step); } @@ -393,12 +629,20 @@ inline bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Even case Event_NONE: { return true; } - case Event_PauseEvent: { - auto ptr = reinterpret_cast(obj); + case Event_PauseRequest: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } - case Event_RunEvent: { - auto ptr = reinterpret_cast(obj); + case Event_RunRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_GetStateRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_GetStateResponse: { + auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } default: return true; @@ -420,12 +664,20 @@ inline bool VerifyEventVector(::flatbuffers::Verifier &verifier, const ::flatbuf inline void *EventUnion::UnPack(const void *obj, Event type, const ::flatbuffers::resolver_function_t *resolver) { (void)resolver; switch (type) { - case Event_PauseEvent: { - auto ptr = reinterpret_cast(obj); + case Event_PauseRequest: { + auto ptr = reinterpret_cast(obj); return ptr->UnPack(resolver); } - case Event_RunEvent: { - auto ptr = reinterpret_cast(obj); + case Event_RunRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_GetStateRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_GetStateResponse: { + auto ptr = reinterpret_cast(obj); return ptr->UnPack(resolver); } default: return nullptr; @@ -435,13 +687,21 @@ inline void *EventUnion::UnPack(const void *obj, Event type, const ::flatbuffers inline ::flatbuffers::Offset EventUnion::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ::flatbuffers::rehasher_function_t *_rehasher) const { (void)_rehasher; switch (type) { - case Event_PauseEvent: { - auto ptr = reinterpret_cast(value); - return CreatePauseEvent(_fbb, ptr, _rehasher).Union(); + case Event_PauseRequest: { + auto ptr = reinterpret_cast(value); + return CreatePauseRequest(_fbb, ptr, _rehasher).Union(); } - case Event_RunEvent: { - auto ptr = reinterpret_cast(value); - return CreateRunEvent(_fbb, ptr, _rehasher).Union(); + case Event_RunRequest: { + auto ptr = reinterpret_cast(value); + return CreateRunRequest(_fbb, ptr, _rehasher).Union(); + } + case Event_GetStateRequest: { + auto ptr = reinterpret_cast(value); + return CreateGetStateRequest(_fbb, ptr, _rehasher).Union(); + } + case Event_GetStateResponse: { + auto ptr = reinterpret_cast(value); + return CreateGetStateResponse(_fbb, ptr, _rehasher).Union(); } default: return 0; } @@ -449,12 +709,20 @@ inline ::flatbuffers::Offset EventUnion::Pack(::flatbuffers::FlatBufferBui inline EventUnion::EventUnion(const EventUnion &u) : type(u.type), value(nullptr) { switch (type) { - case Event_PauseEvent: { - value = new Debugger::PauseEventT(*reinterpret_cast(u.value)); + case Event_PauseRequest: { + value = new Debugger::PauseRequestT(*reinterpret_cast(u.value)); break; } - case Event_RunEvent: { - value = new Debugger::RunEventT(*reinterpret_cast(u.value)); + case Event_RunRequest: { + value = new Debugger::RunRequestT(*reinterpret_cast(u.value)); + break; + } + case Event_GetStateRequest: { + value = new Debugger::GetStateRequestT(*reinterpret_cast(u.value)); + break; + } + case Event_GetStateResponse: { + value = new Debugger::GetStateResponseT(*reinterpret_cast(u.value)); break; } default: @@ -464,13 +732,23 @@ inline EventUnion::EventUnion(const EventUnion &u) : type(u.type), value(nullptr inline void EventUnion::Reset() { switch (type) { - case Event_PauseEvent: { - auto ptr = reinterpret_cast(value); + case Event_PauseRequest: { + auto ptr = reinterpret_cast(value); delete ptr; break; } - case Event_RunEvent: { - auto ptr = reinterpret_cast(value); + case Event_RunRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_GetStateRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_GetStateResponse: { + auto ptr = reinterpret_cast(value); delete ptr; break; }