| <html><body> |
| <style> |
| |
| body, h1, h2, h3, div, span, p, pre, a { |
| margin: 0; |
| padding: 0; |
| border: 0; |
| font-weight: inherit; |
| font-style: inherit; |
| font-size: 100%; |
| font-family: inherit; |
| vertical-align: baseline; |
| } |
| |
| body { |
| font-size: 13px; |
| padding: 1em; |
| } |
| |
| h1 { |
| font-size: 26px; |
| margin-bottom: 1em; |
| } |
| |
| h2 { |
| font-size: 24px; |
| margin-bottom: 1em; |
| } |
| |
| h3 { |
| font-size: 20px; |
| margin-bottom: 1em; |
| margin-top: 1em; |
| } |
| |
| pre, code { |
| line-height: 1.5; |
| font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace; |
| } |
| |
| pre { |
| margin-top: 0.5em; |
| } |
| |
| h1, h2, h3, p { |
| font-family: Arial, sans serif; |
| } |
| |
| h1, h2, h3 { |
| border-bottom: solid #CCC 1px; |
| } |
| |
| .toc_element { |
| margin-top: 0.5em; |
| } |
| |
| .firstline { |
| margin-left: 2 em; |
| } |
| |
| .method { |
| margin-top: 1em; |
| border: solid 1px #CCC; |
| padding: 1em; |
| background: #EEE; |
| } |
| |
| .details { |
| font-weight: bold; |
| font-size: 14px; |
| } |
| |
| </style> |
| |
| <h1><a href="clouddebugger_v2.html">Cloud Debugger API</a> . <a href="clouddebugger_v2.controller.html">controller</a> . <a href="clouddebugger_v2.controller.debuggees.html">debuggees</a> . <a href="clouddebugger_v2.controller.debuggees.breakpoints.html">breakpoints</a></h1> |
| <h2>Instance Methods</h2> |
| <p class="toc_element"> |
| <code><a href="#list">list(debuggeeId, agentId=None, waitToken=None, successOnTimeout=None, x__xgafv=None)</a></code></p> |
| <p class="firstline">Returns the list of all active breakpoints for the debuggee.</p> |
| <p class="toc_element"> |
| <code><a href="#update">update(debuggeeId, id, body=None, x__xgafv=None)</a></code></p> |
| <p class="firstline">Updates the breakpoint state or mutable fields.</p> |
| <h3>Method Details</h3> |
| <div class="method"> |
| <code class="details" id="list">list(debuggeeId, agentId=None, waitToken=None, successOnTimeout=None, x__xgafv=None)</code> |
| <pre>Returns the list of all active breakpoints for the debuggee. |
| |
| The breakpoint specification (`location`, `condition`, and `expressions` |
| fields) is semantically immutable, although the field values may |
| change. For example, an agent may update the location line number |
| to reflect the actual line where the breakpoint was set, but this |
| doesn't change the breakpoint semantics. |
| |
| This means that an agent does not need to check if a breakpoint has changed |
| when it encounters the same breakpoint on a successive call. |
| Moreover, an agent should remember the breakpoints that are completed |
| until the controller removes them from the active list to avoid |
| setting those breakpoints again. |
| |
| Args: |
| debuggeeId: string, Required. Identifies the debuggee. (required) |
| agentId: string, Identifies the agent. |
| This is the ID returned in the RegisterDebuggee response. |
| waitToken: string, A token that, if specified, blocks the method call until the list |
| of active breakpoints has changed, or a server-selected timeout has |
| expired. The value should be set from the `next_wait_token` field in |
| the last response. The initial value should be set to `"init"`. |
| successOnTimeout: boolean, If set to `true` (recommended), returns `google.rpc.Code.OK` status and |
| sets the `wait_expired` response field to `true` when the server-selected |
| timeout has expired. |
| |
| If set to `false` (deprecated), returns `google.rpc.Code.ABORTED` status |
| when the server-selected timeout has expired. |
| x__xgafv: string, V1 error format. |
| Allowed values |
| 1 - v1 error format |
| 2 - v2 error format |
| |
| Returns: |
| An object of the form: |
| |
| { # Response for listing active breakpoints. |
| "nextWaitToken": "A String", # A token that can be used in the next method call to block until |
| # the list of breakpoints changes. |
| "breakpoints": [ # List of all active breakpoints. |
| # The fields `id` and `location` are guaranteed to be set on each breakpoint. |
| { # ------------------------------------------------------------------------------ |
| # ## Breakpoint (the resource) |
| # |
| # Represents the breakpoint specification, status and results. |
| "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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| }, |
| ], |
| "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. |
| # |
| # The status includes an error flag and a human readable message. |
| # This field is usually unset. The message can be either |
| # informational or an error message. Regardless, clients should always |
| # display the text message back to the user. |
| # |
| # Error status indicates complete failure of the breakpoint. |
| # |
| # Example (non-final state): `Still loading symbols...` |
| # |
| # Examples (final state): |
| # |
| # * `Invalid line number` referring to location |
| # * `Field f not found in class C` referring to condition |
| # 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. |
| }, |
| "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", |
| ], |
| "labels": { # A set of custom breakpoint properties, populated by the agent, to be |
| # displayed to the user. |
| "a_key": "A String", |
| }, |
| "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when |
| # the breakpoint hits. The message may include parameter placeholders `$0`, |
| # `$1`, etc. These placeholders are replaced with the evaluated value |
| # of the appropriate expression. Expressions not referenced in |
| # `log_message_format` are not logged. |
| # |
| # Example: `Message received, id = $0, count = $1` with |
| # `expressions` = `[ message.id, message.count ]`. |
| "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution. |
| "location": { # Represents a location in the source code. # Breakpoint source location. |
| "path": "A String", # Path to the source file within the source context of the target binary. |
| "line": 42, # Line inside the file. The first line in the file has the value `1`. |
| "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. |
| }, |
| "isFinalState": True or False, # When true, indicates that this is a final result and the |
| # breakpoint state will not change from here on. |
| "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`. |
| "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee. |
| "action": "A String", # Action that the agent should perform when the code at the |
| # breakpoint location is hit. |
| "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds |
| # resolution. |
| "state": "A String", # The current state of the breakpoint. |
| "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most |
| # recently entered function. |
| { # Represents a stack frame context. |
| "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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| }, |
| ], |
| "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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| "line": 42, # Line inside the file. The first line in the file has the value `1`. |
| "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. |
| }, |
| }, |
| ], |
| "userEmail": "A String", # E-mail address of the user that created this 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. |
| "variableTable": [ # The `variable_table` exists to aid with computation, memory and network |
| # traffic optimization. It enables storing a variable once and reference |
| # it from multiple variables, including variables stored in the |
| # `variable_table` itself. |
| # For example, the same `this` object, which may appear at many levels of |
| # the stack, can have all of its data stored once in this table. The |
| # stack frame variables then would hold only a reference to it. |
| # |
| # The variable `var_table_index` field is an index into this repeated field. |
| # The stored objects are nameless and get their name from the referencing |
| # variable. The effective variable is a merge of the referencing variable |
| # and the referenced variable. |
| { # 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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| }, |
| ], |
| }, |
| ], |
| "waitExpired": True or False, # If set to `true`, indicates that there is no change to the |
| # list of active breakpoints and the server-selected timeout has expired. |
| # The `breakpoints` field would be empty and should be ignored. |
| }</pre> |
| </div> |
| |
| <div class="method"> |
| <code class="details" id="update">update(debuggeeId, id, body=None, x__xgafv=None)</code> |
| <pre>Updates the breakpoint state or mutable fields. |
| The entire Breakpoint message must be sent back to the controller service. |
| |
| Updates to active breakpoint fields are only allowed if the new value |
| does not change the breakpoint specification. Updates to the `location`, |
| `condition` and `expressions` fields should not alter the breakpoint |
| semantics. These may only make changes such as canonicalizing a value |
| or snapping the location to the correct line of code. |
| |
| Args: |
| debuggeeId: string, Required. Identifies the debuggee being debugged. (required) |
| id: string, Breakpoint identifier, unique in the scope of the debuggee. (required) |
| body: object, The request body. |
| The object takes the form of: |
| |
| { # Request to update an active breakpoint. |
| "breakpoint": { # ------------------------------------------------------------------------------ # Required. Updated breakpoint information. |
| # The field `id` must be set. |
| # The agent must echo all Breakpoint specification fields in the update. |
| # ## Breakpoint (the resource) |
| # |
| # Represents the breakpoint specification, status and results. |
| "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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| }, |
| ], |
| "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. |
| # |
| # The status includes an error flag and a human readable message. |
| # This field is usually unset. The message can be either |
| # informational or an error message. Regardless, clients should always |
| # display the text message back to the user. |
| # |
| # Error status indicates complete failure of the breakpoint. |
| # |
| # Example (non-final state): `Still loading symbols...` |
| # |
| # Examples (final state): |
| # |
| # * `Invalid line number` referring to location |
| # * `Field f not found in class C` referring to condition |
| # 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. |
| }, |
| "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", |
| ], |
| "labels": { # A set of custom breakpoint properties, populated by the agent, to be |
| # displayed to the user. |
| "a_key": "A String", |
| }, |
| "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when |
| # the breakpoint hits. The message may include parameter placeholders `$0`, |
| # `$1`, etc. These placeholders are replaced with the evaluated value |
| # of the appropriate expression. Expressions not referenced in |
| # `log_message_format` are not logged. |
| # |
| # Example: `Message received, id = $0, count = $1` with |
| # `expressions` = `[ message.id, message.count ]`. |
| "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution. |
| "location": { # Represents a location in the source code. # Breakpoint source location. |
| "path": "A String", # Path to the source file within the source context of the target binary. |
| "line": 42, # Line inside the file. The first line in the file has the value `1`. |
| "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. |
| }, |
| "isFinalState": True or False, # When true, indicates that this is a final result and the |
| # breakpoint state will not change from here on. |
| "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`. |
| "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee. |
| "action": "A String", # Action that the agent should perform when the code at the |
| # breakpoint location is hit. |
| "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds |
| # resolution. |
| "state": "A String", # The current state of the breakpoint. |
| "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most |
| # recently entered function. |
| { # Represents a stack frame context. |
| "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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| }, |
| ], |
| "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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| "line": 42, # Line inside the file. The first line in the file has the value `1`. |
| "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. |
| }, |
| }, |
| ], |
| "userEmail": "A String", # E-mail address of the user that created this 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. |
| "variableTable": [ # The `variable_table` exists to aid with computation, memory and network |
| # traffic optimization. It enables storing a variable once and reference |
| # it from multiple variables, including variables stored in the |
| # `variable_table` itself. |
| # For example, the same `this` object, which may appear at many levels of |
| # the stack, can have all of its data stored once in this table. The |
| # stack frame variables then would hold only a reference to it. |
| # |
| # The variable `var_table_index` field is an index into this repeated field. |
| # The stored objects are nameless and get their name from the referencing |
| # variable. The effective variable is a merge of the referencing variable |
| # and the referenced variable. |
| { # 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. |
| "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. |
| }, |
| "value": "A String", # Simple value of the variable. |
| "members": [ # Members contained or pointed to by the variable. |
| # Object with schema name: Variable |
| ], |
| "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. |
| "name": "A String", # Name of the variable, if any. |
| "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. |
| }, |
| ], |
| }, |
| } |
| |
| x__xgafv: string, V1 error format. |
| Allowed values |
| 1 - v1 error format |
| 2 - v2 error format |
| |
| Returns: |
| An object of the form: |
| |
| { # Response for updating an active breakpoint. |
| # The message is defined to allow future extensions. |
| }</pre> |
| </div> |
| |
| </body></html> |
