docs: update docs (#916)
* fix: re-run script
* test: fix noxfile
diff --git a/docs/dyn/clouddebugger_v2.controller.debuggees.breakpoints.html b/docs/dyn/clouddebugger_v2.controller.debuggees.breakpoints.html
index c8401b7..9eaa91e 100644
--- a/docs/dyn/clouddebugger_v2.controller.debuggees.breakpoints.html
+++ b/docs/dyn/clouddebugger_v2.controller.debuggees.breakpoints.html
@@ -126,6 +126,530 @@
# ## Breakpoint (the resource)
#
# Represents the breakpoint specification, status and results.
+ "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
+ # The expressions are composed using expressions in the programming language
+ # at the source location. If the breakpoint action is `LOG`, the evaluated
+ # expressions are included in log statements.
+ "A String",
+ ],
+ "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
+ # The evaluated expressions appear in exactly the same order they
+ # are listed in the `expressions` field.
+ # The `name` field holds the original expression text, the `value` or
+ # `members` field holds the result of the evaluated expression.
+ # If the expression cannot be evaluated, the `status` inside the `Variable`
+ # will indicate an error and contain the error text.
+ { # Represents a variable or an argument possibly of a compound object type.
+ # Note how the following variables are represented:
+ #
+ # 1) A simple variable:
+ #
+ # int x = 5
+ #
+ # { name: "x", value: "5", type: "int" } // Captured variable
+ #
+ # 2) A compound object:
+ #
+ # struct T {
+ # int m1;
+ # int m2;
+ # };
+ # T x = { 3, 7 };
+ #
+ # { // Captured variable
+ # name: "x",
+ # type: "T",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 3) A pointer where the pointee was captured:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00500500",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 4) A pointer where the pointee was not captured:
+ #
+ # T* p = new T;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00400400"
+ # status { is_error: true, description { format: "unavailable" } }
+ # }
+ #
+ # The status should describe the reason for the missing value,
+ # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
+ #
+ # Note that a null pointer should not have members.
+ #
+ # 5) An unnamed value:
+ #
+ # int* p = new int(7);
+ #
+ # { // Captured variable
+ # name: "p",
+ # value: "0x00500500",
+ # type: "int*",
+ # members { value: "7", type: "int" } }
+ #
+ # 6) An unnamed pointer where the pointee was not captured:
+ #
+ # int* p = new int(7);
+ # int** pp = &p;
+ #
+ # { // Captured variable
+ # name: "pp",
+ # value: "0x00500500",
+ # type: "int**",
+ # members {
+ # value: "0x00400400",
+ # type: "int*"
+ # status {
+ # is_error: true,
+ # description: { format: "unavailable" } }
+ # }
+ # }
+ # }
+ #
+ # To optimize computation, memory and network traffic, variables that
+ # repeat in the output multiple times can be stored once in a shared
+ # variable table and be referenced using the `var_table_index` field. The
+ # variables stored in the shared table are nameless and are essentially
+ # a partition of the complete variable. To reconstruct the complete
+ # variable, merge the referencing variable with the referenced variable.
+ #
+ # When using the shared variable table, the following variables:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ # T& r = x;
+ #
+ # { name: "x", var_table_index: 3, type: "T" } // Captured variables
+ # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
+ # { name: "r", type="T&", var_table_index: 3 }
+ #
+ # { // Shared variable table entry #3:
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # Note that the pointer address is stored with the referencing variable
+ # and not with the referenced variable. This allows the referenced variable
+ # to be shared between pointers and references.
+ #
+ # The type field is optional. The debugger agent may or may not support it.
+ "members": [ # Members contained or pointed to by the variable.
+ # Object with schema name: Variable
+ ],
+ "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
+ # unset. A status of a single variable only applies to that variable or
+ # expression. The rest of breakpoint data still remains valid. Variables
+ # might be reported in error state even when breakpoint is not in final
+ # state.
+ #
+ # The message may refer to variable name with `refers_to` set to
+ # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
+ # In either case variable value and members will be unset.
+ #
+ # Example of error message applied to name: `Invalid expression syntax`.
+ #
+ # Example of information message applied to value: `Not captured`.
+ #
+ # Examples of error message applied to value:
+ #
+ # * `Malformed string`,
+ # * `Field f not found in class C`
+ # * `Null pointer dereference`
+ # The message can indicate an error or informational status, and refer to
+ # specific parts of the containing object.
+ # For example, the `Breakpoint.status` field can indicate an error referring
+ # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
+ "isError": True or False, # Distinguishes errors from informational messages.
+ "description": { # Represents a message with parameters. # Status message text.
+ "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
+ # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
+ # character.
+ #
+ # Examples:
+ #
+ # * `Failed to load '$0' which helps debug $1 the first time it
+ # is loaded. Again, $0 is very important.`
+ # * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
+ },
+ "refersTo": "A String", # Reference to which the message applies.
+ },
+ "name": "A String", # Name of the variable, if any.
+ "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
+ # `var_table_index`, `type` goes next to `value`. The interpretation of
+ # a type is agent specific. It is recommended to include the dynamic type
+ # rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
+ "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
+ # one variable can reference the same variable in the table. The
+ # `var_table_index` field is an index into `variable_table` in Breakpoint.
+ },
+ ],
+ "isFinalState": True or False, # When true, indicates that this is a final result and the
+ # breakpoint state will not change from here on.
+ "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most
+ # recently entered function.
+ { # Represents a stack frame context.
+ "locals": [ # Set of local variables at the stack frame location.
+ # Note that this might not be populated for all stack frames.
+ { # Represents a variable or an argument possibly of a compound object type.
+ # Note how the following variables are represented:
+ #
+ # 1) A simple variable:
+ #
+ # int x = 5
+ #
+ # { name: "x", value: "5", type: "int" } // Captured variable
+ #
+ # 2) A compound object:
+ #
+ # struct T {
+ # int m1;
+ # int m2;
+ # };
+ # T x = { 3, 7 };
+ #
+ # { // Captured variable
+ # name: "x",
+ # type: "T",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 3) A pointer where the pointee was captured:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00500500",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 4) A pointer where the pointee was not captured:
+ #
+ # T* p = new T;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00400400"
+ # status { is_error: true, description { format: "unavailable" } }
+ # }
+ #
+ # The status should describe the reason for the missing value,
+ # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
+ #
+ # Note that a null pointer should not have members.
+ #
+ # 5) An unnamed value:
+ #
+ # int* p = new int(7);
+ #
+ # { // Captured variable
+ # name: "p",
+ # value: "0x00500500",
+ # type: "int*",
+ # members { value: "7", type: "int" } }
+ #
+ # 6) An unnamed pointer where the pointee was not captured:
+ #
+ # int* p = new int(7);
+ # int** pp = &p;
+ #
+ # { // Captured variable
+ # name: "pp",
+ # value: "0x00500500",
+ # type: "int**",
+ # members {
+ # value: "0x00400400",
+ # type: "int*"
+ # status {
+ # is_error: true,
+ # description: { format: "unavailable" } }
+ # }
+ # }
+ # }
+ #
+ # To optimize computation, memory and network traffic, variables that
+ # repeat in the output multiple times can be stored once in a shared
+ # variable table and be referenced using the `var_table_index` field. The
+ # variables stored in the shared table are nameless and are essentially
+ # a partition of the complete variable. To reconstruct the complete
+ # variable, merge the referencing variable with the referenced variable.
+ #
+ # When using the shared variable table, the following variables:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ # T& r = x;
+ #
+ # { name: "x", var_table_index: 3, type: "T" } // Captured variables
+ # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
+ # { name: "r", type="T&", var_table_index: 3 }
+ #
+ # { // Shared variable table entry #3:
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # Note that the pointer address is stored with the referencing variable
+ # and not with the referenced variable. This allows the referenced variable
+ # to be shared between pointers and references.
+ #
+ # The type field is optional. The debugger agent may or may not support it.
+ "members": [ # Members contained or pointed to by the variable.
+ # Object with schema name: Variable
+ ],
+ "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
+ # unset. A status of a single variable only applies to that variable or
+ # expression. The rest of breakpoint data still remains valid. Variables
+ # might be reported in error state even when breakpoint is not in final
+ # state.
+ #
+ # The message may refer to variable name with `refers_to` set to
+ # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
+ # In either case variable value and members will be unset.
+ #
+ # Example of error message applied to name: `Invalid expression syntax`.
+ #
+ # Example of information message applied to value: `Not captured`.
+ #
+ # Examples of error message applied to value:
+ #
+ # * `Malformed string`,
+ # * `Field f not found in class C`
+ # * `Null pointer dereference`
+ # The message can indicate an error or informational status, and refer to
+ # specific parts of the containing object.
+ # For example, the `Breakpoint.status` field can indicate an error referring
+ # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
+ "isError": True or False, # Distinguishes errors from informational messages.
+ "description": { # Represents a message with parameters. # Status message text.
+ "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
+ # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
+ # character.
+ #
+ # Examples:
+ #
+ # * `Failed to load '$0' which helps debug $1 the first time it
+ # is loaded. Again, $0 is very important.`
+ # * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
+ },
+ "refersTo": "A String", # Reference to which the message applies.
+ },
+ "name": "A String", # Name of the variable, if any.
+ "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
+ # `var_table_index`, `type` goes next to `value`. The interpretation of
+ # a type is agent specific. It is recommended to include the dynamic type
+ # rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
+ "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
+ # one variable can reference the same variable in the table. The
+ # `var_table_index` field is an index into `variable_table` in Breakpoint.
+ },
+ ],
+ "location": { # Represents a location in the source code. # Source location of the call site.
+ "path": "A String", # Path to the source file within the source context of the target binary.
+ "column": 42, # Column within a line. The first column in a line as the value `1`.
+ # Agents that do not support setting breakpoints on specific columns ignore
+ # this field.
+ "line": 42, # Line inside the file. The first line in the file has the value `1`.
+ },
+ "function": "A String", # Demangled function name at the call site.
+ "arguments": [ # Set of arguments passed to this function.
+ # Note that this might not be populated for all stack frames.
+ { # Represents a variable or an argument possibly of a compound object type.
+ # Note how the following variables are represented:
+ #
+ # 1) A simple variable:
+ #
+ # int x = 5
+ #
+ # { name: "x", value: "5", type: "int" } // Captured variable
+ #
+ # 2) A compound object:
+ #
+ # struct T {
+ # int m1;
+ # int m2;
+ # };
+ # T x = { 3, 7 };
+ #
+ # { // Captured variable
+ # name: "x",
+ # type: "T",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 3) A pointer where the pointee was captured:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00500500",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 4) A pointer where the pointee was not captured:
+ #
+ # T* p = new T;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00400400"
+ # status { is_error: true, description { format: "unavailable" } }
+ # }
+ #
+ # The status should describe the reason for the missing value,
+ # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
+ #
+ # Note that a null pointer should not have members.
+ #
+ # 5) An unnamed value:
+ #
+ # int* p = new int(7);
+ #
+ # { // Captured variable
+ # name: "p",
+ # value: "0x00500500",
+ # type: "int*",
+ # members { value: "7", type: "int" } }
+ #
+ # 6) An unnamed pointer where the pointee was not captured:
+ #
+ # int* p = new int(7);
+ # int** pp = &p;
+ #
+ # { // Captured variable
+ # name: "pp",
+ # value: "0x00500500",
+ # type: "int**",
+ # members {
+ # value: "0x00400400",
+ # type: "int*"
+ # status {
+ # is_error: true,
+ # description: { format: "unavailable" } }
+ # }
+ # }
+ # }
+ #
+ # To optimize computation, memory and network traffic, variables that
+ # repeat in the output multiple times can be stored once in a shared
+ # variable table and be referenced using the `var_table_index` field. The
+ # variables stored in the shared table are nameless and are essentially
+ # a partition of the complete variable. To reconstruct the complete
+ # variable, merge the referencing variable with the referenced variable.
+ #
+ # When using the shared variable table, the following variables:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ # T& r = x;
+ #
+ # { name: "x", var_table_index: 3, type: "T" } // Captured variables
+ # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
+ # { name: "r", type="T&", var_table_index: 3 }
+ #
+ # { // Shared variable table entry #3:
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # Note that the pointer address is stored with the referencing variable
+ # and not with the referenced variable. This allows the referenced variable
+ # to be shared between pointers and references.
+ #
+ # The type field is optional. The debugger agent may or may not support it.
+ "members": [ # Members contained or pointed to by the variable.
+ # Object with schema name: Variable
+ ],
+ "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
+ # unset. A status of a single variable only applies to that variable or
+ # expression. The rest of breakpoint data still remains valid. Variables
+ # might be reported in error state even when breakpoint is not in final
+ # state.
+ #
+ # The message may refer to variable name with `refers_to` set to
+ # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
+ # In either case variable value and members will be unset.
+ #
+ # Example of error message applied to name: `Invalid expression syntax`.
+ #
+ # Example of information message applied to value: `Not captured`.
+ #
+ # Examples of error message applied to value:
+ #
+ # * `Malformed string`,
+ # * `Field f not found in class C`
+ # * `Null pointer dereference`
+ # The message can indicate an error or informational status, and refer to
+ # specific parts of the containing object.
+ # For example, the `Breakpoint.status` field can indicate an error referring
+ # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
+ "isError": True or False, # Distinguishes errors from informational messages.
+ "description": { # Represents a message with parameters. # Status message text.
+ "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
+ # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
+ # character.
+ #
+ # Examples:
+ #
+ # * `Failed to load '$0' which helps debug $1 the first time it
+ # is loaded. Again, $0 is very important.`
+ # * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
+ },
+ "refersTo": "A String", # Reference to which the message applies.
+ },
+ "name": "A String", # Name of the variable, if any.
+ "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
+ # `var_table_index`, `type` goes next to `value`. The interpretation of
+ # a type is agent specific. It is recommended to include the dynamic type
+ # rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
+ "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
+ # one variable can reference the same variable in the table. The
+ # `var_table_index` field is an index into `variable_table` in Breakpoint.
+ },
+ ],
+ },
+ ],
+ "condition": "A String", # Condition that triggers the breakpoint.
+ # The condition is a compound boolean expression composed using expressions
+ # in a programming language at the source location.
"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value
# is meaningless when the breakpoint is not in CANARY_ACTIVE state.
"status": { # Represents a contextual status message. # Breakpoint status.
@@ -149,9 +673,6 @@
# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
"isError": True or False, # Distinguishes errors from informational messages.
"description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
@@ -161,6 +682,9 @@
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
},
"refersTo": "A String", # Reference to which the message applies.
},
@@ -328,9 +852,6 @@
# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
"isError": True or False, # Distinguishes errors from informational messages.
"description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
@@ -340,6 +861,9 @@
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
},
"refersTo": "A String", # Reference to which the message applies.
},
@@ -348,10 +872,10 @@
# `var_table_index`, `type` goes next to `value`. The interpretation of
# a type is agent specific. It is recommended to include the dynamic type
# rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
"varTableIndex": 42, # Reference to a variable in the shared variable table. More than
# one variable can reference the same variable in the table. The
# `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
},
],
"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.
@@ -367,530 +891,6 @@
# displayed to the user.
"a_key": "A String",
},
- "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
- # The expressions are composed using expressions in the programming language
- # at the source location. If the breakpoint action is `LOG`, the evaluated
- # expressions are included in log statements.
- "A String",
- ],
- "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
- # The evaluated expressions appear in exactly the same order they
- # are listed in the `expressions` field.
- # The `name` field holds the original expression text, the `value` or
- # `members` field holds the result of the evaluated expression.
- # If the expression cannot be evaluated, the `status` inside the `Variable`
- # will indicate an error and contain the error text.
- { # Represents a variable or an argument possibly of a compound object type.
- # Note how the following variables are represented:
- #
- # 1) A simple variable:
- #
- # int x = 5
- #
- # { name: "x", value: "5", type: "int" } // Captured variable
- #
- # 2) A compound object:
- #
- # struct T {
- # int m1;
- # int m2;
- # };
- # T x = { 3, 7 };
- #
- # { // Captured variable
- # name: "x",
- # type: "T",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 3) A pointer where the pointee was captured:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00500500",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 4) A pointer where the pointee was not captured:
- #
- # T* p = new T;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00400400"
- # status { is_error: true, description { format: "unavailable" } }
- # }
- #
- # The status should describe the reason for the missing value,
- # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
- #
- # Note that a null pointer should not have members.
- #
- # 5) An unnamed value:
- #
- # int* p = new int(7);
- #
- # { // Captured variable
- # name: "p",
- # value: "0x00500500",
- # type: "int*",
- # members { value: "7", type: "int" } }
- #
- # 6) An unnamed pointer where the pointee was not captured:
- #
- # int* p = new int(7);
- # int** pp = &p;
- #
- # { // Captured variable
- # name: "pp",
- # value: "0x00500500",
- # type: "int**",
- # members {
- # value: "0x00400400",
- # type: "int*"
- # status {
- # is_error: true,
- # description: { format: "unavailable" } }
- # }
- # }
- # }
- #
- # To optimize computation, memory and network traffic, variables that
- # repeat in the output multiple times can be stored once in a shared
- # variable table and be referenced using the `var_table_index` field. The
- # variables stored in the shared table are nameless and are essentially
- # a partition of the complete variable. To reconstruct the complete
- # variable, merge the referencing variable with the referenced variable.
- #
- # When using the shared variable table, the following variables:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- # T& r = x;
- #
- # { name: "x", var_table_index: 3, type: "T" } // Captured variables
- # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
- # { name: "r", type="T&", var_table_index: 3 }
- #
- # { // Shared variable table entry #3:
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # Note that the pointer address is stored with the referencing variable
- # and not with the referenced variable. This allows the referenced variable
- # to be shared between pointers and references.
- #
- # The type field is optional. The debugger agent may or may not support it.
- "members": [ # Members contained or pointed to by the variable.
- # Object with schema name: Variable
- ],
- "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
- # unset. A status of a single variable only applies to that variable or
- # expression. The rest of breakpoint data still remains valid. Variables
- # might be reported in error state even when breakpoint is not in final
- # state.
- #
- # The message may refer to variable name with `refers_to` set to
- # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
- # In either case variable value and members will be unset.
- #
- # Example of error message applied to name: `Invalid expression syntax`.
- #
- # Example of information message applied to value: `Not captured`.
- #
- # Examples of error message applied to value:
- #
- # * `Malformed string`,
- # * `Field f not found in class C`
- # * `Null pointer dereference`
- # The message can indicate an error or informational status, and refer to
- # specific parts of the containing object.
- # For example, the `Breakpoint.status` field can indicate an error referring
- # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
- "isError": True or False, # Distinguishes errors from informational messages.
- "description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
- "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
- # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
- # character.
- #
- # Examples:
- #
- # * `Failed to load '$0' which helps debug $1 the first time it
- # is loaded. Again, $0 is very important.`
- # * `Please pay $$10 to use $0 instead of $1.`
- },
- "refersTo": "A String", # Reference to which the message applies.
- },
- "name": "A String", # Name of the variable, if any.
- "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
- # `var_table_index`, `type` goes next to `value`. The interpretation of
- # a type is agent specific. It is recommended to include the dynamic type
- # rather than a static type of an object.
- "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
- # one variable can reference the same variable in the table. The
- # `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
- },
- ],
- "isFinalState": True or False, # When true, indicates that this is a final result and the
- # breakpoint state will not change from here on.
- "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most
- # recently entered function.
- { # Represents a stack frame context.
- "arguments": [ # Set of arguments passed to this function.
- # Note that this might not be populated for all stack frames.
- { # Represents a variable or an argument possibly of a compound object type.
- # Note how the following variables are represented:
- #
- # 1) A simple variable:
- #
- # int x = 5
- #
- # { name: "x", value: "5", type: "int" } // Captured variable
- #
- # 2) A compound object:
- #
- # struct T {
- # int m1;
- # int m2;
- # };
- # T x = { 3, 7 };
- #
- # { // Captured variable
- # name: "x",
- # type: "T",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 3) A pointer where the pointee was captured:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00500500",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 4) A pointer where the pointee was not captured:
- #
- # T* p = new T;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00400400"
- # status { is_error: true, description { format: "unavailable" } }
- # }
- #
- # The status should describe the reason for the missing value,
- # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
- #
- # Note that a null pointer should not have members.
- #
- # 5) An unnamed value:
- #
- # int* p = new int(7);
- #
- # { // Captured variable
- # name: "p",
- # value: "0x00500500",
- # type: "int*",
- # members { value: "7", type: "int" } }
- #
- # 6) An unnamed pointer where the pointee was not captured:
- #
- # int* p = new int(7);
- # int** pp = &p;
- #
- # { // Captured variable
- # name: "pp",
- # value: "0x00500500",
- # type: "int**",
- # members {
- # value: "0x00400400",
- # type: "int*"
- # status {
- # is_error: true,
- # description: { format: "unavailable" } }
- # }
- # }
- # }
- #
- # To optimize computation, memory and network traffic, variables that
- # repeat in the output multiple times can be stored once in a shared
- # variable table and be referenced using the `var_table_index` field. The
- # variables stored in the shared table are nameless and are essentially
- # a partition of the complete variable. To reconstruct the complete
- # variable, merge the referencing variable with the referenced variable.
- #
- # When using the shared variable table, the following variables:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- # T& r = x;
- #
- # { name: "x", var_table_index: 3, type: "T" } // Captured variables
- # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
- # { name: "r", type="T&", var_table_index: 3 }
- #
- # { // Shared variable table entry #3:
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # Note that the pointer address is stored with the referencing variable
- # and not with the referenced variable. This allows the referenced variable
- # to be shared between pointers and references.
- #
- # The type field is optional. The debugger agent may or may not support it.
- "members": [ # Members contained or pointed to by the variable.
- # Object with schema name: Variable
- ],
- "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
- # unset. A status of a single variable only applies to that variable or
- # expression. The rest of breakpoint data still remains valid. Variables
- # might be reported in error state even when breakpoint is not in final
- # state.
- #
- # The message may refer to variable name with `refers_to` set to
- # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
- # In either case variable value and members will be unset.
- #
- # Example of error message applied to name: `Invalid expression syntax`.
- #
- # Example of information message applied to value: `Not captured`.
- #
- # Examples of error message applied to value:
- #
- # * `Malformed string`,
- # * `Field f not found in class C`
- # * `Null pointer dereference`
- # The message can indicate an error or informational status, and refer to
- # specific parts of the containing object.
- # For example, the `Breakpoint.status` field can indicate an error referring
- # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
- "isError": True or False, # Distinguishes errors from informational messages.
- "description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
- "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
- # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
- # character.
- #
- # Examples:
- #
- # * `Failed to load '$0' which helps debug $1 the first time it
- # is loaded. Again, $0 is very important.`
- # * `Please pay $$10 to use $0 instead of $1.`
- },
- "refersTo": "A String", # Reference to which the message applies.
- },
- "name": "A String", # Name of the variable, if any.
- "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
- # `var_table_index`, `type` goes next to `value`. The interpretation of
- # a type is agent specific. It is recommended to include the dynamic type
- # rather than a static type of an object.
- "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
- # one variable can reference the same variable in the table. The
- # `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
- },
- ],
- "locals": [ # Set of local variables at the stack frame location.
- # Note that this might not be populated for all stack frames.
- { # Represents a variable or an argument possibly of a compound object type.
- # Note how the following variables are represented:
- #
- # 1) A simple variable:
- #
- # int x = 5
- #
- # { name: "x", value: "5", type: "int" } // Captured variable
- #
- # 2) A compound object:
- #
- # struct T {
- # int m1;
- # int m2;
- # };
- # T x = { 3, 7 };
- #
- # { // Captured variable
- # name: "x",
- # type: "T",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 3) A pointer where the pointee was captured:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00500500",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 4) A pointer where the pointee was not captured:
- #
- # T* p = new T;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00400400"
- # status { is_error: true, description { format: "unavailable" } }
- # }
- #
- # The status should describe the reason for the missing value,
- # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
- #
- # Note that a null pointer should not have members.
- #
- # 5) An unnamed value:
- #
- # int* p = new int(7);
- #
- # { // Captured variable
- # name: "p",
- # value: "0x00500500",
- # type: "int*",
- # members { value: "7", type: "int" } }
- #
- # 6) An unnamed pointer where the pointee was not captured:
- #
- # int* p = new int(7);
- # int** pp = &p;
- #
- # { // Captured variable
- # name: "pp",
- # value: "0x00500500",
- # type: "int**",
- # members {
- # value: "0x00400400",
- # type: "int*"
- # status {
- # is_error: true,
- # description: { format: "unavailable" } }
- # }
- # }
- # }
- #
- # To optimize computation, memory and network traffic, variables that
- # repeat in the output multiple times can be stored once in a shared
- # variable table and be referenced using the `var_table_index` field. The
- # variables stored in the shared table are nameless and are essentially
- # a partition of the complete variable. To reconstruct the complete
- # variable, merge the referencing variable with the referenced variable.
- #
- # When using the shared variable table, the following variables:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- # T& r = x;
- #
- # { name: "x", var_table_index: 3, type: "T" } // Captured variables
- # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
- # { name: "r", type="T&", var_table_index: 3 }
- #
- # { // Shared variable table entry #3:
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # Note that the pointer address is stored with the referencing variable
- # and not with the referenced variable. This allows the referenced variable
- # to be shared between pointers and references.
- #
- # The type field is optional. The debugger agent may or may not support it.
- "members": [ # Members contained or pointed to by the variable.
- # Object with schema name: Variable
- ],
- "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
- # unset. A status of a single variable only applies to that variable or
- # expression. The rest of breakpoint data still remains valid. Variables
- # might be reported in error state even when breakpoint is not in final
- # state.
- #
- # The message may refer to variable name with `refers_to` set to
- # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
- # In either case variable value and members will be unset.
- #
- # Example of error message applied to name: `Invalid expression syntax`.
- #
- # Example of information message applied to value: `Not captured`.
- #
- # Examples of error message applied to value:
- #
- # * `Malformed string`,
- # * `Field f not found in class C`
- # * `Null pointer dereference`
- # The message can indicate an error or informational status, and refer to
- # specific parts of the containing object.
- # For example, the `Breakpoint.status` field can indicate an error referring
- # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
- "isError": True or False, # Distinguishes errors from informational messages.
- "description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
- "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
- # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
- # character.
- #
- # Examples:
- #
- # * `Failed to load '$0' which helps debug $1 the first time it
- # is loaded. Again, $0 is very important.`
- # * `Please pay $$10 to use $0 instead of $1.`
- },
- "refersTo": "A String", # Reference to which the message applies.
- },
- "name": "A String", # Name of the variable, if any.
- "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
- # `var_table_index`, `type` goes next to `value`. The interpretation of
- # a type is agent specific. It is recommended to include the dynamic type
- # rather than a static type of an object.
- "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
- # one variable can reference the same variable in the table. The
- # `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
- },
- ],
- "location": { # Represents a location in the source code. # Source location of the call site.
- "path": "A String", # Path to the source file within the source context of the target binary.
- "column": 42, # Column within a line. The first column in a line as the value `1`.
- # Agents that do not support setting breakpoints on specific columns ignore
- # this field.
- "line": 42, # Line inside the file. The first line in the file has the value `1`.
- },
- "function": "A String", # Demangled function name at the call site.
- },
- ],
- "condition": "A String", # Condition that triggers the breakpoint.
- # The condition is a compound boolean expression composed using expressions
- # in a programming language at the source location.
},
],
"waitExpired": True or False, # If set to `true`, indicates that there is no change to the
@@ -925,6 +925,530 @@
# ## Breakpoint (the resource)
#
# Represents the breakpoint specification, status and results.
+ "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
+ # The expressions are composed using expressions in the programming language
+ # at the source location. If the breakpoint action is `LOG`, the evaluated
+ # expressions are included in log statements.
+ "A String",
+ ],
+ "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
+ # The evaluated expressions appear in exactly the same order they
+ # are listed in the `expressions` field.
+ # The `name` field holds the original expression text, the `value` or
+ # `members` field holds the result of the evaluated expression.
+ # If the expression cannot be evaluated, the `status` inside the `Variable`
+ # will indicate an error and contain the error text.
+ { # Represents a variable or an argument possibly of a compound object type.
+ # Note how the following variables are represented:
+ #
+ # 1) A simple variable:
+ #
+ # int x = 5
+ #
+ # { name: "x", value: "5", type: "int" } // Captured variable
+ #
+ # 2) A compound object:
+ #
+ # struct T {
+ # int m1;
+ # int m2;
+ # };
+ # T x = { 3, 7 };
+ #
+ # { // Captured variable
+ # name: "x",
+ # type: "T",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 3) A pointer where the pointee was captured:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00500500",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 4) A pointer where the pointee was not captured:
+ #
+ # T* p = new T;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00400400"
+ # status { is_error: true, description { format: "unavailable" } }
+ # }
+ #
+ # The status should describe the reason for the missing value,
+ # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
+ #
+ # Note that a null pointer should not have members.
+ #
+ # 5) An unnamed value:
+ #
+ # int* p = new int(7);
+ #
+ # { // Captured variable
+ # name: "p",
+ # value: "0x00500500",
+ # type: "int*",
+ # members { value: "7", type: "int" } }
+ #
+ # 6) An unnamed pointer where the pointee was not captured:
+ #
+ # int* p = new int(7);
+ # int** pp = &p;
+ #
+ # { // Captured variable
+ # name: "pp",
+ # value: "0x00500500",
+ # type: "int**",
+ # members {
+ # value: "0x00400400",
+ # type: "int*"
+ # status {
+ # is_error: true,
+ # description: { format: "unavailable" } }
+ # }
+ # }
+ # }
+ #
+ # To optimize computation, memory and network traffic, variables that
+ # repeat in the output multiple times can be stored once in a shared
+ # variable table and be referenced using the `var_table_index` field. The
+ # variables stored in the shared table are nameless and are essentially
+ # a partition of the complete variable. To reconstruct the complete
+ # variable, merge the referencing variable with the referenced variable.
+ #
+ # When using the shared variable table, the following variables:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ # T& r = x;
+ #
+ # { name: "x", var_table_index: 3, type: "T" } // Captured variables
+ # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
+ # { name: "r", type="T&", var_table_index: 3 }
+ #
+ # { // Shared variable table entry #3:
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # Note that the pointer address is stored with the referencing variable
+ # and not with the referenced variable. This allows the referenced variable
+ # to be shared between pointers and references.
+ #
+ # The type field is optional. The debugger agent may or may not support it.
+ "members": [ # Members contained or pointed to by the variable.
+ # Object with schema name: Variable
+ ],
+ "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
+ # unset. A status of a single variable only applies to that variable or
+ # expression. The rest of breakpoint data still remains valid. Variables
+ # might be reported in error state even when breakpoint is not in final
+ # state.
+ #
+ # The message may refer to variable name with `refers_to` set to
+ # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
+ # In either case variable value and members will be unset.
+ #
+ # Example of error message applied to name: `Invalid expression syntax`.
+ #
+ # Example of information message applied to value: `Not captured`.
+ #
+ # Examples of error message applied to value:
+ #
+ # * `Malformed string`,
+ # * `Field f not found in class C`
+ # * `Null pointer dereference`
+ # The message can indicate an error or informational status, and refer to
+ # specific parts of the containing object.
+ # For example, the `Breakpoint.status` field can indicate an error referring
+ # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
+ "isError": True or False, # Distinguishes errors from informational messages.
+ "description": { # Represents a message with parameters. # Status message text.
+ "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
+ # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
+ # character.
+ #
+ # Examples:
+ #
+ # * `Failed to load '$0' which helps debug $1 the first time it
+ # is loaded. Again, $0 is very important.`
+ # * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
+ },
+ "refersTo": "A String", # Reference to which the message applies.
+ },
+ "name": "A String", # Name of the variable, if any.
+ "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
+ # `var_table_index`, `type` goes next to `value`. The interpretation of
+ # a type is agent specific. It is recommended to include the dynamic type
+ # rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
+ "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
+ # one variable can reference the same variable in the table. The
+ # `var_table_index` field is an index into `variable_table` in Breakpoint.
+ },
+ ],
+ "isFinalState": True or False, # When true, indicates that this is a final result and the
+ # breakpoint state will not change from here on.
+ "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most
+ # recently entered function.
+ { # Represents a stack frame context.
+ "locals": [ # Set of local variables at the stack frame location.
+ # Note that this might not be populated for all stack frames.
+ { # Represents a variable or an argument possibly of a compound object type.
+ # Note how the following variables are represented:
+ #
+ # 1) A simple variable:
+ #
+ # int x = 5
+ #
+ # { name: "x", value: "5", type: "int" } // Captured variable
+ #
+ # 2) A compound object:
+ #
+ # struct T {
+ # int m1;
+ # int m2;
+ # };
+ # T x = { 3, 7 };
+ #
+ # { // Captured variable
+ # name: "x",
+ # type: "T",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 3) A pointer where the pointee was captured:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00500500",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 4) A pointer where the pointee was not captured:
+ #
+ # T* p = new T;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00400400"
+ # status { is_error: true, description { format: "unavailable" } }
+ # }
+ #
+ # The status should describe the reason for the missing value,
+ # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
+ #
+ # Note that a null pointer should not have members.
+ #
+ # 5) An unnamed value:
+ #
+ # int* p = new int(7);
+ #
+ # { // Captured variable
+ # name: "p",
+ # value: "0x00500500",
+ # type: "int*",
+ # members { value: "7", type: "int" } }
+ #
+ # 6) An unnamed pointer where the pointee was not captured:
+ #
+ # int* p = new int(7);
+ # int** pp = &p;
+ #
+ # { // Captured variable
+ # name: "pp",
+ # value: "0x00500500",
+ # type: "int**",
+ # members {
+ # value: "0x00400400",
+ # type: "int*"
+ # status {
+ # is_error: true,
+ # description: { format: "unavailable" } }
+ # }
+ # }
+ # }
+ #
+ # To optimize computation, memory and network traffic, variables that
+ # repeat in the output multiple times can be stored once in a shared
+ # variable table and be referenced using the `var_table_index` field. The
+ # variables stored in the shared table are nameless and are essentially
+ # a partition of the complete variable. To reconstruct the complete
+ # variable, merge the referencing variable with the referenced variable.
+ #
+ # When using the shared variable table, the following variables:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ # T& r = x;
+ #
+ # { name: "x", var_table_index: 3, type: "T" } // Captured variables
+ # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
+ # { name: "r", type="T&", var_table_index: 3 }
+ #
+ # { // Shared variable table entry #3:
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # Note that the pointer address is stored with the referencing variable
+ # and not with the referenced variable. This allows the referenced variable
+ # to be shared between pointers and references.
+ #
+ # The type field is optional. The debugger agent may or may not support it.
+ "members": [ # Members contained or pointed to by the variable.
+ # Object with schema name: Variable
+ ],
+ "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
+ # unset. A status of a single variable only applies to that variable or
+ # expression. The rest of breakpoint data still remains valid. Variables
+ # might be reported in error state even when breakpoint is not in final
+ # state.
+ #
+ # The message may refer to variable name with `refers_to` set to
+ # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
+ # In either case variable value and members will be unset.
+ #
+ # Example of error message applied to name: `Invalid expression syntax`.
+ #
+ # Example of information message applied to value: `Not captured`.
+ #
+ # Examples of error message applied to value:
+ #
+ # * `Malformed string`,
+ # * `Field f not found in class C`
+ # * `Null pointer dereference`
+ # The message can indicate an error or informational status, and refer to
+ # specific parts of the containing object.
+ # For example, the `Breakpoint.status` field can indicate an error referring
+ # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
+ "isError": True or False, # Distinguishes errors from informational messages.
+ "description": { # Represents a message with parameters. # Status message text.
+ "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
+ # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
+ # character.
+ #
+ # Examples:
+ #
+ # * `Failed to load '$0' which helps debug $1 the first time it
+ # is loaded. Again, $0 is very important.`
+ # * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
+ },
+ "refersTo": "A String", # Reference to which the message applies.
+ },
+ "name": "A String", # Name of the variable, if any.
+ "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
+ # `var_table_index`, `type` goes next to `value`. The interpretation of
+ # a type is agent specific. It is recommended to include the dynamic type
+ # rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
+ "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
+ # one variable can reference the same variable in the table. The
+ # `var_table_index` field is an index into `variable_table` in Breakpoint.
+ },
+ ],
+ "location": { # Represents a location in the source code. # Source location of the call site.
+ "path": "A String", # Path to the source file within the source context of the target binary.
+ "column": 42, # Column within a line. The first column in a line as the value `1`.
+ # Agents that do not support setting breakpoints on specific columns ignore
+ # this field.
+ "line": 42, # Line inside the file. The first line in the file has the value `1`.
+ },
+ "function": "A String", # Demangled function name at the call site.
+ "arguments": [ # Set of arguments passed to this function.
+ # Note that this might not be populated for all stack frames.
+ { # Represents a variable or an argument possibly of a compound object type.
+ # Note how the following variables are represented:
+ #
+ # 1) A simple variable:
+ #
+ # int x = 5
+ #
+ # { name: "x", value: "5", type: "int" } // Captured variable
+ #
+ # 2) A compound object:
+ #
+ # struct T {
+ # int m1;
+ # int m2;
+ # };
+ # T x = { 3, 7 };
+ #
+ # { // Captured variable
+ # name: "x",
+ # type: "T",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 3) A pointer where the pointee was captured:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00500500",
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # 4) A pointer where the pointee was not captured:
+ #
+ # T* p = new T;
+ #
+ # { // Captured variable
+ # name: "p",
+ # type: "T*",
+ # value: "0x00400400"
+ # status { is_error: true, description { format: "unavailable" } }
+ # }
+ #
+ # The status should describe the reason for the missing value,
+ # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
+ #
+ # Note that a null pointer should not have members.
+ #
+ # 5) An unnamed value:
+ #
+ # int* p = new int(7);
+ #
+ # { // Captured variable
+ # name: "p",
+ # value: "0x00500500",
+ # type: "int*",
+ # members { value: "7", type: "int" } }
+ #
+ # 6) An unnamed pointer where the pointee was not captured:
+ #
+ # int* p = new int(7);
+ # int** pp = &p;
+ #
+ # { // Captured variable
+ # name: "pp",
+ # value: "0x00500500",
+ # type: "int**",
+ # members {
+ # value: "0x00400400",
+ # type: "int*"
+ # status {
+ # is_error: true,
+ # description: { format: "unavailable" } }
+ # }
+ # }
+ # }
+ #
+ # To optimize computation, memory and network traffic, variables that
+ # repeat in the output multiple times can be stored once in a shared
+ # variable table and be referenced using the `var_table_index` field. The
+ # variables stored in the shared table are nameless and are essentially
+ # a partition of the complete variable. To reconstruct the complete
+ # variable, merge the referencing variable with the referenced variable.
+ #
+ # When using the shared variable table, the following variables:
+ #
+ # T x = { 3, 7 };
+ # T* p = &x;
+ # T& r = x;
+ #
+ # { name: "x", var_table_index: 3, type: "T" } // Captured variables
+ # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
+ # { name: "r", type="T&", var_table_index: 3 }
+ #
+ # { // Shared variable table entry #3:
+ # members { name: "m1", value: "3", type: "int" },
+ # members { name: "m2", value: "7", type: "int" }
+ # }
+ #
+ # Note that the pointer address is stored with the referencing variable
+ # and not with the referenced variable. This allows the referenced variable
+ # to be shared between pointers and references.
+ #
+ # The type field is optional. The debugger agent may or may not support it.
+ "members": [ # Members contained or pointed to by the variable.
+ # Object with schema name: Variable
+ ],
+ "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
+ # unset. A status of a single variable only applies to that variable or
+ # expression. The rest of breakpoint data still remains valid. Variables
+ # might be reported in error state even when breakpoint is not in final
+ # state.
+ #
+ # The message may refer to variable name with `refers_to` set to
+ # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
+ # In either case variable value and members will be unset.
+ #
+ # Example of error message applied to name: `Invalid expression syntax`.
+ #
+ # Example of information message applied to value: `Not captured`.
+ #
+ # Examples of error message applied to value:
+ #
+ # * `Malformed string`,
+ # * `Field f not found in class C`
+ # * `Null pointer dereference`
+ # The message can indicate an error or informational status, and refer to
+ # specific parts of the containing object.
+ # For example, the `Breakpoint.status` field can indicate an error referring
+ # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
+ "isError": True or False, # Distinguishes errors from informational messages.
+ "description": { # Represents a message with parameters. # Status message text.
+ "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
+ # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
+ # character.
+ #
+ # Examples:
+ #
+ # * `Failed to load '$0' which helps debug $1 the first time it
+ # is loaded. Again, $0 is very important.`
+ # * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
+ },
+ "refersTo": "A String", # Reference to which the message applies.
+ },
+ "name": "A String", # Name of the variable, if any.
+ "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
+ # `var_table_index`, `type` goes next to `value`. The interpretation of
+ # a type is agent specific. It is recommended to include the dynamic type
+ # rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
+ "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
+ # one variable can reference the same variable in the table. The
+ # `var_table_index` field is an index into `variable_table` in Breakpoint.
+ },
+ ],
+ },
+ ],
+ "condition": "A String", # Condition that triggers the breakpoint.
+ # The condition is a compound boolean expression composed using expressions
+ # in a programming language at the source location.
"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value
# is meaningless when the breakpoint is not in CANARY_ACTIVE state.
"status": { # Represents a contextual status message. # Breakpoint status.
@@ -948,9 +1472,6 @@
# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
"isError": True or False, # Distinguishes errors from informational messages.
"description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
@@ -960,6 +1481,9 @@
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
},
"refersTo": "A String", # Reference to which the message applies.
},
@@ -1127,9 +1651,6 @@
# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
"isError": True or False, # Distinguishes errors from informational messages.
"description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
@@ -1139,6 +1660,9 @@
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
+ "parameters": [ # Optional parameters to be embedded into the message.
+ "A String",
+ ],
},
"refersTo": "A String", # Reference to which the message applies.
},
@@ -1147,10 +1671,10 @@
# `var_table_index`, `type` goes next to `value`. The interpretation of
# a type is agent specific. It is recommended to include the dynamic type
# rather than a static type of an object.
+ "value": "A String", # Simple value of the variable.
"varTableIndex": 42, # Reference to a variable in the shared variable table. More than
# one variable can reference the same variable in the table. The
# `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
},
],
"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.
@@ -1166,530 +1690,6 @@
# displayed to the user.
"a_key": "A String",
},
- "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
- # The expressions are composed using expressions in the programming language
- # at the source location. If the breakpoint action is `LOG`, the evaluated
- # expressions are included in log statements.
- "A String",
- ],
- "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
- # The evaluated expressions appear in exactly the same order they
- # are listed in the `expressions` field.
- # The `name` field holds the original expression text, the `value` or
- # `members` field holds the result of the evaluated expression.
- # If the expression cannot be evaluated, the `status` inside the `Variable`
- # will indicate an error and contain the error text.
- { # Represents a variable or an argument possibly of a compound object type.
- # Note how the following variables are represented:
- #
- # 1) A simple variable:
- #
- # int x = 5
- #
- # { name: "x", value: "5", type: "int" } // Captured variable
- #
- # 2) A compound object:
- #
- # struct T {
- # int m1;
- # int m2;
- # };
- # T x = { 3, 7 };
- #
- # { // Captured variable
- # name: "x",
- # type: "T",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 3) A pointer where the pointee was captured:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00500500",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 4) A pointer where the pointee was not captured:
- #
- # T* p = new T;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00400400"
- # status { is_error: true, description { format: "unavailable" } }
- # }
- #
- # The status should describe the reason for the missing value,
- # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
- #
- # Note that a null pointer should not have members.
- #
- # 5) An unnamed value:
- #
- # int* p = new int(7);
- #
- # { // Captured variable
- # name: "p",
- # value: "0x00500500",
- # type: "int*",
- # members { value: "7", type: "int" } }
- #
- # 6) An unnamed pointer where the pointee was not captured:
- #
- # int* p = new int(7);
- # int** pp = &p;
- #
- # { // Captured variable
- # name: "pp",
- # value: "0x00500500",
- # type: "int**",
- # members {
- # value: "0x00400400",
- # type: "int*"
- # status {
- # is_error: true,
- # description: { format: "unavailable" } }
- # }
- # }
- # }
- #
- # To optimize computation, memory and network traffic, variables that
- # repeat in the output multiple times can be stored once in a shared
- # variable table and be referenced using the `var_table_index` field. The
- # variables stored in the shared table are nameless and are essentially
- # a partition of the complete variable. To reconstruct the complete
- # variable, merge the referencing variable with the referenced variable.
- #
- # When using the shared variable table, the following variables:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- # T& r = x;
- #
- # { name: "x", var_table_index: 3, type: "T" } // Captured variables
- # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
- # { name: "r", type="T&", var_table_index: 3 }
- #
- # { // Shared variable table entry #3:
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # Note that the pointer address is stored with the referencing variable
- # and not with the referenced variable. This allows the referenced variable
- # to be shared between pointers and references.
- #
- # The type field is optional. The debugger agent may or may not support it.
- "members": [ # Members contained or pointed to by the variable.
- # Object with schema name: Variable
- ],
- "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
- # unset. A status of a single variable only applies to that variable or
- # expression. The rest of breakpoint data still remains valid. Variables
- # might be reported in error state even when breakpoint is not in final
- # state.
- #
- # The message may refer to variable name with `refers_to` set to
- # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
- # In either case variable value and members will be unset.
- #
- # Example of error message applied to name: `Invalid expression syntax`.
- #
- # Example of information message applied to value: `Not captured`.
- #
- # Examples of error message applied to value:
- #
- # * `Malformed string`,
- # * `Field f not found in class C`
- # * `Null pointer dereference`
- # The message can indicate an error or informational status, and refer to
- # specific parts of the containing object.
- # For example, the `Breakpoint.status` field can indicate an error referring
- # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
- "isError": True or False, # Distinguishes errors from informational messages.
- "description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
- "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
- # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
- # character.
- #
- # Examples:
- #
- # * `Failed to load '$0' which helps debug $1 the first time it
- # is loaded. Again, $0 is very important.`
- # * `Please pay $$10 to use $0 instead of $1.`
- },
- "refersTo": "A String", # Reference to which the message applies.
- },
- "name": "A String", # Name of the variable, if any.
- "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
- # `var_table_index`, `type` goes next to `value`. The interpretation of
- # a type is agent specific. It is recommended to include the dynamic type
- # rather than a static type of an object.
- "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
- # one variable can reference the same variable in the table. The
- # `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
- },
- ],
- "isFinalState": True or False, # When true, indicates that this is a final result and the
- # breakpoint state will not change from here on.
- "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most
- # recently entered function.
- { # Represents a stack frame context.
- "arguments": [ # Set of arguments passed to this function.
- # Note that this might not be populated for all stack frames.
- { # Represents a variable or an argument possibly of a compound object type.
- # Note how the following variables are represented:
- #
- # 1) A simple variable:
- #
- # int x = 5
- #
- # { name: "x", value: "5", type: "int" } // Captured variable
- #
- # 2) A compound object:
- #
- # struct T {
- # int m1;
- # int m2;
- # };
- # T x = { 3, 7 };
- #
- # { // Captured variable
- # name: "x",
- # type: "T",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 3) A pointer where the pointee was captured:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00500500",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 4) A pointer where the pointee was not captured:
- #
- # T* p = new T;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00400400"
- # status { is_error: true, description { format: "unavailable" } }
- # }
- #
- # The status should describe the reason for the missing value,
- # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
- #
- # Note that a null pointer should not have members.
- #
- # 5) An unnamed value:
- #
- # int* p = new int(7);
- #
- # { // Captured variable
- # name: "p",
- # value: "0x00500500",
- # type: "int*",
- # members { value: "7", type: "int" } }
- #
- # 6) An unnamed pointer where the pointee was not captured:
- #
- # int* p = new int(7);
- # int** pp = &p;
- #
- # { // Captured variable
- # name: "pp",
- # value: "0x00500500",
- # type: "int**",
- # members {
- # value: "0x00400400",
- # type: "int*"
- # status {
- # is_error: true,
- # description: { format: "unavailable" } }
- # }
- # }
- # }
- #
- # To optimize computation, memory and network traffic, variables that
- # repeat in the output multiple times can be stored once in a shared
- # variable table and be referenced using the `var_table_index` field. The
- # variables stored in the shared table are nameless and are essentially
- # a partition of the complete variable. To reconstruct the complete
- # variable, merge the referencing variable with the referenced variable.
- #
- # When using the shared variable table, the following variables:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- # T& r = x;
- #
- # { name: "x", var_table_index: 3, type: "T" } // Captured variables
- # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
- # { name: "r", type="T&", var_table_index: 3 }
- #
- # { // Shared variable table entry #3:
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # Note that the pointer address is stored with the referencing variable
- # and not with the referenced variable. This allows the referenced variable
- # to be shared between pointers and references.
- #
- # The type field is optional. The debugger agent may or may not support it.
- "members": [ # Members contained or pointed to by the variable.
- # Object with schema name: Variable
- ],
- "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
- # unset. A status of a single variable only applies to that variable or
- # expression. The rest of breakpoint data still remains valid. Variables
- # might be reported in error state even when breakpoint is not in final
- # state.
- #
- # The message may refer to variable name with `refers_to` set to
- # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
- # In either case variable value and members will be unset.
- #
- # Example of error message applied to name: `Invalid expression syntax`.
- #
- # Example of information message applied to value: `Not captured`.
- #
- # Examples of error message applied to value:
- #
- # * `Malformed string`,
- # * `Field f not found in class C`
- # * `Null pointer dereference`
- # The message can indicate an error or informational status, and refer to
- # specific parts of the containing object.
- # For example, the `Breakpoint.status` field can indicate an error referring
- # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
- "isError": True or False, # Distinguishes errors from informational messages.
- "description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
- "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
- # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
- # character.
- #
- # Examples:
- #
- # * `Failed to load '$0' which helps debug $1 the first time it
- # is loaded. Again, $0 is very important.`
- # * `Please pay $$10 to use $0 instead of $1.`
- },
- "refersTo": "A String", # Reference to which the message applies.
- },
- "name": "A String", # Name of the variable, if any.
- "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
- # `var_table_index`, `type` goes next to `value`. The interpretation of
- # a type is agent specific. It is recommended to include the dynamic type
- # rather than a static type of an object.
- "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
- # one variable can reference the same variable in the table. The
- # `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
- },
- ],
- "locals": [ # Set of local variables at the stack frame location.
- # Note that this might not be populated for all stack frames.
- { # Represents a variable or an argument possibly of a compound object type.
- # Note how the following variables are represented:
- #
- # 1) A simple variable:
- #
- # int x = 5
- #
- # { name: "x", value: "5", type: "int" } // Captured variable
- #
- # 2) A compound object:
- #
- # struct T {
- # int m1;
- # int m2;
- # };
- # T x = { 3, 7 };
- #
- # { // Captured variable
- # name: "x",
- # type: "T",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 3) A pointer where the pointee was captured:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00500500",
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # 4) A pointer where the pointee was not captured:
- #
- # T* p = new T;
- #
- # { // Captured variable
- # name: "p",
- # type: "T*",
- # value: "0x00400400"
- # status { is_error: true, description { format: "unavailable" } }
- # }
- #
- # The status should describe the reason for the missing value,
- # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
- #
- # Note that a null pointer should not have members.
- #
- # 5) An unnamed value:
- #
- # int* p = new int(7);
- #
- # { // Captured variable
- # name: "p",
- # value: "0x00500500",
- # type: "int*",
- # members { value: "7", type: "int" } }
- #
- # 6) An unnamed pointer where the pointee was not captured:
- #
- # int* p = new int(7);
- # int** pp = &p;
- #
- # { // Captured variable
- # name: "pp",
- # value: "0x00500500",
- # type: "int**",
- # members {
- # value: "0x00400400",
- # type: "int*"
- # status {
- # is_error: true,
- # description: { format: "unavailable" } }
- # }
- # }
- # }
- #
- # To optimize computation, memory and network traffic, variables that
- # repeat in the output multiple times can be stored once in a shared
- # variable table and be referenced using the `var_table_index` field. The
- # variables stored in the shared table are nameless and are essentially
- # a partition of the complete variable. To reconstruct the complete
- # variable, merge the referencing variable with the referenced variable.
- #
- # When using the shared variable table, the following variables:
- #
- # T x = { 3, 7 };
- # T* p = &x;
- # T& r = x;
- #
- # { name: "x", var_table_index: 3, type: "T" } // Captured variables
- # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
- # { name: "r", type="T&", var_table_index: 3 }
- #
- # { // Shared variable table entry #3:
- # members { name: "m1", value: "3", type: "int" },
- # members { name: "m2", value: "7", type: "int" }
- # }
- #
- # Note that the pointer address is stored with the referencing variable
- # and not with the referenced variable. This allows the referenced variable
- # to be shared between pointers and references.
- #
- # The type field is optional. The debugger agent may or may not support it.
- "members": [ # Members contained or pointed to by the variable.
- # Object with schema name: Variable
- ],
- "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
- # unset. A status of a single variable only applies to that variable or
- # expression. The rest of breakpoint data still remains valid. Variables
- # might be reported in error state even when breakpoint is not in final
- # state.
- #
- # The message may refer to variable name with `refers_to` set to
- # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
- # In either case variable value and members will be unset.
- #
- # Example of error message applied to name: `Invalid expression syntax`.
- #
- # Example of information message applied to value: `Not captured`.
- #
- # Examples of error message applied to value:
- #
- # * `Malformed string`,
- # * `Field f not found in class C`
- # * `Null pointer dereference`
- # The message can indicate an error or informational status, and refer to
- # specific parts of the containing object.
- # For example, the `Breakpoint.status` field can indicate an error referring
- # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
- "isError": True or False, # Distinguishes errors from informational messages.
- "description": { # Represents a message with parameters. # Status message text.
- "parameters": [ # Optional parameters to be embedded into the message.
- "A String",
- ],
- "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
- # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
- # character.
- #
- # Examples:
- #
- # * `Failed to load '$0' which helps debug $1 the first time it
- # is loaded. Again, $0 is very important.`
- # * `Please pay $$10 to use $0 instead of $1.`
- },
- "refersTo": "A String", # Reference to which the message applies.
- },
- "name": "A String", # Name of the variable, if any.
- "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
- # `var_table_index`, `type` goes next to `value`. The interpretation of
- # a type is agent specific. It is recommended to include the dynamic type
- # rather than a static type of an object.
- "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
- # one variable can reference the same variable in the table. The
- # `var_table_index` field is an index into `variable_table` in Breakpoint.
- "value": "A String", # Simple value of the variable.
- },
- ],
- "location": { # Represents a location in the source code. # Source location of the call site.
- "path": "A String", # Path to the source file within the source context of the target binary.
- "column": 42, # Column within a line. The first column in a line as the value `1`.
- # Agents that do not support setting breakpoints on specific columns ignore
- # this field.
- "line": 42, # Line inside the file. The first line in the file has the value `1`.
- },
- "function": "A String", # Demangled function name at the call site.
- },
- ],
- "condition": "A String", # Condition that triggers the breakpoint.
- # The condition is a compound boolean expression composed using expressions
- # in a programming language at the source location.
},
}