diff --git a/page/src/fb/debugger.ts b/page/src/fb/debugger.ts index babc30f3..c5f2befb 100644 --- a/page/src/fb/debugger.ts +++ b/page/src/fb/debugger.ts @@ -9,7 +9,11 @@ export { GetStateResponse, GetStateResponseT } from './debugger/get-state-respon export { PauseRequest, PauseRequestT } from './debugger/pause-request.js'; export { ReadMemoryRequest, ReadMemoryRequestT } from './debugger/read-memory-request.js'; export { ReadMemoryResponse, ReadMemoryResponseT } from './debugger/read-memory-response.js'; +export { ReadRegisterRequest, ReadRegisterRequestT } from './debugger/read-register-request.js'; +export { ReadRegisterResponse, ReadRegisterResponseT } from './debugger/read-register-response.js'; export { RunRequest, RunRequestT } from './debugger/run-request.js'; export { State } from './debugger/state.js'; export { WriteMemoryRequest, WriteMemoryRequestT } from './debugger/write-memory-request.js'; export { WriteMemoryResponse, WriteMemoryResponseT } from './debugger/write-memory-response.js'; +export { WriteRegisterRequest, WriteRegisterRequestT } from './debugger/write-register-request.js'; +export { WriteRegisterResponse, WriteRegisterResponseT } from './debugger/write-register-response.js'; diff --git a/page/src/fb/debugger/debug-event.ts b/page/src/fb/debugger/debug-event.ts index afb57ec2..9be99bfa 100644 --- a/page/src/fb/debugger/debug-event.ts +++ b/page/src/fb/debugger/debug-event.ts @@ -10,9 +10,13 @@ import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-respo import { PauseRequest, PauseRequestT } from '../debugger/pause-request.js'; import { ReadMemoryRequest, ReadMemoryRequestT } from '../debugger/read-memory-request.js'; import { ReadMemoryResponse, ReadMemoryResponseT } from '../debugger/read-memory-response.js'; +import { ReadRegisterRequest, ReadRegisterRequestT } from '../debugger/read-register-request.js'; +import { ReadRegisterResponse, ReadRegisterResponseT } from '../debugger/read-register-response.js'; import { RunRequest, RunRequestT } from '../debugger/run-request.js'; import { WriteMemoryRequest, WriteMemoryRequestT } from '../debugger/write-memory-request.js'; import { WriteMemoryResponse, WriteMemoryResponseT } from '../debugger/write-memory-response.js'; +import { WriteRegisterRequest, WriteRegisterRequestT } from '../debugger/write-register-request.js'; +import { WriteRegisterResponse, WriteRegisterResponseT } from '../debugger/write-register-response.js'; export class DebugEvent implements flatbuffers.IUnpackableObject { @@ -100,7 +104,7 @@ unpackTo(_o: DebugEventT): void { export class DebugEventT implements flatbuffers.IGeneratedObject { constructor( public eventType: Event = Event.NONE, - public event: GetStateRequestT|GetStateResponseT|PauseRequestT|ReadMemoryRequestT|ReadMemoryResponseT|RunRequestT|WriteMemoryRequestT|WriteMemoryResponseT|null = null + public event: GetStateRequestT|GetStateResponseT|PauseRequestT|ReadMemoryRequestT|ReadMemoryResponseT|ReadRegisterRequestT|ReadRegisterResponseT|RunRequestT|WriteMemoryRequestT|WriteMemoryResponseT|WriteRegisterRequestT|WriteRegisterResponseT|null = null ){} diff --git a/page/src/fb/debugger/event.ts b/page/src/fb/debugger/event.ts index 6b249b2b..fde2a752 100644 --- a/page/src/fb/debugger/event.ts +++ b/page/src/fb/debugger/event.ts @@ -7,9 +7,13 @@ import { GetStateResponse, GetStateResponseT } from '../debugger/get-state-respo import { PauseRequest, PauseRequestT } from '../debugger/pause-request.js'; import { ReadMemoryRequest, ReadMemoryRequestT } from '../debugger/read-memory-request.js'; import { ReadMemoryResponse, ReadMemoryResponseT } from '../debugger/read-memory-response.js'; +import { ReadRegisterRequest, ReadRegisterRequestT } from '../debugger/read-register-request.js'; +import { ReadRegisterResponse, ReadRegisterResponseT } from '../debugger/read-register-response.js'; import { RunRequest, RunRequestT } from '../debugger/run-request.js'; import { WriteMemoryRequest, WriteMemoryRequestT } from '../debugger/write-memory-request.js'; import { WriteMemoryResponse, WriteMemoryResponseT } from '../debugger/write-memory-response.js'; +import { WriteRegisterRequest, WriteRegisterRequestT } from '../debugger/write-register-request.js'; +import { WriteRegisterResponse, WriteRegisterResponseT } from '../debugger/write-register-response.js'; export enum Event { @@ -21,13 +25,17 @@ export enum Event { WriteMemoryRequest = 5, WriteMemoryResponse = 6, ReadMemoryRequest = 7, - ReadMemoryResponse = 8 + ReadMemoryResponse = 8, + WriteRegisterRequest = 9, + WriteRegisterResponse = 10, + ReadRegisterRequest = 11, + ReadRegisterResponse = 12 } export function unionToEvent( type: Event, - accessor: (obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null -): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null { + accessor: (obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null +): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null { switch(Event[type]) { case 'NONE': return null; case 'PauseRequest': return accessor(new PauseRequest())! as PauseRequest; @@ -38,15 +46,19 @@ export function unionToEvent( case 'WriteMemoryResponse': return accessor(new WriteMemoryResponse())! as WriteMemoryResponse; case 'ReadMemoryRequest': return accessor(new ReadMemoryRequest())! as ReadMemoryRequest; case 'ReadMemoryResponse': return accessor(new ReadMemoryResponse())! as ReadMemoryResponse; + case 'WriteRegisterRequest': return accessor(new WriteRegisterRequest())! as WriteRegisterRequest; + case 'WriteRegisterResponse': return accessor(new WriteRegisterResponse())! as WriteRegisterResponse; + case 'ReadRegisterRequest': return accessor(new ReadRegisterRequest())! as ReadRegisterRequest; + case 'ReadRegisterResponse': return accessor(new ReadRegisterResponse())! as ReadRegisterResponse; default: return null; } } export function unionListToEvent( type: Event, - accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null, + accessor: (index: number, obj:GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse) => GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null, index: number -): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|null { +): GetStateRequest|GetStateResponse|PauseRequest|ReadMemoryRequest|ReadMemoryResponse|ReadRegisterRequest|ReadRegisterResponse|RunRequest|WriteMemoryRequest|WriteMemoryResponse|WriteRegisterRequest|WriteRegisterResponse|null { switch(Event[type]) { case 'NONE': return null; case 'PauseRequest': return accessor(index, new PauseRequest())! as PauseRequest; @@ -57,6 +69,10 @@ export function unionListToEvent( case 'WriteMemoryResponse': return accessor(index, new WriteMemoryResponse())! as WriteMemoryResponse; case 'ReadMemoryRequest': return accessor(index, new ReadMemoryRequest())! as ReadMemoryRequest; case 'ReadMemoryResponse': return accessor(index, new ReadMemoryResponse())! as ReadMemoryResponse; + case 'WriteRegisterRequest': return accessor(index, new WriteRegisterRequest())! as WriteRegisterRequest; + case 'WriteRegisterResponse': return accessor(index, new WriteRegisterResponse())! as WriteRegisterResponse; + case 'ReadRegisterRequest': return accessor(index, new ReadRegisterRequest())! as ReadRegisterRequest; + case 'ReadRegisterResponse': return accessor(index, new ReadRegisterResponse())! as ReadRegisterResponse; default: return null; } } diff --git a/page/src/fb/debugger/read-register-request.ts b/page/src/fb/debugger/read-register-request.ts new file mode 100644 index 00000000..71980ad8 --- /dev/null +++ b/page/src/fb/debugger/read-register-request.ts @@ -0,0 +1,85 @@ +// 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 ReadRegisterRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ReadRegisterRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsReadRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterRequest):ReadRegisterRequest { + return (obj || new ReadRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsReadRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterRequest):ReadRegisterRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ReadRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +register():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_register(value:number):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 startReadRegisterRequest(builder:flatbuffers.Builder) { + builder.startObject(1); +} + +static addRegister(builder:flatbuffers.Builder, register:number) { + builder.addFieldInt32(0, register, 0); +} + +static endReadRegisterRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createReadRegisterRequest(builder:flatbuffers.Builder, register:number):flatbuffers.Offset { + ReadRegisterRequest.startReadRegisterRequest(builder); + ReadRegisterRequest.addRegister(builder, register); + return ReadRegisterRequest.endReadRegisterRequest(builder); +} + +unpack(): ReadRegisterRequestT { + return new ReadRegisterRequestT( + this.register() + ); +} + + +unpackTo(_o: ReadRegisterRequestT): void { + _o.register = this.register(); +} +} + +export class ReadRegisterRequestT implements flatbuffers.IGeneratedObject { +constructor( + public register: number = 0 +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return ReadRegisterRequest.createReadRegisterRequest(builder, + this.register + ); +} +} diff --git a/page/src/fb/debugger/read-register-response.ts b/page/src/fb/debugger/read-register-response.ts new file mode 100644 index 00000000..9d2d6c86 --- /dev/null +++ b/page/src/fb/debugger/read-register-response.ts @@ -0,0 +1,123 @@ +// 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 ReadRegisterResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):ReadRegisterResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsReadRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterResponse):ReadRegisterResponse { + return (obj || new ReadRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsReadRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:ReadRegisterResponse):ReadRegisterResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new ReadRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +register():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_register(value:number):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; +} + +data(index: number):number|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +dataLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +dataArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +static startReadRegisterResponse(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addRegister(builder:flatbuffers.Builder, register:number) { + builder.addFieldInt32(0, register, 0); +} + +static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, dataOffset, 0); +} + +static createDataVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startDataVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static endReadRegisterResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createReadRegisterResponse(builder:flatbuffers.Builder, register:number, dataOffset:flatbuffers.Offset):flatbuffers.Offset { + ReadRegisterResponse.startReadRegisterResponse(builder); + ReadRegisterResponse.addRegister(builder, register); + ReadRegisterResponse.addData(builder, dataOffset); + return ReadRegisterResponse.endReadRegisterResponse(builder); +} + +unpack(): ReadRegisterResponseT { + return new ReadRegisterResponseT( + this.register(), + this.bb!.createScalarList(this.data.bind(this), this.dataLength()) + ); +} + + +unpackTo(_o: ReadRegisterResponseT): void { + _o.register = this.register(); + _o.data = this.bb!.createScalarList(this.data.bind(this), this.dataLength()); +} +} + +export class ReadRegisterResponseT implements flatbuffers.IGeneratedObject { +constructor( + public register: number = 0, + public data: (number)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const data = ReadRegisterResponse.createDataVector(builder, this.data); + + return ReadRegisterResponse.createReadRegisterResponse(builder, + this.register, + data + ); +} +} diff --git a/page/src/fb/debugger/write-register-request.ts b/page/src/fb/debugger/write-register-request.ts new file mode 100644 index 00000000..6e81a3f8 --- /dev/null +++ b/page/src/fb/debugger/write-register-request.ts @@ -0,0 +1,123 @@ +// 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 WriteRegisterRequest implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):WriteRegisterRequest { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsWriteRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterRequest):WriteRegisterRequest { + return (obj || new WriteRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsWriteRegisterRequest(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterRequest):WriteRegisterRequest { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new WriteRegisterRequest()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +register():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_register(value:number):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; +} + +data(index: number):number|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint8(this.bb!.__vector(this.bb_pos + offset) + index) : 0; +} + +dataLength():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.__vector_len(this.bb_pos + offset) : 0; +} + +dataArray():Uint8Array|null { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? new Uint8Array(this.bb!.bytes().buffer, this.bb!.bytes().byteOffset + this.bb!.__vector(this.bb_pos + offset), this.bb!.__vector_len(this.bb_pos + offset)) : null; +} + +static startWriteRegisterRequest(builder:flatbuffers.Builder) { + builder.startObject(2); +} + +static addRegister(builder:flatbuffers.Builder, register:number) { + builder.addFieldInt32(0, register, 0); +} + +static addData(builder:flatbuffers.Builder, dataOffset:flatbuffers.Offset) { + builder.addFieldOffset(1, dataOffset, 0); +} + +static createDataVector(builder:flatbuffers.Builder, data:number[]|Uint8Array):flatbuffers.Offset { + builder.startVector(1, data.length, 1); + for (let i = data.length - 1; i >= 0; i--) { + builder.addInt8(data[i]!); + } + return builder.endVector(); +} + +static startDataVector(builder:flatbuffers.Builder, numElems:number) { + builder.startVector(1, numElems, 1); +} + +static endWriteRegisterRequest(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createWriteRegisterRequest(builder:flatbuffers.Builder, register:number, dataOffset:flatbuffers.Offset):flatbuffers.Offset { + WriteRegisterRequest.startWriteRegisterRequest(builder); + WriteRegisterRequest.addRegister(builder, register); + WriteRegisterRequest.addData(builder, dataOffset); + return WriteRegisterRequest.endWriteRegisterRequest(builder); +} + +unpack(): WriteRegisterRequestT { + return new WriteRegisterRequestT( + this.register(), + this.bb!.createScalarList(this.data.bind(this), this.dataLength()) + ); +} + + +unpackTo(_o: WriteRegisterRequestT): void { + _o.register = this.register(); + _o.data = this.bb!.createScalarList(this.data.bind(this), this.dataLength()); +} +} + +export class WriteRegisterRequestT implements flatbuffers.IGeneratedObject { +constructor( + public register: number = 0, + public data: (number)[] = [] +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + const data = WriteRegisterRequest.createDataVector(builder, this.data); + + return WriteRegisterRequest.createWriteRegisterRequest(builder, + this.register, + data + ); +} +} diff --git a/page/src/fb/debugger/write-register-response.ts b/page/src/fb/debugger/write-register-response.ts new file mode 100644 index 00000000..839edc55 --- /dev/null +++ b/page/src/fb/debugger/write-register-response.ts @@ -0,0 +1,135 @@ +// 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 WriteRegisterResponse implements flatbuffers.IUnpackableObject { + bb: flatbuffers.ByteBuffer|null = null; + bb_pos = 0; + __init(i:number, bb:flatbuffers.ByteBuffer):WriteRegisterResponse { + this.bb_pos = i; + this.bb = bb; + return this; +} + +static getRootAsWriteRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterResponse):WriteRegisterResponse { + return (obj || new WriteRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +static getSizePrefixedRootAsWriteRegisterResponse(bb:flatbuffers.ByteBuffer, obj?:WriteRegisterResponse):WriteRegisterResponse { + bb.setPosition(bb.position() + flatbuffers.SIZE_PREFIX_LENGTH); + return (obj || new WriteRegisterResponse()).__init(bb.readInt32(bb.position()) + bb.position(), bb); +} + +register():number { + const offset = this.bb!.__offset(this.bb_pos, 4); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_register(value:number):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; +} + +size():number { + const offset = this.bb!.__offset(this.bb_pos, 6); + return offset ? this.bb!.readUint32(this.bb_pos + offset) : 0; +} + +mutate_size(value:number):boolean { + const offset = this.bb!.__offset(this.bb_pos, 6); + + if (offset === 0) { + return false; + } + + this.bb!.writeUint32(this.bb_pos + offset, value); + return true; +} + +success():boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + return offset ? !!this.bb!.readInt8(this.bb_pos + offset) : false; +} + +mutate_success(value:boolean):boolean { + const offset = this.bb!.__offset(this.bb_pos, 8); + + if (offset === 0) { + return false; + } + + this.bb!.writeInt8(this.bb_pos + offset, +value); + return true; +} + +static startWriteRegisterResponse(builder:flatbuffers.Builder) { + builder.startObject(3); +} + +static addRegister(builder:flatbuffers.Builder, register:number) { + builder.addFieldInt32(0, register, 0); +} + +static addSize(builder:flatbuffers.Builder, size:number) { + builder.addFieldInt32(1, size, 0); +} + +static addSuccess(builder:flatbuffers.Builder, success:boolean) { + builder.addFieldInt8(2, +success, +false); +} + +static endWriteRegisterResponse(builder:flatbuffers.Builder):flatbuffers.Offset { + const offset = builder.endObject(); + return offset; +} + +static createWriteRegisterResponse(builder:flatbuffers.Builder, register:number, size:number, success:boolean):flatbuffers.Offset { + WriteRegisterResponse.startWriteRegisterResponse(builder); + WriteRegisterResponse.addRegister(builder, register); + WriteRegisterResponse.addSize(builder, size); + WriteRegisterResponse.addSuccess(builder, success); + return WriteRegisterResponse.endWriteRegisterResponse(builder); +} + +unpack(): WriteRegisterResponseT { + return new WriteRegisterResponseT( + this.register(), + this.size(), + this.success() + ); +} + + +unpackTo(_o: WriteRegisterResponseT): void { + _o.register = this.register(); + _o.size = this.size(); + _o.success = this.success(); +} +} + +export class WriteRegisterResponseT implements flatbuffers.IGeneratedObject { +constructor( + public register: number = 0, + public size: number = 0, + public success: boolean = false +){} + + +pack(builder:flatbuffers.Builder): flatbuffers.Offset { + return WriteRegisterResponse.createWriteRegisterResponse(builder, + this.register, + this.size, + this.success + ); +} +} diff --git a/src/debugger/event_handler.cpp b/src/debugger/event_handler.cpp index 8569078d..d607d239 100644 --- a/src/debugger/event_handler.cpp +++ b/src/debugger/event_handler.cpp @@ -123,6 +123,45 @@ namespace debugger send_event(response); } + void handle_read_register(const event_context& c, const Debugger::ReadRegisterRequestT& request) + { + uint8_t buffer[512]{}; + const auto res = + c.win_emu.emu().read_register(static_cast(request.register_), buffer, sizeof(buffer)); + + const auto size = std::min(sizeof(buffer), res); + + Debugger::ReadRegisterResponseT response{}; + response.register_ = request.register_; + response.data.assign(buffer, buffer + size); + + send_event(std::move(response)); + } + + void handle_write_register(const event_context& c, const Debugger::WriteRegisterRequestT& request) + { + bool success{}; + size_t size = request.data.size(); + + try + { + size = c.win_emu.emu().write_register(static_cast(request.register_), request.data.data(), + request.data.size()); + success = true; + } + catch (...) + { + success = false; + } + + Debugger::WriteRegisterResponseT response{}; + response.register_ = request.register_; + response.size = static_cast(size); + response.success = success; + + send_event(response); + } + void handle_event(event_context& c, const Debugger::DebugEventT& e) { switch (e.event.type) @@ -147,6 +186,14 @@ namespace debugger handle_write_memory(c, *e.event.AsWriteMemoryRequest()); break; + case Debugger::Event_ReadRegisterRequest: + handle_read_register(c, *e.event.AsReadRegisterRequest()); + break; + + case Debugger::Event_WriteRegisterRequest: + handle_write_register(c, *e.event.AsWriteRegisterRequest()); + break; + default: break; } diff --git a/src/debugger/events.fbs b/src/debugger/events.fbs index d676b441..4c17f9a4 100644 --- a/src/debugger/events.fbs +++ b/src/debugger/events.fbs @@ -39,6 +39,26 @@ table ReadMemoryResponse { data: [ubyte]; } +table WriteRegisterRequest { + register: uint32; + data: [ubyte]; +} + +table WriteRegisterResponse { + register: uint32; + size: uint32; + success: bool; +} + +table ReadRegisterRequest { + register: uint32; +} + +table ReadRegisterResponse { + register: uint32; + data: [ubyte]; +} + union Event { PauseRequest, RunRequest, @@ -48,6 +68,10 @@ union Event { WriteMemoryResponse, ReadMemoryRequest, ReadMemoryResponse, + WriteRegisterRequest, + WriteRegisterResponse, + ReadRegisterRequest, + ReadRegisterResponse, } table DebugEvent { diff --git a/src/debugger/events_generated.hxx b/src/debugger/events_generated.hxx index c2f80331..5c56b8c5 100644 --- a/src/debugger/events_generated.hxx +++ b/src/debugger/events_generated.hxx @@ -47,6 +47,22 @@ struct ReadMemoryResponse; struct ReadMemoryResponseBuilder; struct ReadMemoryResponseT; +struct WriteRegisterRequest; +struct WriteRegisterRequestBuilder; +struct WriteRegisterRequestT; + +struct WriteRegisterResponse; +struct WriteRegisterResponseBuilder; +struct WriteRegisterResponseT; + +struct ReadRegisterRequest; +struct ReadRegisterRequestBuilder; +struct ReadRegisterRequestT; + +struct ReadRegisterResponse; +struct ReadRegisterResponseBuilder; +struct ReadRegisterResponseT; + struct DebugEvent; struct DebugEventBuilder; struct DebugEventT; @@ -94,11 +110,15 @@ enum Event : uint8_t { Event_WriteMemoryResponse = 6, Event_ReadMemoryRequest = 7, Event_ReadMemoryResponse = 8, + Event_WriteRegisterRequest = 9, + Event_WriteRegisterResponse = 10, + Event_ReadRegisterRequest = 11, + Event_ReadRegisterResponse = 12, Event_MIN = Event_NONE, - Event_MAX = Event_ReadMemoryResponse + Event_MAX = Event_ReadRegisterResponse }; -inline const Event (&EnumValuesEvent())[9] { +inline const Event (&EnumValuesEvent())[13] { static const Event values[] = { Event_NONE, Event_PauseRequest, @@ -108,13 +128,17 @@ inline const Event (&EnumValuesEvent())[9] { Event_WriteMemoryRequest, Event_WriteMemoryResponse, Event_ReadMemoryRequest, - Event_ReadMemoryResponse + Event_ReadMemoryResponse, + Event_WriteRegisterRequest, + Event_WriteRegisterResponse, + Event_ReadRegisterRequest, + Event_ReadRegisterResponse }; return values; } inline const char * const *EnumNamesEvent() { - static const char * const names[10] = { + static const char * const names[14] = { "NONE", "PauseRequest", "RunRequest", @@ -124,13 +148,17 @@ inline const char * const *EnumNamesEvent() { "WriteMemoryResponse", "ReadMemoryRequest", "ReadMemoryResponse", + "WriteRegisterRequest", + "WriteRegisterResponse", + "ReadRegisterRequest", + "ReadRegisterResponse", nullptr }; return names; } inline const char *EnumNameEvent(Event e) { - if (::flatbuffers::IsOutRange(e, Event_NONE, Event_ReadMemoryResponse)) return ""; + if (::flatbuffers::IsOutRange(e, Event_NONE, Event_ReadRegisterResponse)) return ""; const size_t index = static_cast(e); return EnumNamesEvent()[index]; } @@ -171,6 +199,22 @@ template<> struct EventTraits { static const Event enum_value = Event_ReadMemoryResponse; }; +template<> struct EventTraits { + static const Event enum_value = Event_WriteRegisterRequest; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_WriteRegisterResponse; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_ReadRegisterRequest; +}; + +template<> struct EventTraits { + static const Event enum_value = Event_ReadRegisterResponse; +}; + template struct EventUnionTraits { static const Event enum_value = Event_NONE; }; @@ -207,6 +251,22 @@ template<> struct EventUnionTraits { static const Event enum_value = Event_ReadMemoryResponse; }; +template<> struct EventUnionTraits { + static const Event enum_value = Event_WriteRegisterRequest; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_WriteRegisterResponse; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_ReadRegisterRequest; +}; + +template<> struct EventUnionTraits { + static const Event enum_value = Event_ReadRegisterResponse; +}; + struct EventUnion { Event type; void *value; @@ -301,6 +361,38 @@ struct EventUnion { return type == Event_ReadMemoryResponse ? reinterpret_cast(value) : nullptr; } + Debugger::WriteRegisterRequestT *AsWriteRegisterRequest() { + return type == Event_WriteRegisterRequest ? + reinterpret_cast(value) : nullptr; + } + const Debugger::WriteRegisterRequestT *AsWriteRegisterRequest() const { + return type == Event_WriteRegisterRequest ? + reinterpret_cast(value) : nullptr; + } + Debugger::WriteRegisterResponseT *AsWriteRegisterResponse() { + return type == Event_WriteRegisterResponse ? + reinterpret_cast(value) : nullptr; + } + const Debugger::WriteRegisterResponseT *AsWriteRegisterResponse() const { + return type == Event_WriteRegisterResponse ? + reinterpret_cast(value) : nullptr; + } + Debugger::ReadRegisterRequestT *AsReadRegisterRequest() { + return type == Event_ReadRegisterRequest ? + reinterpret_cast(value) : nullptr; + } + const Debugger::ReadRegisterRequestT *AsReadRegisterRequest() const { + return type == Event_ReadRegisterRequest ? + reinterpret_cast(value) : nullptr; + } + Debugger::ReadRegisterResponseT *AsReadRegisterResponse() { + return type == Event_ReadRegisterResponse ? + reinterpret_cast(value) : nullptr; + } + const Debugger::ReadRegisterResponseT *AsReadRegisterResponse() const { + return type == Event_ReadRegisterResponse ? + reinterpret_cast(value) : nullptr; + } }; bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Event type); @@ -808,6 +900,306 @@ inline ::flatbuffers::Offset CreateReadMemoryResponseDirect( ::flatbuffers::Offset CreateReadMemoryResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadMemoryResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +struct WriteRegisterRequestT : public ::flatbuffers::NativeTable { + typedef WriteRegisterRequest TableType; + uint32_t register_ = 0; + std::vector data{}; +}; + +struct WriteRegisterRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef WriteRegisterRequestT NativeTableType; + typedef WriteRegisterRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_REGISTER_ = 4, + VT_DATA = 6 + }; + uint32_t register_() const { + return GetField(VT_REGISTER_, 0); + } + bool mutate_register_(uint32_t _register_ = 0) { + return SetField(VT_REGISTER_, _register_, 0); + } + const ::flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + ::flatbuffers::Vector *mutable_data() { + return GetPointer<::flatbuffers::Vector *>(VT_DATA); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_REGISTER_, 4) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } + WriteRegisterRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(WriteRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct WriteRegisterRequestBuilder { + typedef WriteRegisterRequest Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_register_(uint32_t register_) { + fbb_.AddElement(WriteRegisterRequest::VT_REGISTER_, register_, 0); + } + void add_data(::flatbuffers::Offset<::flatbuffers::Vector> data) { + fbb_.AddOffset(WriteRegisterRequest::VT_DATA, data); + } + explicit WriteRegisterRequestBuilder(::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 CreateWriteRegisterRequest( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t register_ = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> data = 0) { + WriteRegisterRequestBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_register_(register_); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateWriteRegisterRequestDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t register_ = 0, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return Debugger::CreateWriteRegisterRequest( + _fbb, + register_, + data__); +} + +::flatbuffers::Offset CreateWriteRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct WriteRegisterResponseT : public ::flatbuffers::NativeTable { + typedef WriteRegisterResponse TableType; + uint32_t register_ = 0; + uint32_t size = 0; + bool success = false; +}; + +struct WriteRegisterResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef WriteRegisterResponseT NativeTableType; + typedef WriteRegisterResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_REGISTER_ = 4, + VT_SIZE = 6, + VT_SUCCESS = 8 + }; + uint32_t register_() const { + return GetField(VT_REGISTER_, 0); + } + bool mutate_register_(uint32_t _register_ = 0) { + return SetField(VT_REGISTER_, _register_, 0); + } + uint32_t size() const { + return GetField(VT_SIZE, 0); + } + bool mutate_size(uint32_t _size = 0) { + return SetField(VT_SIZE, _size, 0); + } + bool success() const { + return GetField(VT_SUCCESS, 0) != 0; + } + bool mutate_success(bool _success = 0) { + return SetField(VT_SUCCESS, static_cast(_success), 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_REGISTER_, 4) && + VerifyField(verifier, VT_SIZE, 4) && + VerifyField(verifier, VT_SUCCESS, 1) && + verifier.EndTable(); + } + WriteRegisterResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(WriteRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct WriteRegisterResponseBuilder { + typedef WriteRegisterResponse Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_register_(uint32_t register_) { + fbb_.AddElement(WriteRegisterResponse::VT_REGISTER_, register_, 0); + } + void add_size(uint32_t size) { + fbb_.AddElement(WriteRegisterResponse::VT_SIZE, size, 0); + } + void add_success(bool success) { + fbb_.AddElement(WriteRegisterResponse::VT_SUCCESS, static_cast(success), 0); + } + explicit WriteRegisterResponseBuilder(::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 CreateWriteRegisterResponse( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t register_ = 0, + uint32_t size = 0, + bool success = false) { + WriteRegisterResponseBuilder builder_(_fbb); + builder_.add_size(size); + builder_.add_register_(register_); + builder_.add_success(success); + return builder_.Finish(); +} + +::flatbuffers::Offset CreateWriteRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReadRegisterRequestT : public ::flatbuffers::NativeTable { + typedef ReadRegisterRequest TableType; + uint32_t register_ = 0; +}; + +struct ReadRegisterRequest FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ReadRegisterRequestT NativeTableType; + typedef ReadRegisterRequestBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_REGISTER_ = 4 + }; + uint32_t register_() const { + return GetField(VT_REGISTER_, 0); + } + bool mutate_register_(uint32_t _register_ = 0) { + return SetField(VT_REGISTER_, _register_, 0); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_REGISTER_, 4) && + verifier.EndTable(); + } + ReadRegisterRequestT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReadRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReadRegisterRequestBuilder { + typedef ReadRegisterRequest Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_register_(uint32_t register_) { + fbb_.AddElement(ReadRegisterRequest::VT_REGISTER_, register_, 0); + } + explicit ReadRegisterRequestBuilder(::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 CreateReadRegisterRequest( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t register_ = 0) { + ReadRegisterRequestBuilder builder_(_fbb); + builder_.add_register_(register_); + return builder_.Finish(); +} + +::flatbuffers::Offset CreateReadRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + +struct ReadRegisterResponseT : public ::flatbuffers::NativeTable { + typedef ReadRegisterResponse TableType; + uint32_t register_ = 0; + std::vector data{}; +}; + +struct ReadRegisterResponse FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { + typedef ReadRegisterResponseT NativeTableType; + typedef ReadRegisterResponseBuilder Builder; + enum FlatBuffersVTableOffset FLATBUFFERS_VTABLE_UNDERLYING_TYPE { + VT_REGISTER_ = 4, + VT_DATA = 6 + }; + uint32_t register_() const { + return GetField(VT_REGISTER_, 0); + } + bool mutate_register_(uint32_t _register_ = 0) { + return SetField(VT_REGISTER_, _register_, 0); + } + const ::flatbuffers::Vector *data() const { + return GetPointer *>(VT_DATA); + } + ::flatbuffers::Vector *mutable_data() { + return GetPointer<::flatbuffers::Vector *>(VT_DATA); + } + bool Verify(::flatbuffers::Verifier &verifier) const { + return VerifyTableStart(verifier) && + VerifyField(verifier, VT_REGISTER_, 4) && + VerifyOffset(verifier, VT_DATA) && + verifier.VerifyVector(data()) && + verifier.EndTable(); + } + ReadRegisterResponseT *UnPack(const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + void UnPackTo(ReadRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver = nullptr) const; + static ::flatbuffers::Offset Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); +}; + +struct ReadRegisterResponseBuilder { + typedef ReadRegisterResponse Table; + ::flatbuffers::FlatBufferBuilder &fbb_; + ::flatbuffers::uoffset_t start_; + void add_register_(uint32_t register_) { + fbb_.AddElement(ReadRegisterResponse::VT_REGISTER_, register_, 0); + } + void add_data(::flatbuffers::Offset<::flatbuffers::Vector> data) { + fbb_.AddOffset(ReadRegisterResponse::VT_DATA, data); + } + explicit ReadRegisterResponseBuilder(::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 CreateReadRegisterResponse( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t register_ = 0, + ::flatbuffers::Offset<::flatbuffers::Vector> data = 0) { + ReadRegisterResponseBuilder builder_(_fbb); + builder_.add_data(data); + builder_.add_register_(register_); + return builder_.Finish(); +} + +inline ::flatbuffers::Offset CreateReadRegisterResponseDirect( + ::flatbuffers::FlatBufferBuilder &_fbb, + uint32_t register_ = 0, + const std::vector *data = nullptr) { + auto data__ = data ? _fbb.CreateVector(*data) : 0; + return Debugger::CreateReadRegisterResponse( + _fbb, + register_, + data__); +} + +::flatbuffers::Offset CreateReadRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher = nullptr); + struct DebugEventT : public ::flatbuffers::NativeTable { typedef DebugEvent TableType; Debugger::EventUnion event{}; @@ -851,6 +1243,18 @@ struct DebugEvent FLATBUFFERS_FINAL_CLASS : private ::flatbuffers::Table { const Debugger::ReadMemoryResponse *event_as_ReadMemoryResponse() const { return event_type() == Debugger::Event_ReadMemoryResponse ? static_cast(event()) : nullptr; } + const Debugger::WriteRegisterRequest *event_as_WriteRegisterRequest() const { + return event_type() == Debugger::Event_WriteRegisterRequest ? static_cast(event()) : nullptr; + } + const Debugger::WriteRegisterResponse *event_as_WriteRegisterResponse() const { + return event_type() == Debugger::Event_WriteRegisterResponse ? static_cast(event()) : nullptr; + } + const Debugger::ReadRegisterRequest *event_as_ReadRegisterRequest() const { + return event_type() == Debugger::Event_ReadRegisterRequest ? static_cast(event()) : nullptr; + } + const Debugger::ReadRegisterResponse *event_as_ReadRegisterResponse() const { + return event_type() == Debugger::Event_ReadRegisterResponse ? static_cast(event()) : nullptr; + } void *mutable_event() { return GetPointer(VT_EVENT); } @@ -898,6 +1302,22 @@ template<> inline const Debugger::ReadMemoryResponse *DebugEvent::event_as inline const Debugger::WriteRegisterRequest *DebugEvent::event_as() const { + return event_as_WriteRegisterRequest(); +} + +template<> inline const Debugger::WriteRegisterResponse *DebugEvent::event_as() const { + return event_as_WriteRegisterResponse(); +} + +template<> inline const Debugger::ReadRegisterRequest *DebugEvent::event_as() const { + return event_as_ReadRegisterRequest(); +} + +template<> inline const Debugger::ReadRegisterResponse *DebugEvent::event_as() const { + return event_as_ReadRegisterResponse(); +} + struct DebugEventBuilder { typedef DebugEvent Table; ::flatbuffers::FlatBufferBuilder &fbb_; @@ -1148,6 +1568,122 @@ inline ::flatbuffers::Offset CreateReadMemoryResponse(::flat _data); } +inline WriteRegisterRequestT *WriteRegisterRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new WriteRegisterRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void WriteRegisterRequest::UnPackTo(WriteRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = register_(); _o->register_ = _e; } + { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } +} + +inline ::flatbuffers::Offset WriteRegisterRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateWriteRegisterRequest(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateWriteRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WriteRegisterRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _register_ = _o->register_; + auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; + return Debugger::CreateWriteRegisterRequest( + _fbb, + _register_, + _data); +} + +inline WriteRegisterResponseT *WriteRegisterResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new WriteRegisterResponseT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void WriteRegisterResponse::UnPackTo(WriteRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = register_(); _o->register_ = _e; } + { auto _e = size(); _o->size = _e; } + { auto _e = success(); _o->success = _e; } +} + +inline ::flatbuffers::Offset WriteRegisterResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateWriteRegisterResponse(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateWriteRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const WriteRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const WriteRegisterResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _register_ = _o->register_; + auto _size = _o->size; + auto _success = _o->success; + return Debugger::CreateWriteRegisterResponse( + _fbb, + _register_, + _size, + _success); +} + +inline ReadRegisterRequestT *ReadRegisterRequest::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReadRegisterRequestT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ReadRegisterRequest::UnPackTo(ReadRegisterRequestT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = register_(); _o->register_ = _e; } +} + +inline ::flatbuffers::Offset ReadRegisterRequest::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateReadRegisterRequest(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateReadRegisterRequest(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterRequestT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadRegisterRequestT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _register_ = _o->register_; + return Debugger::CreateReadRegisterRequest( + _fbb, + _register_); +} + +inline ReadRegisterResponseT *ReadRegisterResponse::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { + auto _o = std::unique_ptr(new ReadRegisterResponseT()); + UnPackTo(_o.get(), _resolver); + return _o.release(); +} + +inline void ReadRegisterResponse::UnPackTo(ReadRegisterResponseT *_o, const ::flatbuffers::resolver_function_t *_resolver) const { + (void)_o; + (void)_resolver; + { auto _e = register_(); _o->register_ = _e; } + { auto _e = data(); if (_e) { _o->data.resize(_e->size()); std::copy(_e->begin(), _e->end(), _o->data.begin()); } } +} + +inline ::flatbuffers::Offset ReadRegisterResponse::Pack(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT* _o, const ::flatbuffers::rehasher_function_t *_rehasher) { + return CreateReadRegisterResponse(_fbb, _o, _rehasher); +} + +inline ::flatbuffers::Offset CreateReadRegisterResponse(::flatbuffers::FlatBufferBuilder &_fbb, const ReadRegisterResponseT *_o, const ::flatbuffers::rehasher_function_t *_rehasher) { + (void)_rehasher; + (void)_o; + struct _VectorArgs { ::flatbuffers::FlatBufferBuilder *__fbb; const ReadRegisterResponseT* __o; const ::flatbuffers::rehasher_function_t *__rehasher; } _va = { &_fbb, _o, _rehasher}; (void)_va; + auto _register_ = _o->register_; + auto _data = _o->data.size() ? _fbb.CreateVector(_o->data) : 0; + return Debugger::CreateReadRegisterResponse( + _fbb, + _register_, + _data); +} + inline DebugEventT *DebugEvent::UnPack(const ::flatbuffers::resolver_function_t *_resolver) const { auto _o = std::unique_ptr(new DebugEventT()); UnPackTo(_o.get(), _resolver); @@ -1214,6 +1750,22 @@ inline bool VerifyEvent(::flatbuffers::Verifier &verifier, const void *obj, Even auto ptr = reinterpret_cast(obj); return verifier.VerifyTable(ptr); } + case Event_WriteRegisterRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_WriteRegisterResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_ReadRegisterRequest: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } + case Event_ReadRegisterResponse: { + auto ptr = reinterpret_cast(obj); + return verifier.VerifyTable(ptr); + } default: return true; } } @@ -1265,6 +1817,22 @@ inline void *EventUnion::UnPack(const void *obj, Event type, const ::flatbuffers auto ptr = reinterpret_cast(obj); return ptr->UnPack(resolver); } + case Event_WriteRegisterRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_WriteRegisterResponse: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_ReadRegisterRequest: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } + case Event_ReadRegisterResponse: { + auto ptr = reinterpret_cast(obj); + return ptr->UnPack(resolver); + } default: return nullptr; } } @@ -1304,6 +1872,22 @@ inline ::flatbuffers::Offset EventUnion::Pack(::flatbuffers::FlatBufferBui auto ptr = reinterpret_cast(value); return CreateReadMemoryResponse(_fbb, ptr, _rehasher).Union(); } + case Event_WriteRegisterRequest: { + auto ptr = reinterpret_cast(value); + return CreateWriteRegisterRequest(_fbb, ptr, _rehasher).Union(); + } + case Event_WriteRegisterResponse: { + auto ptr = reinterpret_cast(value); + return CreateWriteRegisterResponse(_fbb, ptr, _rehasher).Union(); + } + case Event_ReadRegisterRequest: { + auto ptr = reinterpret_cast(value); + return CreateReadRegisterRequest(_fbb, ptr, _rehasher).Union(); + } + case Event_ReadRegisterResponse: { + auto ptr = reinterpret_cast(value); + return CreateReadRegisterResponse(_fbb, ptr, _rehasher).Union(); + } default: return 0; } } @@ -1342,6 +1926,22 @@ inline EventUnion::EventUnion(const EventUnion &u) : type(u.type), value(nullptr value = new Debugger::ReadMemoryResponseT(*reinterpret_cast(u.value)); break; } + case Event_WriteRegisterRequest: { + value = new Debugger::WriteRegisterRequestT(*reinterpret_cast(u.value)); + break; + } + case Event_WriteRegisterResponse: { + value = new Debugger::WriteRegisterResponseT(*reinterpret_cast(u.value)); + break; + } + case Event_ReadRegisterRequest: { + value = new Debugger::ReadRegisterRequestT(*reinterpret_cast(u.value)); + break; + } + case Event_ReadRegisterResponse: { + value = new Debugger::ReadRegisterResponseT(*reinterpret_cast(u.value)); + break; + } default: break; } @@ -1389,6 +1989,26 @@ inline void EventUnion::Reset() { delete ptr; break; } + case Event_WriteRegisterRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_WriteRegisterResponse: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_ReadRegisterRequest: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } + case Event_ReadRegisterResponse: { + auto ptr = reinterpret_cast(value); + delete ptr; + break; + } default: break; } value = nullptr;