| <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.debugger.html">debugger</a> . <a href="clouddebugger_v2.debugger.debuggees.html">debuggees</a> . <a href="clouddebugger_v2.debugger.debuggees.breakpoints.html">breakpoints</a></h1> |
| <h2>Instance Methods</h2> |
| <p class="toc_element"> |
| <code><a href="#delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p> |
| <p class="firstline">Deletes the breakpoint from the debuggee.</p> |
| <p class="toc_element"> |
| <code><a href="#get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p> |
| <p class="firstline">Gets breakpoint information.</p> |
| <p class="toc_element"> |
| <code><a href="#list">list(debuggeeId, includeInactive=None, stripResults=None, waitToken=None, action_value=None, includeAllUsers=None, clientVersion=None, x__xgafv=None)</a></code></p> |
| <p class="firstline">Lists all breakpoints for the debuggee.</p> |
| <p class="toc_element"> |
| <code><a href="#set">set(debuggeeId, body=None, clientVersion=None, canaryOption=None, x__xgafv=None)</a></code></p> |
| <p class="firstline">Sets the breakpoint to the debuggee.</p> |
| <h3>Method Details</h3> |
| <div class="method"> |
| <code class="details" id="delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code> |
| <pre>Deletes the breakpoint from the debuggee. |
| |
| Args: |
| debuggeeId: string, Required. ID of the debuggee whose breakpoint to delete. (required) |
| breakpointId: string, Required. ID of the breakpoint to delete. (required) |
| clientVersion: string, Required. The client version making the call. |
| Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). |
| x__xgafv: string, V1 error format. |
| Allowed values |
| 1 - v1 error format |
| 2 - v2 error format |
| |
| Returns: |
| An object of the form: |
| |
| { # A generic empty message that you can re-use to avoid defining duplicated |
| # empty messages in your APIs. A typical example is to use it as the request |
| # or the response type of an API method. For instance: |
| # |
| # service Foo { |
| # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty); |
| # } |
| # |
| # The JSON representation for `Empty` is empty JSON object `{}`. |
| }</pre> |
| </div> |
| |
| <div class="method"> |
| <code class="details" id="get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code> |
| <pre>Gets breakpoint information. |
| |
| Args: |
| debuggeeId: string, Required. ID of the debuggee whose breakpoint to get. (required) |
| breakpointId: string, Required. ID of the breakpoint to get. (required) |
| clientVersion: string, Required. The client version making the call. |
| Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). |
| x__xgafv: string, V1 error format. |
| Allowed values |
| 1 - v1 error format |
| 2 - v2 error format |
| |
| Returns: |
| An object of the form: |
| |
| { # Response for getting breakpoint information. |
| "breakpoint": { # ------------------------------------------------------------------------------ # Complete breakpoint state. |
| # The fields `id` and `location` are guaranteed to be set. |
| # ## 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. |
| }, |
| ], |
| }, |
| }</pre> |
| </div> |
| |
| <div class="method"> |
| <code class="details" id="list">list(debuggeeId, includeInactive=None, stripResults=None, waitToken=None, action_value=None, includeAllUsers=None, clientVersion=None, x__xgafv=None)</code> |
| <pre>Lists all breakpoints for the debuggee. |
| |
| Args: |
| debuggeeId: string, Required. ID of the debuggee whose breakpoints to list. (required) |
| includeInactive: boolean, When set to `true`, the response includes active and inactive |
| breakpoints. Otherwise, it includes only active breakpoints. |
| stripResults: boolean, This field is deprecated. The following fields are always stripped out of |
| the result: `stack_frames`, `evaluated_expressions` and `variable_table`. |
| waitToken: string, A wait token that, if specified, blocks the call until the breakpoints |
| list has changed, or a server selected timeout has expired. The value |
| should be set from the last response. The error code |
| `google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which |
| should be called again with the same `wait_token`. |
| action_value: string, Only breakpoints with the specified action will pass the filter. |
| includeAllUsers: boolean, When set to `true`, the response includes the list of breakpoints set by |
| any user. Otherwise, it includes only breakpoints set by the caller. |
| clientVersion: string, Required. The client version making the call. |
| Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). |
| 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 breakpoints. |
| "nextWaitToken": "A String", # A wait token that can be used in the next call to `list` (REST) or |
| # `ListBreakpoints` (RPC) to block until the list of breakpoints has changes. |
| "breakpoints": [ # List of breakpoints matching the request. |
| # The fields `id` and `location` are guaranteed to be set on each breakpoint. |
| # The fields: `stack_frames`, `evaluated_expressions` and `variable_table` |
| # are cleared on each breakpoint regardless of its status. |
| { # ------------------------------------------------------------------------------ |
| # ## 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. |
| }, |
| ], |
| }, |
| ], |
| }</pre> |
| </div> |
| |
| <div class="method"> |
| <code class="details" id="set">set(debuggeeId, body=None, clientVersion=None, canaryOption=None, x__xgafv=None)</code> |
| <pre>Sets the breakpoint to the debuggee. |
| |
| Args: |
| debuggeeId: string, Required. ID of the debuggee where the breakpoint is to be set. (required) |
| body: object, The request body. |
| The object takes the form of: |
| |
| { # ------------------------------------------------------------------------------ |
| # ## 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. |
| }, |
| ], |
| } |
| |
| clientVersion: string, Required. The client version making the call. |
| Schema: `domain/type/version` (e.g., `google.com/intellij/v1`). |
| canaryOption: string, The canary option set by the user upon setting 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 setting a breakpoint. |
| "breakpoint": { # ------------------------------------------------------------------------------ # Breakpoint resource. |
| # The field `id` is guaranteed to be set (in addition to the echoed fields). |
| # ## 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. |
| }, |
| ], |
| }, |
| }</pre> |
| </div> |
| |
| </body></html> |
