yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-05 19:42:36 +02:00
Code Issues Releases Wiki Activity

GP-599: #2648: Add namespaces to GADP enums.

Browse source
This commit is contained in:
Dan 2021-01-15 12:30:06 -05:00
parent dd041fbe8f
commit 0134f53eaa
5 changed files with 144 additions and 144 deletions
Download patch file Download diff file Expand all files Collapse all files

22
Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/client/GadpClient.java
View file

@ -143,33 +143,33 @@ public class GadpClient implements DebuggerObjectModel {
Gadp.ErrorReply error = MSG_HELPER.expect(msg, Gadp.ErrorReply.getDefaultInstance()); Gadp.ErrorReply error = MSG_HELPER.expect(msg, Gadp.ErrorReply.getDefaultInstance());
if (error != null) { if (error != null) {
switch (error.getCode()) { switch (error.getCode()) {
case NO_INTERFACE: case EC_NO_INTERFACE:
throw new DebuggerModelTypeException(error.getMessage()); throw new DebuggerModelTypeException(error.getMessage());
case NO_OBJECT: case EC_NO_OBJECT:
throw new DebuggerModelNoSuchPathException(error.getMessage()); throw new DebuggerModelNoSuchPathException(error.getMessage());
case BAD_ARGUMENT: case EC_BAD_ARGUMENT:
throw new DebuggerIllegalArgumentException(error.getMessage()); throw new DebuggerIllegalArgumentException(error.getMessage());
case MEMORY_ACCESS: case EC_MEMORY_ACCESS:
throw new DebuggerMemoryAccessException(error.getMessage()); throw new DebuggerMemoryAccessException(error.getMessage());
case REGISTER_ACCESS: case EC_REGISTER_ACCESS:
throw new DebuggerRegisterAccessException(error.getMessage()); throw new DebuggerRegisterAccessException(error.getMessage());
case BAD_ADDRESS: case EC_BAD_ADDRESS:
throw new AssertionError( throw new AssertionError(
"Client implementation sent an invalid address: " + error.getMessage()); "Client implementation sent an invalid address: " + error.getMessage());
case BAD_REQUEST: case EC_BAD_REQUEST:
throw new AssertionError( throw new AssertionError(
"Client implementation sent an invalid request: " + error.getMessage()); "Client implementation sent an invalid request: " + error.getMessage());
case UNRECOGNIZED: case UNRECOGNIZED:
throw new AssertionError( throw new AssertionError(
"Server replied with an error code unknown to the client: " + "Server replied with an error code unknown to the client: " +
error.getCodeValue() + ": " + error.getMessage()); error.getCodeValue() + ": " + error.getMessage());
case USER_ERROR: case EC_USER_ERROR:
throw new DebuggerUserException(error.getMessage()); throw new DebuggerUserException(error.getMessage());
case MODEL_ACCESS: case EC_MODEL_ACCESS:
throw new DebuggerModelAccessException(error.getMessage()); throw new DebuggerModelAccessException(error.getMessage());
case UNKNOWN: case EC_UNKNOWN:
throw new RuntimeException("Unknown: " + error.getMessage()); throw new RuntimeException("Unknown: " + error.getMessage());
case NO_VERSION: case EC_NO_VERSION:
default: default:
throw new GadpErrorException(error.getCode(), error.getMessage()); throw new GadpErrorException(error.getCode(), error.getMessage());
} }

3
Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/AbstractGadpServer.java
View file

@ -23,7 +23,6 @@ import ghidra.comm.service.AbstractAsyncServer;
import ghidra.dbg.*; import ghidra.dbg.*;
import ghidra.dbg.gadp.error.GadpErrorException; import ghidra.dbg.gadp.error.GadpErrorException;
import ghidra.dbg.gadp.protocol.Gadp; import ghidra.dbg.gadp.protocol.Gadp;
import ghidra.dbg.gadp.protocol.Gadp.ErrorCode;
import ghidra.program.model.address.*; import ghidra.program.model.address.*;
public abstract class AbstractGadpServer public abstract class AbstractGadpServer
@ -59,7 +58,7 @@ public abstract class AbstractGadpServer
protected AddressRange getAddressRange(Gadp.AddressRange range) { protected AddressRange getAddressRange(Gadp.AddressRange range) {
AddressSpace space = model.getAddressSpace(range.getSpace()); AddressSpace space = model.getAddressSpace(range.getSpace());
if (space == null) { if (space == null) {
throw new GadpErrorException(ErrorCode.BAD_ADDRESS, throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_ADDRESS,
"Unrecognized address space: " + range); "Unrecognized address space: " + range);
} }
Address min = space.getAddress(range.getOffset()); Address min = space.getAddress(range.getOffset());

27
Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/server/GadpClientHandler.java
View file

@ -292,30 +292,30 @@ public class GadpClientHandler
return channel.write(buildError(req, error.getCode(), error.getMessage())); return channel.write(buildError(req, error.getCode(), error.getMessage()));
} }
if (t instanceof UnsupportedOperationException) { if (t instanceof UnsupportedOperationException) {
return channel.write(buildError(req, ErrorCode.NOT_SUPPORTED, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_NOT_SUPPORTED, t.getMessage()));
} }
if (t instanceof DebuggerModelNoSuchPathException) { if (t instanceof DebuggerModelNoSuchPathException) {
return channel.write(buildError(req, ErrorCode.NO_OBJECT, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_NO_OBJECT, t.getMessage()));
} }
if (t instanceof DebuggerModelTypeException) { if (t instanceof DebuggerModelTypeException) {
return channel.write(buildError(req, ErrorCode.NO_INTERFACE, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_NO_INTERFACE, t.getMessage()));
} }
if (t instanceof DebuggerIllegalArgumentException) { if (t instanceof DebuggerIllegalArgumentException) {
return channel.write(buildError(req, ErrorCode.BAD_ARGUMENT, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_BAD_ARGUMENT, t.getMessage()));
} }
if (t instanceof DebuggerMemoryAccessException) { if (t instanceof DebuggerMemoryAccessException) {
return channel.write(buildError(req, ErrorCode.MEMORY_ACCESS, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_MEMORY_ACCESS, t.getMessage()));
} }
if (t instanceof DebuggerRegisterAccessException) { if (t instanceof DebuggerRegisterAccessException) {
return channel.write(buildError(req, ErrorCode.REGISTER_ACCESS, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_REGISTER_ACCESS, t.getMessage()));
} }
if (t instanceof DebuggerUserException) { if (t instanceof DebuggerUserException) {
return channel.write(buildError(req, ErrorCode.USER_ERROR, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_USER_ERROR, t.getMessage()));
} }
if (t instanceof DebuggerModelAccessException) { if (t instanceof DebuggerModelAccessException) {
return channel.write(buildError(req, ErrorCode.MODEL_ACCESS, t.getMessage())); return channel.write(buildError(req, ErrorCode.EC_MODEL_ACCESS, t.getMessage()));
} }
return channel.write(buildError(req, ErrorCode.UNKNOWN, "Unknown server-side error")); return channel.write(buildError(req, ErrorCode.EC_UNKNOWN, "Unknown server-side error"));
} }
protected GadpVersion getVersion() { protected GadpVersion getVersion() {
@ -367,7 +367,7 @@ public class GadpClientHandler
case INVOKE_REQUEST: case INVOKE_REQUEST:
return processInvoke(msg.getSequence(), msg.getInvokeRequest()); return processInvoke(msg.getSequence(), msg.getInvokeRequest());
default: default:
throw new GadpErrorException(ErrorCode.BAD_REQUEST, throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_REQUEST,
"Unrecognized request: " + msg.getMsgCase()); "Unrecognized request: " + msg.getMsgCase());
} }
} }
@ -375,7 +375,8 @@ public class GadpClientHandler
protected CompletableFuture<?> processConnect(int seqno, Gadp.ConnectRequest req) { protected CompletableFuture<?> processConnect(int seqno, Gadp.ConnectRequest req) {
String ver = getVersion().getName(); String ver = getVersion().getName();
if (!req.getVersionList().contains(ver)) { if (!req.getVersionList().contains(ver)) {
throw new GadpErrorException(ErrorCode.NO_VERSION, "No listed version is supported"); throw new GadpErrorException(Gadp.ErrorCode.EC_NO_VERSION,
"No listed version is supported");
} }
TargetObjectSchema rootSchema = model.getRootSchema(); TargetObjectSchema rootSchema = model.getRootSchema();
return channel.write(Gadp.RootMessage.newBuilder() return channel.write(Gadp.RootMessage.newBuilder()
@ -523,7 +524,7 @@ public class GadpClientHandler
case PID: case PID:
return attacher.attach(req.getPid()); return attacher.attach(req.getPid());
default: default:
throw new GadpErrorException(ErrorCode.BAD_REQUEST, throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_REQUEST,
"Unrecognized attach specification:" + req); "Unrecognized attach specification:" + req);
} }
}).thenCompose(__ -> { }).thenCompose(__ -> {
@ -546,7 +547,7 @@ public class GadpClientHandler
AddressRange range = server.getAddressRange(req.getAddress()); AddressRange range = server.getAddressRange(req.getAddress());
return breaks.placeBreakpoint(range, kinds); return breaks.placeBreakpoint(range, kinds);
default: default:
throw new GadpErrorException(ErrorCode.BAD_REQUEST, throw new GadpErrorException(Gadp.ErrorCode.EC_BAD_REQUEST,
"Unrecognized breakpoint specification: " + req); "Unrecognized breakpoint specification: " + req);
} }
}).thenCompose(__ -> { }).thenCompose(__ -> {

132
Ghidra/Debug/Debugger-gadp/src/main/java/ghidra/dbg/gadp/util/GadpValueUtils.java
View file

@ -67,13 +67,13 @@ public enum GadpValueUtils {
public static TargetBreakpointKind getBreakKind(Gadp.BreakKind kind) { public static TargetBreakpointKind getBreakKind(Gadp.BreakKind kind) {
switch (kind) { switch (kind) {
case READ: case BK_READ:
return TargetBreakpointKind.READ; return TargetBreakpointKind.READ;
case WRITE: case BK_WRITE:
return TargetBreakpointKind.WRITE; return TargetBreakpointKind.WRITE;
case EXECUTE: case BK_EXECUTE:
return TargetBreakpointKind.EXECUTE; return TargetBreakpointKind.EXECUTE;
case SOFTWARE: case BK_SOFTWARE:
return TargetBreakpointKind.SOFTWARE; return TargetBreakpointKind.SOFTWARE;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
@ -89,13 +89,13 @@ public enum GadpValueUtils {
public static Gadp.BreakKind makeBreakKind(TargetBreakpointKind kind) { public static Gadp.BreakKind makeBreakKind(TargetBreakpointKind kind) {
switch (kind) { switch (kind) {
case READ: case READ:
return Gadp.BreakKind.READ; return Gadp.BreakKind.BK_READ;
case WRITE: case WRITE:
return Gadp.BreakKind.WRITE; return Gadp.BreakKind.BK_WRITE;
case EXECUTE: case EXECUTE:
return Gadp.BreakKind.EXECUTE; return Gadp.BreakKind.BK_EXECUTE;
case SOFTWARE: case SOFTWARE:
return Gadp.BreakKind.SOFTWARE; return Gadp.BreakKind.BK_SOFTWARE;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
} }
@ -108,9 +108,9 @@ public enum GadpValueUtils {
public static TargetAttachKind getAttachKind(Gadp.AttachKind kind) { public static TargetAttachKind getAttachKind(Gadp.AttachKind kind) {
switch (kind) { switch (kind) {
case BY_OBJECT_REF: case AK_BY_OBJECT_REF:
return TargetAttachKind.BY_OBJECT_REF; return TargetAttachKind.BY_OBJECT_REF;
case BY_ID: case AK_BY_ID:
return TargetAttachKind.BY_ID; return TargetAttachKind.BY_ID;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
@ -126,9 +126,9 @@ public enum GadpValueUtils {
public static Gadp.AttachKind makeAttachKind(TargetAttachKind kind) { public static Gadp.AttachKind makeAttachKind(TargetAttachKind kind) {
switch (kind) { switch (kind) {
case BY_OBJECT_REF: case BY_OBJECT_REF:
return Gadp.AttachKind.BY_OBJECT_REF; return Gadp.AttachKind.AK_BY_OBJECT_REF;
case BY_ID: case BY_ID:
return Gadp.AttachKind.BY_ID; return Gadp.AttachKind.AK_BY_ID;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
} }
@ -141,23 +141,23 @@ public enum GadpValueUtils {
public static TargetStepKind getStepKind(Gadp.StepKind kind) { public static TargetStepKind getStepKind(Gadp.StepKind kind) {
switch (kind) { switch (kind) {
case ADVANCE: case SK_ADVANCE:
return TargetStepKind.ADVANCE; return TargetStepKind.ADVANCE;
case FINISH: case SK_FINISH:
return TargetStepKind.FINISH; return TargetStepKind.FINISH;
case INTO: case SK_INTO:
return TargetStepKind.INTO; return TargetStepKind.INTO;
case LINE: case SK_LINE:
return TargetStepKind.LINE; return TargetStepKind.LINE;
case OVER: case SK_OVER:
return TargetStepKind.OVER; return TargetStepKind.OVER;
case OVER_LINE: case SK_OVER_LINE:
return TargetStepKind.OVER_LINE; return TargetStepKind.OVER_LINE;
case RETURN: case SK_RETURN:
return TargetStepKind.RETURN; return TargetStepKind.RETURN;
case SKIP: case SK_SKIP:
return TargetStepKind.SKIP; return TargetStepKind.SKIP;
case UNTIL: case SK_UNTIL:
return TargetStepKind.UNTIL; return TargetStepKind.UNTIL;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
@ -167,23 +167,23 @@ public enum GadpValueUtils {
public static Gadp.StepKind makeStepKind(TargetStepKind kind) { public static Gadp.StepKind makeStepKind(TargetStepKind kind) {
switch (kind) { switch (kind) {
case ADVANCE: case ADVANCE:
return Gadp.StepKind.ADVANCE; return Gadp.StepKind.SK_ADVANCE;
case FINISH: case FINISH:
return Gadp.StepKind.FINISH; return Gadp.StepKind.SK_FINISH;
case INTO: case INTO:
return Gadp.StepKind.INTO; return Gadp.StepKind.SK_INTO;
case LINE: case LINE:
return Gadp.StepKind.LINE; return Gadp.StepKind.SK_LINE;
case OVER: case OVER:
return Gadp.StepKind.OVER; return Gadp.StepKind.SK_OVER;
case OVER_LINE: case OVER_LINE:
return Gadp.StepKind.OVER_LINE; return Gadp.StepKind.SK_OVER_LINE;
case RETURN: case RETURN:
return Gadp.StepKind.RETURN; return Gadp.StepKind.SK_RETURN;
case SKIP: case SKIP:
return Gadp.StepKind.SKIP; return Gadp.StepKind.SK_SKIP;
case UNTIL: case UNTIL:
return Gadp.StepKind.UNTIL; return Gadp.StepKind.SK_UNTIL;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
} }
@ -191,15 +191,15 @@ public enum GadpValueUtils {
public static TargetExecutionState getExecutionState(Gadp.ExecutionState state) { public static TargetExecutionState getExecutionState(Gadp.ExecutionState state) {
switch (state) { switch (state) {
case INACTIVE: case ES_INACTIVE:
return TargetExecutionState.INACTIVE; return TargetExecutionState.INACTIVE;
case ALIVE: case ES_ALIVE:
return TargetExecutionState.ALIVE; return TargetExecutionState.ALIVE;
case STOPPED: case ES_STOPPED:
return TargetExecutionState.STOPPED; return TargetExecutionState.STOPPED;
case RUNNING: case ES_RUNNING:
return TargetExecutionState.RUNNING; return TargetExecutionState.RUNNING;
case TERMINATED: case ES_TERMINATED:
return TargetExecutionState.TERMINATED; return TargetExecutionState.TERMINATED;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
@ -209,15 +209,15 @@ public enum GadpValueUtils {
public static Gadp.ExecutionState makeExecutionState(TargetExecutionState state) { public static Gadp.ExecutionState makeExecutionState(TargetExecutionState state) {
switch (state) { switch (state) {
case INACTIVE: case INACTIVE:
return Gadp.ExecutionState.INACTIVE; return Gadp.ExecutionState.ES_INACTIVE;
case ALIVE: case ALIVE:
return Gadp.ExecutionState.ALIVE; return Gadp.ExecutionState.ES_ALIVE;
case STOPPED: case STOPPED:
return Gadp.ExecutionState.STOPPED; return Gadp.ExecutionState.ES_STOPPED;
case RUNNING: case RUNNING:
return Gadp.ExecutionState.RUNNING; return Gadp.ExecutionState.ES_RUNNING;
case TERMINATED: case TERMINATED:
return Gadp.ExecutionState.TERMINATED; return Gadp.ExecutionState.ES_TERMINATED;
default: default:
throw new IllegalArgumentException(); throw new IllegalArgumentException();
} }
@ -230,25 +230,25 @@ public enum GadpValueUtils {
return TargetEventType.STOPPED; return TargetEventType.STOPPED;
case EV_RUNNING: case EV_RUNNING:
return TargetEventType.RUNNING; return TargetEventType.RUNNING;
case PROCESS_CREATED: case EV_PROCESS_CREATED:
return TargetEventType.PROCESS_CREATED; return TargetEventType.PROCESS_CREATED;
case PROCESS_EXITED: case EV_PROCESS_EXITED:
return TargetEventType.PROCESS_EXITED; return TargetEventType.PROCESS_EXITED;
case THREAD_CREATED: case EV_THREAD_CREATED:
return TargetEventType.THREAD_CREATED; return TargetEventType.THREAD_CREATED;
case THREAD_EXITED: case EV_THREAD_EXITED:
return TargetEventType.THREAD_EXITED; return TargetEventType.THREAD_EXITED;
case MODULE_LOADED: case EV_MODULE_LOADED:
return TargetEventType.MODULE_LOADED; return TargetEventType.MODULE_LOADED;
case MODULE_UNLOADED: case EV_MODULE_UNLOADED:
return TargetEventType.MODULE_UNLOADED; return TargetEventType.MODULE_UNLOADED;
case BREAKPOINT_HIT: case EV_BREAKPOINT_HIT:
return TargetEventType.BREAKPOINT_HIT; return TargetEventType.BREAKPOINT_HIT;
case STEP_COMPLETED: case EV_STEP_COMPLETED:
return TargetEventType.STEP_COMPLETED; return TargetEventType.STEP_COMPLETED;
case EXCEPTION: case EV_EXCEPTION:
return TargetEventType.EXCEPTION; return TargetEventType.EXCEPTION;
case SIGNAL: case EV_SIGNAL:
return TargetEventType.SIGNAL; return TargetEventType.SIGNAL;
} }
} }
@ -261,25 +261,25 @@ public enum GadpValueUtils {
case RUNNING: case RUNNING:
return Gadp.TargetEventType.EV_RUNNING; return Gadp.TargetEventType.EV_RUNNING;
case PROCESS_CREATED: case PROCESS_CREATED:
return Gadp.TargetEventType.PROCESS_CREATED; return Gadp.TargetEventType.EV_PROCESS_CREATED;
case PROCESS_EXITED: case PROCESS_EXITED:
return Gadp.TargetEventType.PROCESS_EXITED; return Gadp.TargetEventType.EV_PROCESS_EXITED;
case THREAD_CREATED: case THREAD_CREATED:
return Gadp.TargetEventType.THREAD_CREATED; return Gadp.TargetEventType.EV_THREAD_CREATED;
case THREAD_EXITED: case THREAD_EXITED:
return Gadp.TargetEventType.THREAD_EXITED; return Gadp.TargetEventType.EV_THREAD_EXITED;
case MODULE_LOADED: case MODULE_LOADED:
return Gadp.TargetEventType.MODULE_LOADED; return Gadp.TargetEventType.EV_MODULE_LOADED;
case MODULE_UNLOADED: case MODULE_UNLOADED:
return Gadp.TargetEventType.MODULE_UNLOADED; return Gadp.TargetEventType.EV_MODULE_UNLOADED;
case BREAKPOINT_HIT: case BREAKPOINT_HIT:
return Gadp.TargetEventType.BREAKPOINT_HIT; return Gadp.TargetEventType.EV_BREAKPOINT_HIT;
case STEP_COMPLETED: case STEP_COMPLETED:
return Gadp.TargetEventType.STEP_COMPLETED; return Gadp.TargetEventType.EV_STEP_COMPLETED;
case EXCEPTION: case EXCEPTION:
return Gadp.TargetEventType.EXCEPTION; return Gadp.TargetEventType.EV_EXCEPTION;
case SIGNAL: case SIGNAL:
return Gadp.TargetEventType.SIGNAL; return Gadp.TargetEventType.EV_SIGNAL;
} }
} }
@ -383,22 +383,22 @@ public enum GadpValueUtils {
public static Gadp.UpdateMode makeUpdateMode(TargetUpdateMode mode) { public static Gadp.UpdateMode makeUpdateMode(TargetUpdateMode mode) {
switch (mode) { switch (mode) {
case SOLICITED: case SOLICITED:
return Gadp.UpdateMode.SOLICITED; return Gadp.UpdateMode.UM_SOLICITED;
case FIXED: case FIXED:
return Gadp.UpdateMode.FIXED; return Gadp.UpdateMode.UM_FIXED;
case UNSOLICITED: case UNSOLICITED:
default: default:
return Gadp.UpdateMode.UNSOLICITED; return Gadp.UpdateMode.UM_UNSOLICITED;
} }
} }
public static TargetUpdateMode getUpdateMode(Gadp.UpdateMode mode) { public static TargetUpdateMode getUpdateMode(Gadp.UpdateMode mode) {
switch (mode) { switch (mode) {
case FIXED: case UM_FIXED:
return TargetUpdateMode.FIXED; return TargetUpdateMode.FIXED;
case SOLICITED: case UM_SOLICITED:
return TargetUpdateMode.SOLICITED; return TargetUpdateMode.SOLICITED;
case UNSOLICITED: case UM_UNSOLICITED:
default: default:
return TargetUpdateMode.UNSOLICITED; return TargetUpdateMode.UNSOLICITED;
} }

104
Ghidra/Debug/Debugger-gadp/src/main/proto/gadp.proto
View file

@ -17,18 +17,18 @@ syntax = "proto3";
package ghidra.dbg.gadp.protocol; package ghidra.dbg.gadp.protocol;
enum ErrorCode { enum ErrorCode {
UNKNOWN = 0; EC_UNKNOWN = 0;
BAD_REQUEST = 1; EC_BAD_REQUEST = 1;
NO_VERSION = 2; EC_NO_VERSION = 2;
NO_OBJECT = 3; EC_NO_OBJECT = 3;
NO_INTERFACE = 4; EC_NO_INTERFACE = 4;
BAD_ARGUMENT = 5; EC_BAD_ARGUMENT = 5;
BAD_ADDRESS = 6; EC_BAD_ADDRESS = 6;
NOT_SUPPORTED = 7; EC_NOT_SUPPORTED = 7;
MEMORY_ACCESS = 8; EC_MEMORY_ACCESS = 8;
REGISTER_ACCESS = 9; EC_REGISTER_ACCESS = 9;
USER_ERROR = 10; EC_USER_ERROR = 10;
MODEL_ACCESS = 11; EC_MODEL_ACCESS = 11;
} }
// For testing: cause the server to report an unrecognized request error // For testing: cause the server to report an unrecognized request error
@ -78,10 +78,10 @@ message PathList {
} }
enum BreakKind { enum BreakKind {
READ = 0; BK_READ = 0;
WRITE = 1; BK_WRITE = 1;
EXECUTE = 2; BK_EXECUTE = 2;
SOFTWARE = 3; BK_SOFTWARE = 3;
} }
message BreakKindsSet { message BreakKindsSet {
@ -89,15 +89,15 @@ message BreakKindsSet {
} }
enum StepKind { enum StepKind {
INTO = 0; SK_INTO = 0;
ADVANCE = 1; SK_ADVANCE = 1;
FINISH = 2; SK_FINISH = 2;
LINE = 3; SK_LINE = 3;
OVER = 4; SK_OVER = 4;
OVER_LINE = 5; SK_OVER_LINE = 5;
SKIP = 6; SK_SKIP = 6;
RETURN = 7; SK_RETURN = 7;
UNTIL = 8; SK_UNTIL = 8;
} }
message StepKindsSet { message StepKindsSet {
@ -109,8 +109,8 @@ message StringList {
} }
enum AttachKind { enum AttachKind {
BY_OBJECT_REF = 0; AK_BY_OBJECT_REF = 0;
BY_ID = 1; AK_BY_ID = 1;
} }
message AttachKindSet { message AttachKindSet {
@ -118,20 +118,20 @@ message AttachKindSet {
} }
enum ExecutionState { enum ExecutionState {
INACTIVE = 0; ES_INACTIVE = 0;
ALIVE = 1; ES_ALIVE = 1;
STOPPED = 2; ES_STOPPED = 2;
RUNNING = 3; ES_RUNNING = 3;
TERMINATED = 4; ES_TERMINATED = 4;
} }
enum PrimitiveKind { enum PrimitiveKind {
UNDEFINED = 0; PK_UNDEFINED = 0;
VOID = 1; PK_VOID = 1;
UINT = 2; PK_UINT = 2;
SINT = 3; PK_SINT = 3;
FLOAT = 4; PK_FLOAT = 4;
COMPLEX = 5; PK_COMPLEX = 5;
} }
message DataType { message DataType {
@ -166,9 +166,9 @@ message DataType {
} }
enum UpdateMode { enum UpdateMode {
UNSOLICITED = 0; UM_UNSOLICITED = 0;
SOLICITED = 1; UM_SOLICITED = 1;
FIXED = 2; UM_FIXED = 2;
} }
enum ValueType { enum ValueType {
@ -493,18 +493,18 @@ message InvokeReply {
} }
enum TargetEventType { enum TargetEventType {
EV_STOPPED = 0; // Stupid name conflict EV_STOPPED = 0;
EV_RUNNING = 1; EV_RUNNING = 1;
PROCESS_CREATED = 2; EV_PROCESS_CREATED = 2;
PROCESS_EXITED = 3; EV_PROCESS_EXITED = 3;
THREAD_CREATED = 4; EV_THREAD_CREATED = 4;
THREAD_EXITED = 5; EV_THREAD_EXITED = 5;
MODULE_LOADED = 6; EV_MODULE_LOADED = 6;
MODULE_UNLOADED = 7; EV_MODULE_UNLOADED = 7;
BREAKPOINT_HIT = 8; EV_BREAKPOINT_HIT = 8;
STEP_COMPLETED = 9; EV_STEP_COMPLETED = 9;
EXCEPTION = 10; EV_EXCEPTION = 10;
SIGNAL = 11; EV_SIGNAL = 11;
} }
message TargetEvent { message TargetEvent {