Google Git
Sign in
android / platform / external / python / google-api-python-client / refs/heads/android11-dev / . / docs / dyn / clouddebugger_v2.debugger.debuggees.breakpoints.html
blob: 3f1fb8132ceddef265630b0f7cb654dc36e8eaec [file] [log] [blame] [edit]
<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">Stackdriver 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, includeAllUsers=None, includeInactive=None, x__xgafv=None, clientVersion=None, stripResults=None, action_value=None, waitToken=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, clientVersion=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, ID of the debuggee whose breakpoint to delete. (required)
breakpointId: string, ID of the breakpoint to delete. (required)
clientVersion: string, 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, ID of the debuggee whose breakpoint to get. (required)
breakpointId: string, ID of the breakpoint to get. (required)
clientVersion: string, 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": { # Represents the breakpoint specification, status and results. # Complete breakpoint state.
# The fields `id` and `location` are guaranteed to be set.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"userEmail": "A String", # E-mail address of the user that created this breakpoint
"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 ]`.
"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
"labels": { # A set of custom breakpoint properties, populated by the agent, to be
# displayed to the user.
"a_key": "A String",
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"location": { # Represents a location in the source code. # Source location of the call site.
"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.
"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`.
},
},
],
"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.
"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.
"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`.
},
"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
# resolution.
"action": "A String", # Action that the agent should perform when the code at the
# breakpoint location is hit.
"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",
],
"isFinalState": True or False, # When true, indicates that this is a final result and the
# breakpoint state will not change from here on.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
"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.
},
}</pre>
</div>
<div class="method">
<code class="details" id="list">list(debuggeeId, includeAllUsers=None, includeInactive=None, x__xgafv=None, clientVersion=None, stripResults=None, action_value=None, waitToken=None)</code>
<pre>Lists all breakpoints for the debuggee.
Args:
debuggeeId: string, ID of the debuggee whose breakpoints to list. (required)
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.
includeInactive: boolean, When set to `true`, the response includes active and inactive
breakpoints. Otherwise, it includes only active breakpoints.
x__xgafv: string, V1 error format.
Allowed values
1 - v1 error format
2 - v2 error format
clientVersion: string, The client version making the call.
Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).
stripResults: boolean, This field is deprecated. The following fields are always stripped out of
the result: `stack_frames`, `evaluated_expressions` and `variable_table`.
action_value: string, Only breakpoints with the specified action will pass the filter.
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`.
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.
{ # Represents the breakpoint specification, status and results.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"userEmail": "A String", # E-mail address of the user that created this breakpoint
"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 ]`.
"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
"labels": { # A set of custom breakpoint properties, populated by the agent, to be
# displayed to the user.
"a_key": "A String",
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"location": { # Represents a location in the source code. # Source location of the call site.
"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.
"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`.
},
},
],
"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.
"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.
"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`.
},
"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
# resolution.
"action": "A String", # Action that the agent should perform when the code at the
# breakpoint location is hit.
"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",
],
"isFinalState": True or False, # When true, indicates that this is a final result and the
# breakpoint state will not change from here on.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
"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.
},
],
}</pre>
</div>
<div class="method">
<code class="details" id="set">set(debuggeeId, body, clientVersion=None, x__xgafv=None)</code>
<pre>Sets the breakpoint to the debuggee.
Args:
debuggeeId: string, ID of the debuggee where the breakpoint is to be set. (required)
body: object, The request body. (required)
The object takes the form of:
{ # Represents the breakpoint specification, status and results.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"userEmail": "A String", # E-mail address of the user that created this breakpoint
"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 ]`.
"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
"labels": { # A set of custom breakpoint properties, populated by the agent, to be
# displayed to the user.
"a_key": "A String",
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"location": { # Represents a location in the source code. # Source location of the call site.
"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.
"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`.
},
},
],
"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.
"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.
"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`.
},
"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
# resolution.
"action": "A String", # Action that the agent should perform when the code at the
# breakpoint location is hit.
"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",
],
"isFinalState": True or False, # When true, indicates that this is a final result and the
# breakpoint state will not change from here on.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
"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.
}
clientVersion: string, 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 setting a breakpoint.
"breakpoint": { # Represents the breakpoint specification, status and results. # Breakpoint resource.
# The field `id` is guaranteed to be set (in addition to the echoed fileds).
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"userEmail": "A String", # E-mail address of the user that created this breakpoint
"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 ]`.
"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
"labels": { # A set of custom breakpoint properties, populated by the agent, to be
# displayed to the user.
"a_key": "A String",
},
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"location": { # Represents a location in the source code. # Source location of the call site.
"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.
"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`.
},
},
],
"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.
"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.
"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`.
},
"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
# resolution.
"action": "A String", # Action that the agent should perform when the code at the
# breakpoint location is hit.
"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",
],
"isFinalState": True or False, # When true, indicates that this is a final result and the
# breakpoint state will not change from here on.
"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.
"refersTo": "A String", # Reference to which the message applies.
"description": { # Represents a message with parameters. # Status message text.
"parameters": [ # Optional parameters to be embedded into the message.
"A String",
],
"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
# character.
#
# Examples:
#
# * `Failed to load '$0' which helps debug $1 the first time it
# is loaded. Again, $0 is very important.`
# * `Please pay $$10 to use $0 instead of $1.`
},
},
"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.
"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.
},
],
"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
"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.
},
}</pre>
</div>
</body></html>