blob: d84c5dd3245a5f9d6d5958119c4638321ad9c1c8 [file] [log] [blame]
Takashi Matsuo06694102015-09-11 13:55:40 -07001<html><body>
2<style>
3
4body, h1, h2, h3, div, span, p, pre, a {
5 margin: 0;
6 padding: 0;
7 border: 0;
8 font-weight: inherit;
9 font-style: inherit;
10 font-size: 100%;
11 font-family: inherit;
12 vertical-align: baseline;
13}
14
15body {
16 font-size: 13px;
17 padding: 1em;
18}
19
20h1 {
21 font-size: 26px;
22 margin-bottom: 1em;
23}
24
25h2 {
26 font-size: 24px;
27 margin-bottom: 1em;
28}
29
30h3 {
31 font-size: 20px;
32 margin-bottom: 1em;
33 margin-top: 1em;
34}
35
36pre, code {
37 line-height: 1.5;
38 font-family: Monaco, 'DejaVu Sans Mono', 'Bitstream Vera Sans Mono', 'Lucida Console', monospace;
39}
40
41pre {
42 margin-top: 0.5em;
43}
44
45h1, h2, h3, p {
46 font-family: Arial, sans serif;
47}
48
49h1, h2, h3 {
50 border-bottom: solid #CCC 1px;
51}
52
53.toc_element {
54 margin-top: 0.5em;
55}
56
57.firstline {
58 margin-left: 2 em;
59}
60
61.method {
62 margin-top: 1em;
63 border: solid 1px #CCC;
64 padding: 1em;
65 background: #EEE;
66}
67
68.details {
69 font-weight: bold;
70 font-size: 14px;
71}
72
73</style>
74
Jon Wayne Parrott7d5badb2016-08-16 12:44:29 -070075<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>
Takashi Matsuo06694102015-09-11 13:55:40 -070076<h2>Instance Methods</h2>
77<p class="toc_element">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -070078 <code><a href="#delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>
Takashi Matsuo06694102015-09-11 13:55:40 -070079<p class="firstline">Deletes the breakpoint from the debuggee.</p>
80<p class="toc_element">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -070081 <code><a href="#get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>
Takashi Matsuo06694102015-09-11 13:55:40 -070082<p class="firstline">Gets breakpoint information.</p>
83<p class="toc_element">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -070084 <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>
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -080085<p class="firstline">Lists all breakpoints for the debuggee.</p>
Takashi Matsuo06694102015-09-11 13:55:40 -070086<p class="toc_element">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -070087 <code><a href="#set">set(debuggeeId, body, clientVersion=None, x__xgafv=None)</a></code></p>
Takashi Matsuo06694102015-09-11 13:55:40 -070088<p class="firstline">Sets the breakpoint to the debuggee.</p>
89<h3>Method Details</h3>
90<div class="method">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -070091 <code class="details" id="delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>
Takashi Matsuo06694102015-09-11 13:55:40 -070092 <pre>Deletes the breakpoint from the debuggee.
93
94Args:
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -080095 debuggeeId: string, ID of the debuggee whose breakpoint to delete. (required)
96 breakpointId: string, ID of the breakpoint to delete. (required)
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -040097 clientVersion: string, The client version making the call.
98Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
Takashi Matsuo06694102015-09-11 13:55:40 -070099 x__xgafv: string, V1 error format.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400100 Allowed values
101 1 - v1 error format
102 2 - v2 error format
Takashi Matsuo06694102015-09-11 13:55:40 -0700103
104Returns:
105 An object of the form:
106
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400107 { # A generic empty message that you can re-use to avoid defining duplicated
108 # empty messages in your APIs. A typical example is to use it as the request
109 # or the response type of an API method. For instance:
110 #
111 # service Foo {
112 # rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
113 # }
114 #
115 # The JSON representation for `Empty` is empty JSON object `{}`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700116 }</pre>
117</div>
118
119<div class="method">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700120 <code class="details" id="get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>
Takashi Matsuo06694102015-09-11 13:55:40 -0700121 <pre>Gets breakpoint information.
122
123Args:
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800124 debuggeeId: string, ID of the debuggee whose breakpoint to get. (required)
125 breakpointId: string, ID of the breakpoint to get. (required)
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400126 clientVersion: string, The client version making the call.
127Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
Takashi Matsuo06694102015-09-11 13:55:40 -0700128 x__xgafv: string, V1 error format.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400129 Allowed values
130 1 - v1 error format
131 2 - v2 error format
Takashi Matsuo06694102015-09-11 13:55:40 -0700132
133Returns:
134 An object of the form:
135
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800136 { # Response for getting breakpoint information.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400137 "breakpoint": { # Represents the breakpoint specification, status and results. # Complete breakpoint state.
138 # The fields `id` and `location` are guaranteed to be set.
139 "status": { # Represents a contextual status message. # Breakpoint status.
140 #
141 # The status includes an error flag and a human readable message.
142 # This field is usually unset. The message can be either
143 # informational or an error message. Regardless, clients should always
144 # display the text message back to the user.
145 #
146 # Error status indicates complete failure of the breakpoint.
147 #
148 # Example (non-final state): `Still loading symbols...`
149 #
150 # Examples (final state):
151 #
152 # * `Invalid line number` referring to location
153 # * `Field f not found in class C` referring to condition
154 # The message can indicate an error or informational status, and refer to
155 # specific parts of the containing object.
156 # For example, the `Breakpoint.status` field can indicate an error referring
157 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700158 "isError": True or False, # Distinguishes errors from informational messages.
159 "refersTo": "A String", # Reference to which the message applies.
160 "description": { # Represents a message with parameters. # Status message text.
161 "parameters": [ # Optional parameters to be embedded into the message.
162 "A String",
163 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400164 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
165 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
166 # character.
167 #
168 # Examples:
169 #
170 # * `Failed to load '$0' which helps debug $1 the first time it
171 # is loaded. Again, $0 is very important.`
172 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -0700173 },
174 },
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400175 "variableTable": [ # The `variable_table` exists to aid with computation, memory and network
176 # traffic optimization. It enables storing a variable once and reference
177 # it from multiple variables, including variables stored in the
178 # `variable_table` itself.
179 # For example, the same `this` object, which may appear at many levels of
180 # the stack, can have all of its data stored once in this table. The
181 # stack frame variables then would hold only a reference to it.
182 #
183 # The variable `var_table_index` field is an index into this repeated field.
184 # The stored objects are nameless and get their name from the referencing
185 # variable. The effective variable is a merge of the referencing variable
186 # and the referenced variable.
187 { # Represents a variable or an argument possibly of a compound object type.
188 # Note how the following variables are represented:
189 #
190 # 1) A simple variable:
191 #
192 # int x = 5
193 #
194 # { name: "x", value: "5", type: "int" } // Captured variable
195 #
196 # 2) A compound object:
197 #
198 # struct T {
199 # int m1;
200 # int m2;
201 # };
202 # T x = { 3, 7 };
203 #
204 # { // Captured variable
205 # name: "x",
206 # type: "T",
207 # members { name: "m1", value: "3", type: "int" },
208 # members { name: "m2", value: "7", type: "int" }
209 # }
210 #
211 # 3) A pointer where the pointee was captured:
212 #
213 # T x = { 3, 7 };
214 # T* p = &x;
215 #
216 # { // Captured variable
217 # name: "p",
218 # type: "T*",
219 # value: "0x00500500",
220 # members { name: "m1", value: "3", type: "int" },
221 # members { name: "m2", value: "7", type: "int" }
222 # }
223 #
224 # 4) A pointer where the pointee was not captured:
225 #
226 # T* p = new T;
227 #
228 # { // Captured variable
229 # name: "p",
230 # type: "T*",
231 # value: "0x00400400"
232 # status { is_error: true, description { format: "unavailable" } }
233 # }
234 #
235 # The status should describe the reason for the missing value,
236 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
237 #
238 # Note that a null pointer should not have members.
239 #
240 # 5) An unnamed value:
241 #
242 # int* p = new int(7);
243 #
244 # { // Captured variable
245 # name: "p",
246 # value: "0x00500500",
247 # type: "int*",
248 # members { value: "7", type: "int" } }
249 #
250 # 6) An unnamed pointer where the pointee was not captured:
251 #
252 # int* p = new int(7);
253 # int** pp = &p;
254 #
255 # { // Captured variable
256 # name: "pp",
257 # value: "0x00500500",
258 # type: "int**",
259 # members {
260 # value: "0x00400400",
261 # type: "int*"
262 # status {
263 # is_error: true,
264 # description: { format: "unavailable" } }
265 # }
266 # }
267 # }
268 #
269 # To optimize computation, memory and network traffic, variables that
270 # repeat in the output multiple times can be stored once in a shared
271 # variable table and be referenced using the `var_table_index` field. The
272 # variables stored in the shared table are nameless and are essentially
273 # a partition of the complete variable. To reconstruct the complete
274 # variable, merge the referencing variable with the referenced variable.
275 #
276 # When using the shared variable table, the following variables:
277 #
278 # T x = { 3, 7 };
279 # T* p = &x;
280 # T& r = x;
281 #
282 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
283 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
284 # { name: "r", type="T&", var_table_index: 3 }
285 #
286 # { // Shared variable table entry #3:
287 # members { name: "m1", value: "3", type: "int" },
288 # members { name: "m2", value: "7", type: "int" }
289 # }
290 #
291 # Note that the pointer address is stored with the referencing variable
292 # and not with the referenced variable. This allows the referenced variable
293 # to be shared between pointers and references.
294 #
295 # The type field is optional. The debugger agent may or may not support it.
296 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
297 # unset. A status of a single variable only applies to that variable or
298 # expression. The rest of breakpoint data still remains valid. Variables
299 # might be reported in error state even when breakpoint is not in final
300 # state.
301 #
302 # The message may refer to variable name with `refers_to` set to
303 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
304 # In either case variable value and members will be unset.
305 #
306 # Example of error message applied to name: `Invalid expression syntax`.
307 #
308 # Example of information message applied to value: `Not captured`.
309 #
310 # Examples of error message applied to value:
311 #
312 # * `Malformed string`,
313 # * `Field f not found in class C`
314 # * `Null pointer dereference`
315 # The message can indicate an error or informational status, and refer to
316 # specific parts of the containing object.
317 # For example, the `Breakpoint.status` field can indicate an error referring
318 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700319 "isError": True or False, # Distinguishes errors from informational messages.
320 "refersTo": "A String", # Reference to which the message applies.
321 "description": { # Represents a message with parameters. # Status message text.
322 "parameters": [ # Optional parameters to be embedded into the message.
323 "A String",
324 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400325 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
326 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
327 # character.
328 #
329 # Examples:
330 #
331 # * `Failed to load '$0' which helps debug $1 the first time it
332 # is loaded. Again, $0 is very important.`
333 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -0700334 },
335 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800336 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400337 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
338 # one variable can reference the same variable in the table. The
339 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800340 "value": "A String", # Simple value of the variable.
341 "members": [ # Members contained or pointed to by the variable.
342 # Object with schema name: Variable
343 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400344 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
345 # `var_table_index`, `type` goes next to `value`. The interpretation of
346 # a type is agent specific. It is recommended to include the dynamic type
347 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -0700348 },
349 ],
Thomas Coffee2f245372017-03-27 10:39:26 -0700350 "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
351 # resolution.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800352 "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400353 "labels": { # A set of custom breakpoint properties, populated by the agent, to be
354 # displayed to the user.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700355 "a_key": "A String",
356 },
Thomas Coffee2f245372017-03-27 10:39:26 -0700357 "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when
358 # the breakpoint hits. The message may include parameter placeholders `$0`,
359 # `$1`, etc. These placeholders are replaced with the evaluated value
360 # of the appropriate expression. Expressions not referenced in
361 # `log_message_format` are not logged.
362 #
363 # Example: `Message received, id = $0, count = $1` with
364 # `expressions` = `[ message.id, message.count ]`.
365 "userEmail": "A String", # E-mail address of the user that created this breakpoint
366 "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.
Takashi Matsuo06694102015-09-11 13:55:40 -0700367 "stackFrames": [ # The stack at breakpoint time.
368 { # Represents a stack frame context.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800369 "function": "A String", # Demangled function name at the call site.
Thomas Coffee2f245372017-03-27 10:39:26 -0700370 "location": { # Represents a location in the source code. # Source location of the call site.
371 "path": "A String", # Path to the source file within the source context of the target binary.
372 "line": 42, # Line inside the file. The first line in the file has the value `1`.
373 },
Sai Cheemalapatie833b792017-03-24 15:06:46 -0700374 "locals": [ # Set of local variables at the stack frame location.
375 # Note that this might not be populated for all stack frames.
376 { # Represents a variable or an argument possibly of a compound object type.
377 # Note how the following variables are represented:
378 #
379 # 1) A simple variable:
380 #
381 # int x = 5
382 #
383 # { name: "x", value: "5", type: "int" } // Captured variable
384 #
385 # 2) A compound object:
386 #
387 # struct T {
388 # int m1;
389 # int m2;
390 # };
391 # T x = { 3, 7 };
392 #
393 # { // Captured variable
394 # name: "x",
395 # type: "T",
396 # members { name: "m1", value: "3", type: "int" },
397 # members { name: "m2", value: "7", type: "int" }
398 # }
399 #
400 # 3) A pointer where the pointee was captured:
401 #
402 # T x = { 3, 7 };
403 # T* p = &x;
404 #
405 # { // Captured variable
406 # name: "p",
407 # type: "T*",
408 # value: "0x00500500",
409 # members { name: "m1", value: "3", type: "int" },
410 # members { name: "m2", value: "7", type: "int" }
411 # }
412 #
413 # 4) A pointer where the pointee was not captured:
414 #
415 # T* p = new T;
416 #
417 # { // Captured variable
418 # name: "p",
419 # type: "T*",
420 # value: "0x00400400"
421 # status { is_error: true, description { format: "unavailable" } }
422 # }
423 #
424 # The status should describe the reason for the missing value,
425 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
426 #
427 # Note that a null pointer should not have members.
428 #
429 # 5) An unnamed value:
430 #
431 # int* p = new int(7);
432 #
433 # { // Captured variable
434 # name: "p",
435 # value: "0x00500500",
436 # type: "int*",
437 # members { value: "7", type: "int" } }
438 #
439 # 6) An unnamed pointer where the pointee was not captured:
440 #
441 # int* p = new int(7);
442 # int** pp = &p;
443 #
444 # { // Captured variable
445 # name: "pp",
446 # value: "0x00500500",
447 # type: "int**",
448 # members {
449 # value: "0x00400400",
450 # type: "int*"
451 # status {
452 # is_error: true,
453 # description: { format: "unavailable" } }
454 # }
455 # }
456 # }
457 #
458 # To optimize computation, memory and network traffic, variables that
459 # repeat in the output multiple times can be stored once in a shared
460 # variable table and be referenced using the `var_table_index` field. The
461 # variables stored in the shared table are nameless and are essentially
462 # a partition of the complete variable. To reconstruct the complete
463 # variable, merge the referencing variable with the referenced variable.
464 #
465 # When using the shared variable table, the following variables:
466 #
467 # T x = { 3, 7 };
468 # T* p = &x;
469 # T& r = x;
470 #
471 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
472 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
473 # { name: "r", type="T&", var_table_index: 3 }
474 #
475 # { // Shared variable table entry #3:
476 # members { name: "m1", value: "3", type: "int" },
477 # members { name: "m2", value: "7", type: "int" }
478 # }
479 #
480 # Note that the pointer address is stored with the referencing variable
481 # and not with the referenced variable. This allows the referenced variable
482 # to be shared between pointers and references.
483 #
484 # The type field is optional. The debugger agent may or may not support it.
485 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
486 # unset. A status of a single variable only applies to that variable or
487 # expression. The rest of breakpoint data still remains valid. Variables
488 # might be reported in error state even when breakpoint is not in final
489 # state.
490 #
491 # The message may refer to variable name with `refers_to` set to
492 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
493 # In either case variable value and members will be unset.
494 #
495 # Example of error message applied to name: `Invalid expression syntax`.
496 #
497 # Example of information message applied to value: `Not captured`.
498 #
499 # Examples of error message applied to value:
500 #
501 # * `Malformed string`,
502 # * `Field f not found in class C`
503 # * `Null pointer dereference`
504 # The message can indicate an error or informational status, and refer to
505 # specific parts of the containing object.
506 # For example, the `Breakpoint.status` field can indicate an error referring
507 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
508 "isError": True or False, # Distinguishes errors from informational messages.
509 "refersTo": "A String", # Reference to which the message applies.
510 "description": { # Represents a message with parameters. # Status message text.
511 "parameters": [ # Optional parameters to be embedded into the message.
512 "A String",
513 ],
514 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
515 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
516 # character.
517 #
518 # Examples:
519 #
520 # * `Failed to load '$0' which helps debug $1 the first time it
521 # is loaded. Again, $0 is very important.`
522 # * `Please pay $$10 to use $0 instead of $1.`
523 },
524 },
525 "name": "A String", # Name of the variable, if any.
526 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
527 # one variable can reference the same variable in the table. The
528 # `var_table_index` field is an index into `variable_table` in Breakpoint.
529 "value": "A String", # Simple value of the variable.
530 "members": [ # Members contained or pointed to by the variable.
531 # Object with schema name: Variable
532 ],
533 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
534 # `var_table_index`, `type` goes next to `value`. The interpretation of
535 # a type is agent specific. It is recommended to include the dynamic type
536 # rather than a static type of an object.
537 },
538 ],
Thomas Coffee2f245372017-03-27 10:39:26 -0700539 "arguments": [ # Set of arguments passed to this function.
540 # Note that this might not be populated for all stack frames.
541 { # Represents a variable or an argument possibly of a compound object type.
542 # Note how the following variables are represented:
543 #
544 # 1) A simple variable:
545 #
546 # int x = 5
547 #
548 # { name: "x", value: "5", type: "int" } // Captured variable
549 #
550 # 2) A compound object:
551 #
552 # struct T {
553 # int m1;
554 # int m2;
555 # };
556 # T x = { 3, 7 };
557 #
558 # { // Captured variable
559 # name: "x",
560 # type: "T",
561 # members { name: "m1", value: "3", type: "int" },
562 # members { name: "m2", value: "7", type: "int" }
563 # }
564 #
565 # 3) A pointer where the pointee was captured:
566 #
567 # T x = { 3, 7 };
568 # T* p = &x;
569 #
570 # { // Captured variable
571 # name: "p",
572 # type: "T*",
573 # value: "0x00500500",
574 # members { name: "m1", value: "3", type: "int" },
575 # members { name: "m2", value: "7", type: "int" }
576 # }
577 #
578 # 4) A pointer where the pointee was not captured:
579 #
580 # T* p = new T;
581 #
582 # { // Captured variable
583 # name: "p",
584 # type: "T*",
585 # value: "0x00400400"
586 # status { is_error: true, description { format: "unavailable" } }
587 # }
588 #
589 # The status should describe the reason for the missing value,
590 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
591 #
592 # Note that a null pointer should not have members.
593 #
594 # 5) An unnamed value:
595 #
596 # int* p = new int(7);
597 #
598 # { // Captured variable
599 # name: "p",
600 # value: "0x00500500",
601 # type: "int*",
602 # members { value: "7", type: "int" } }
603 #
604 # 6) An unnamed pointer where the pointee was not captured:
605 #
606 # int* p = new int(7);
607 # int** pp = &p;
608 #
609 # { // Captured variable
610 # name: "pp",
611 # value: "0x00500500",
612 # type: "int**",
613 # members {
614 # value: "0x00400400",
615 # type: "int*"
616 # status {
617 # is_error: true,
618 # description: { format: "unavailable" } }
619 # }
620 # }
621 # }
622 #
623 # To optimize computation, memory and network traffic, variables that
624 # repeat in the output multiple times can be stored once in a shared
625 # variable table and be referenced using the `var_table_index` field. The
626 # variables stored in the shared table are nameless and are essentially
627 # a partition of the complete variable. To reconstruct the complete
628 # variable, merge the referencing variable with the referenced variable.
629 #
630 # When using the shared variable table, the following variables:
631 #
632 # T x = { 3, 7 };
633 # T* p = &x;
634 # T& r = x;
635 #
636 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
637 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
638 # { name: "r", type="T&", var_table_index: 3 }
639 #
640 # { // Shared variable table entry #3:
641 # members { name: "m1", value: "3", type: "int" },
642 # members { name: "m2", value: "7", type: "int" }
643 # }
644 #
645 # Note that the pointer address is stored with the referencing variable
646 # and not with the referenced variable. This allows the referenced variable
647 # to be shared between pointers and references.
648 #
649 # The type field is optional. The debugger agent may or may not support it.
650 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
651 # unset. A status of a single variable only applies to that variable or
652 # expression. The rest of breakpoint data still remains valid. Variables
653 # might be reported in error state even when breakpoint is not in final
654 # state.
655 #
656 # The message may refer to variable name with `refers_to` set to
657 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
658 # In either case variable value and members will be unset.
659 #
660 # Example of error message applied to name: `Invalid expression syntax`.
661 #
662 # Example of information message applied to value: `Not captured`.
663 #
664 # Examples of error message applied to value:
665 #
666 # * `Malformed string`,
667 # * `Field f not found in class C`
668 # * `Null pointer dereference`
669 # The message can indicate an error or informational status, and refer to
670 # specific parts of the containing object.
671 # For example, the `Breakpoint.status` field can indicate an error referring
672 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
673 "isError": True or False, # Distinguishes errors from informational messages.
674 "refersTo": "A String", # Reference to which the message applies.
675 "description": { # Represents a message with parameters. # Status message text.
676 "parameters": [ # Optional parameters to be embedded into the message.
677 "A String",
678 ],
679 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
680 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
681 # character.
682 #
683 # Examples:
684 #
685 # * `Failed to load '$0' which helps debug $1 the first time it
686 # is loaded. Again, $0 is very important.`
687 # * `Please pay $$10 to use $0 instead of $1.`
688 },
689 },
690 "name": "A String", # Name of the variable, if any.
691 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
692 # one variable can reference the same variable in the table. The
693 # `var_table_index` field is an index into `variable_table` in Breakpoint.
694 "value": "A String", # Simple value of the variable.
695 "members": [ # Members contained or pointed to by the variable.
696 # Object with schema name: Variable
697 ],
698 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
699 # `var_table_index`, `type` goes next to `value`. The interpretation of
700 # a type is agent specific. It is recommended to include the dynamic type
701 # rather than a static type of an object.
702 },
703 ],
Takashi Matsuo06694102015-09-11 13:55:40 -0700704 },
705 ],
Thomas Coffee2f245372017-03-27 10:39:26 -0700706 "location": { # Represents a location in the source code. # Breakpoint source location.
707 "path": "A String", # Path to the source file within the source context of the target binary.
708 "line": 42, # Line inside the file. The first line in the file has the value `1`.
709 },
710 "action": "A String", # Action that the agent should perform when the code at the
711 # breakpoint location is hit.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400712 "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
713 # The expressions are composed using expressions in the programming language
714 # at the source location. If the breakpoint action is `LOG`, the evaluated
715 # expressions are included in log statements.
Takashi Matsuo06694102015-09-11 13:55:40 -0700716 "A String",
717 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400718 "isFinalState": True or False, # When true, indicates that this is a final result and the
719 # breakpoint state will not change from here on.
720 "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
721 # The evaluated expressions appear in exactly the same order they
722 # are listed in the `expressions` field.
723 # The `name` field holds the original expression text, the `value` or
724 # `members` field holds the result of the evaluated expression.
725 # If the expression cannot be evaluated, the `status` inside the `Variable`
726 # will indicate an error and contain the error text.
727 { # Represents a variable or an argument possibly of a compound object type.
728 # Note how the following variables are represented:
729 #
730 # 1) A simple variable:
731 #
732 # int x = 5
733 #
734 # { name: "x", value: "5", type: "int" } // Captured variable
735 #
736 # 2) A compound object:
737 #
738 # struct T {
739 # int m1;
740 # int m2;
741 # };
742 # T x = { 3, 7 };
743 #
744 # { // Captured variable
745 # name: "x",
746 # type: "T",
747 # members { name: "m1", value: "3", type: "int" },
748 # members { name: "m2", value: "7", type: "int" }
749 # }
750 #
751 # 3) A pointer where the pointee was captured:
752 #
753 # T x = { 3, 7 };
754 # T* p = &x;
755 #
756 # { // Captured variable
757 # name: "p",
758 # type: "T*",
759 # value: "0x00500500",
760 # members { name: "m1", value: "3", type: "int" },
761 # members { name: "m2", value: "7", type: "int" }
762 # }
763 #
764 # 4) A pointer where the pointee was not captured:
765 #
766 # T* p = new T;
767 #
768 # { // Captured variable
769 # name: "p",
770 # type: "T*",
771 # value: "0x00400400"
772 # status { is_error: true, description { format: "unavailable" } }
773 # }
774 #
775 # The status should describe the reason for the missing value,
776 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
777 #
778 # Note that a null pointer should not have members.
779 #
780 # 5) An unnamed value:
781 #
782 # int* p = new int(7);
783 #
784 # { // Captured variable
785 # name: "p",
786 # value: "0x00500500",
787 # type: "int*",
788 # members { value: "7", type: "int" } }
789 #
790 # 6) An unnamed pointer where the pointee was not captured:
791 #
792 # int* p = new int(7);
793 # int** pp = &p;
794 #
795 # { // Captured variable
796 # name: "pp",
797 # value: "0x00500500",
798 # type: "int**",
799 # members {
800 # value: "0x00400400",
801 # type: "int*"
802 # status {
803 # is_error: true,
804 # description: { format: "unavailable" } }
805 # }
806 # }
807 # }
808 #
809 # To optimize computation, memory and network traffic, variables that
810 # repeat in the output multiple times can be stored once in a shared
811 # variable table and be referenced using the `var_table_index` field. The
812 # variables stored in the shared table are nameless and are essentially
813 # a partition of the complete variable. To reconstruct the complete
814 # variable, merge the referencing variable with the referenced variable.
815 #
816 # When using the shared variable table, the following variables:
817 #
818 # T x = { 3, 7 };
819 # T* p = &x;
820 # T& r = x;
821 #
822 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
823 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
824 # { name: "r", type="T&", var_table_index: 3 }
825 #
826 # { // Shared variable table entry #3:
827 # members { name: "m1", value: "3", type: "int" },
828 # members { name: "m2", value: "7", type: "int" }
829 # }
830 #
831 # Note that the pointer address is stored with the referencing variable
832 # and not with the referenced variable. This allows the referenced variable
833 # to be shared between pointers and references.
834 #
835 # The type field is optional. The debugger agent may or may not support it.
836 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
837 # unset. A status of a single variable only applies to that variable or
838 # expression. The rest of breakpoint data still remains valid. Variables
839 # might be reported in error state even when breakpoint is not in final
840 # state.
841 #
842 # The message may refer to variable name with `refers_to` set to
843 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
844 # In either case variable value and members will be unset.
845 #
846 # Example of error message applied to name: `Invalid expression syntax`.
847 #
848 # Example of information message applied to value: `Not captured`.
849 #
850 # Examples of error message applied to value:
851 #
852 # * `Malformed string`,
853 # * `Field f not found in class C`
854 # * `Null pointer dereference`
855 # The message can indicate an error or informational status, and refer to
856 # specific parts of the containing object.
857 # For example, the `Breakpoint.status` field can indicate an error referring
858 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700859 "isError": True or False, # Distinguishes errors from informational messages.
860 "refersTo": "A String", # Reference to which the message applies.
861 "description": { # Represents a message with parameters. # Status message text.
862 "parameters": [ # Optional parameters to be embedded into the message.
863 "A String",
864 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400865 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
866 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
867 # character.
868 #
869 # Examples:
870 #
871 # * `Failed to load '$0' which helps debug $1 the first time it
872 # is loaded. Again, $0 is very important.`
873 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -0700874 },
875 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800876 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400877 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
878 # one variable can reference the same variable in the table. The
879 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800880 "value": "A String", # Simple value of the variable.
881 "members": [ # Members contained or pointed to by the variable.
882 # Object with schema name: Variable
883 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400884 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
885 # `var_table_index`, `type` goes next to `value`. The interpretation of
886 # a type is agent specific. It is recommended to include the dynamic type
887 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -0700888 },
889 ],
890 "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400891 "condition": "A String", # Condition that triggers the breakpoint.
892 # The condition is a compound boolean expression composed using expressions
893 # in a programming language at the source location.
Takashi Matsuo06694102015-09-11 13:55:40 -0700894 },
895 }</pre>
896</div>
897
898<div class="method">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -0700899 <code class="details" id="list">list(debuggeeId, includeAllUsers=None, includeInactive=None, x__xgafv=None, clientVersion=None, stripResults=None, action_value=None, waitToken=None)</code>
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800900 <pre>Lists all breakpoints for the debuggee.
Takashi Matsuo06694102015-09-11 13:55:40 -0700901
902Args:
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800903 debuggeeId: string, ID of the debuggee whose breakpoints to list. (required)
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400904 includeAllUsers: boolean, When set to `true`, the response includes the list of breakpoints set by
905any user. Otherwise, it includes only breakpoints set by the caller.
906 includeInactive: boolean, When set to `true`, the response includes active and inactive
907breakpoints. Otherwise, it includes only active breakpoints.
Takashi Matsuo06694102015-09-11 13:55:40 -0700908 x__xgafv: string, V1 error format.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400909 Allowed values
910 1 - v1 error format
911 2 - v2 error format
912 clientVersion: string, The client version making the call.
913Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
914 stripResults: boolean, This field is deprecated. The following fields are always stripped out of
915the result: `stack_frames`, `evaluated_expressions` and `variable_table`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700916 action_value: string, Only breakpoints with the specified action will pass the filter.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400917 waitToken: string, A wait token that, if specified, blocks the call until the breakpoints
918list has changed, or a server selected timeout has expired. The value
919should be set from the last response. The error code
920`google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which
921should be called again with the same `wait_token`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700922
923Returns:
924 An object of the form:
925
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -0800926 { # Response for listing breakpoints.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400927 "nextWaitToken": "A String", # A wait token that can be used in the next call to `list` (REST) or
928 # `ListBreakpoints` (RPC) to block until the list of breakpoints has changes.
929 "breakpoints": [ # List of breakpoints matching the request.
930 # The fields `id` and `location` are guaranteed to be set on each breakpoint.
931 # The fields: `stack_frames`, `evaluated_expressions` and `variable_table`
932 # are cleared on each breakpoint regardless of it's status.
Takashi Matsuo06694102015-09-11 13:55:40 -0700933 { # Represents the breakpoint specification, status and results.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400934 "status": { # Represents a contextual status message. # Breakpoint status.
935 #
936 # The status includes an error flag and a human readable message.
937 # This field is usually unset. The message can be either
938 # informational or an error message. Regardless, clients should always
939 # display the text message back to the user.
940 #
941 # Error status indicates complete failure of the breakpoint.
942 #
943 # Example (non-final state): `Still loading symbols...`
944 #
945 # Examples (final state):
946 #
947 # * `Invalid line number` referring to location
948 # * `Field f not found in class C` referring to condition
949 # The message can indicate an error or informational status, and refer to
950 # specific parts of the containing object.
951 # For example, the `Breakpoint.status` field can indicate an error referring
952 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -0700953 "isError": True or False, # Distinguishes errors from informational messages.
954 "refersTo": "A String", # Reference to which the message applies.
955 "description": { # Represents a message with parameters. # Status message text.
956 "parameters": [ # Optional parameters to be embedded into the message.
957 "A String",
958 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400959 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
960 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
961 # character.
962 #
963 # Examples:
964 #
965 # * `Failed to load '$0' which helps debug $1 the first time it
966 # is loaded. Again, $0 is very important.`
967 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -0700968 },
969 },
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -0400970 "variableTable": [ # The `variable_table` exists to aid with computation, memory and network
971 # traffic optimization. It enables storing a variable once and reference
972 # it from multiple variables, including variables stored in the
973 # `variable_table` itself.
974 # For example, the same `this` object, which may appear at many levels of
975 # the stack, can have all of its data stored once in this table. The
976 # stack frame variables then would hold only a reference to it.
977 #
978 # The variable `var_table_index` field is an index into this repeated field.
979 # The stored objects are nameless and get their name from the referencing
980 # variable. The effective variable is a merge of the referencing variable
981 # and the referenced variable.
982 { # Represents a variable or an argument possibly of a compound object type.
983 # Note how the following variables are represented:
984 #
985 # 1) A simple variable:
986 #
987 # int x = 5
988 #
989 # { name: "x", value: "5", type: "int" } // Captured variable
990 #
991 # 2) A compound object:
992 #
993 # struct T {
994 # int m1;
995 # int m2;
996 # };
997 # T x = { 3, 7 };
998 #
999 # { // Captured variable
1000 # name: "x",
1001 # type: "T",
1002 # members { name: "m1", value: "3", type: "int" },
1003 # members { name: "m2", value: "7", type: "int" }
1004 # }
1005 #
1006 # 3) A pointer where the pointee was captured:
1007 #
1008 # T x = { 3, 7 };
1009 # T* p = &x;
1010 #
1011 # { // Captured variable
1012 # name: "p",
1013 # type: "T*",
1014 # value: "0x00500500",
1015 # members { name: "m1", value: "3", type: "int" },
1016 # members { name: "m2", value: "7", type: "int" }
1017 # }
1018 #
1019 # 4) A pointer where the pointee was not captured:
1020 #
1021 # T* p = new T;
1022 #
1023 # { // Captured variable
1024 # name: "p",
1025 # type: "T*",
1026 # value: "0x00400400"
1027 # status { is_error: true, description { format: "unavailable" } }
1028 # }
1029 #
1030 # The status should describe the reason for the missing value,
1031 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
1032 #
1033 # Note that a null pointer should not have members.
1034 #
1035 # 5) An unnamed value:
1036 #
1037 # int* p = new int(7);
1038 #
1039 # { // Captured variable
1040 # name: "p",
1041 # value: "0x00500500",
1042 # type: "int*",
1043 # members { value: "7", type: "int" } }
1044 #
1045 # 6) An unnamed pointer where the pointee was not captured:
1046 #
1047 # int* p = new int(7);
1048 # int** pp = &p;
1049 #
1050 # { // Captured variable
1051 # name: "pp",
1052 # value: "0x00500500",
1053 # type: "int**",
1054 # members {
1055 # value: "0x00400400",
1056 # type: "int*"
1057 # status {
1058 # is_error: true,
1059 # description: { format: "unavailable" } }
1060 # }
1061 # }
1062 # }
1063 #
1064 # To optimize computation, memory and network traffic, variables that
1065 # repeat in the output multiple times can be stored once in a shared
1066 # variable table and be referenced using the `var_table_index` field. The
1067 # variables stored in the shared table are nameless and are essentially
1068 # a partition of the complete variable. To reconstruct the complete
1069 # variable, merge the referencing variable with the referenced variable.
1070 #
1071 # When using the shared variable table, the following variables:
1072 #
1073 # T x = { 3, 7 };
1074 # T* p = &x;
1075 # T& r = x;
1076 #
1077 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
1078 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
1079 # { name: "r", type="T&", var_table_index: 3 }
1080 #
1081 # { // Shared variable table entry #3:
1082 # members { name: "m1", value: "3", type: "int" },
1083 # members { name: "m2", value: "7", type: "int" }
1084 # }
1085 #
1086 # Note that the pointer address is stored with the referencing variable
1087 # and not with the referenced variable. This allows the referenced variable
1088 # to be shared between pointers and references.
1089 #
1090 # The type field is optional. The debugger agent may or may not support it.
1091 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
1092 # unset. A status of a single variable only applies to that variable or
1093 # expression. The rest of breakpoint data still remains valid. Variables
1094 # might be reported in error state even when breakpoint is not in final
1095 # state.
1096 #
1097 # The message may refer to variable name with `refers_to` set to
1098 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
1099 # In either case variable value and members will be unset.
1100 #
1101 # Example of error message applied to name: `Invalid expression syntax`.
1102 #
1103 # Example of information message applied to value: `Not captured`.
1104 #
1105 # Examples of error message applied to value:
1106 #
1107 # * `Malformed string`,
1108 # * `Field f not found in class C`
1109 # * `Null pointer dereference`
1110 # The message can indicate an error or informational status, and refer to
1111 # specific parts of the containing object.
1112 # For example, the `Breakpoint.status` field can indicate an error referring
1113 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07001114 "isError": True or False, # Distinguishes errors from informational messages.
1115 "refersTo": "A String", # Reference to which the message applies.
1116 "description": { # Represents a message with parameters. # Status message text.
1117 "parameters": [ # Optional parameters to be embedded into the message.
1118 "A String",
1119 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001120 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
1121 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
1122 # character.
1123 #
1124 # Examples:
1125 #
1126 # * `Failed to load '$0' which helps debug $1 the first time it
1127 # is loaded. Again, $0 is very important.`
1128 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07001129 },
1130 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001131 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001132 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
1133 # one variable can reference the same variable in the table. The
1134 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001135 "value": "A String", # Simple value of the variable.
1136 "members": [ # Members contained or pointed to by the variable.
1137 # Object with schema name: Variable
1138 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001139 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
1140 # `var_table_index`, `type` goes next to `value`. The interpretation of
1141 # a type is agent specific. It is recommended to include the dynamic type
1142 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -07001143 },
1144 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07001145 "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
1146 # resolution.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001147 "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001148 "labels": { # A set of custom breakpoint properties, populated by the agent, to be
1149 # displayed to the user.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -07001150 "a_key": "A String",
1151 },
Thomas Coffee2f245372017-03-27 10:39:26 -07001152 "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when
1153 # the breakpoint hits. The message may include parameter placeholders `$0`,
1154 # `$1`, etc. These placeholders are replaced with the evaluated value
1155 # of the appropriate expression. Expressions not referenced in
1156 # `log_message_format` are not logged.
1157 #
1158 # Example: `Message received, id = $0, count = $1` with
1159 # `expressions` = `[ message.id, message.count ]`.
1160 "userEmail": "A String", # E-mail address of the user that created this breakpoint
1161 "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.
Takashi Matsuo06694102015-09-11 13:55:40 -07001162 "stackFrames": [ # The stack at breakpoint time.
1163 { # Represents a stack frame context.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001164 "function": "A String", # Demangled function name at the call site.
Thomas Coffee2f245372017-03-27 10:39:26 -07001165 "location": { # Represents a location in the source code. # Source location of the call site.
1166 "path": "A String", # Path to the source file within the source context of the target binary.
1167 "line": 42, # Line inside the file. The first line in the file has the value `1`.
1168 },
Sai Cheemalapatie833b792017-03-24 15:06:46 -07001169 "locals": [ # Set of local variables at the stack frame location.
1170 # Note that this might not be populated for all stack frames.
1171 { # Represents a variable or an argument possibly of a compound object type.
1172 # Note how the following variables are represented:
1173 #
1174 # 1) A simple variable:
1175 #
1176 # int x = 5
1177 #
1178 # { name: "x", value: "5", type: "int" } // Captured variable
1179 #
1180 # 2) A compound object:
1181 #
1182 # struct T {
1183 # int m1;
1184 # int m2;
1185 # };
1186 # T x = { 3, 7 };
1187 #
1188 # { // Captured variable
1189 # name: "x",
1190 # type: "T",
1191 # members { name: "m1", value: "3", type: "int" },
1192 # members { name: "m2", value: "7", type: "int" }
1193 # }
1194 #
1195 # 3) A pointer where the pointee was captured:
1196 #
1197 # T x = { 3, 7 };
1198 # T* p = &x;
1199 #
1200 # { // Captured variable
1201 # name: "p",
1202 # type: "T*",
1203 # value: "0x00500500",
1204 # members { name: "m1", value: "3", type: "int" },
1205 # members { name: "m2", value: "7", type: "int" }
1206 # }
1207 #
1208 # 4) A pointer where the pointee was not captured:
1209 #
1210 # T* p = new T;
1211 #
1212 # { // Captured variable
1213 # name: "p",
1214 # type: "T*",
1215 # value: "0x00400400"
1216 # status { is_error: true, description { format: "unavailable" } }
1217 # }
1218 #
1219 # The status should describe the reason for the missing value,
1220 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
1221 #
1222 # Note that a null pointer should not have members.
1223 #
1224 # 5) An unnamed value:
1225 #
1226 # int* p = new int(7);
1227 #
1228 # { // Captured variable
1229 # name: "p",
1230 # value: "0x00500500",
1231 # type: "int*",
1232 # members { value: "7", type: "int" } }
1233 #
1234 # 6) An unnamed pointer where the pointee was not captured:
1235 #
1236 # int* p = new int(7);
1237 # int** pp = &p;
1238 #
1239 # { // Captured variable
1240 # name: "pp",
1241 # value: "0x00500500",
1242 # type: "int**",
1243 # members {
1244 # value: "0x00400400",
1245 # type: "int*"
1246 # status {
1247 # is_error: true,
1248 # description: { format: "unavailable" } }
1249 # }
1250 # }
1251 # }
1252 #
1253 # To optimize computation, memory and network traffic, variables that
1254 # repeat in the output multiple times can be stored once in a shared
1255 # variable table and be referenced using the `var_table_index` field. The
1256 # variables stored in the shared table are nameless and are essentially
1257 # a partition of the complete variable. To reconstruct the complete
1258 # variable, merge the referencing variable with the referenced variable.
1259 #
1260 # When using the shared variable table, the following variables:
1261 #
1262 # T x = { 3, 7 };
1263 # T* p = &x;
1264 # T& r = x;
1265 #
1266 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
1267 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
1268 # { name: "r", type="T&", var_table_index: 3 }
1269 #
1270 # { // Shared variable table entry #3:
1271 # members { name: "m1", value: "3", type: "int" },
1272 # members { name: "m2", value: "7", type: "int" }
1273 # }
1274 #
1275 # Note that the pointer address is stored with the referencing variable
1276 # and not with the referenced variable. This allows the referenced variable
1277 # to be shared between pointers and references.
1278 #
1279 # The type field is optional. The debugger agent may or may not support it.
1280 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
1281 # unset. A status of a single variable only applies to that variable or
1282 # expression. The rest of breakpoint data still remains valid. Variables
1283 # might be reported in error state even when breakpoint is not in final
1284 # state.
1285 #
1286 # The message may refer to variable name with `refers_to` set to
1287 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
1288 # In either case variable value and members will be unset.
1289 #
1290 # Example of error message applied to name: `Invalid expression syntax`.
1291 #
1292 # Example of information message applied to value: `Not captured`.
1293 #
1294 # Examples of error message applied to value:
1295 #
1296 # * `Malformed string`,
1297 # * `Field f not found in class C`
1298 # * `Null pointer dereference`
1299 # The message can indicate an error or informational status, and refer to
1300 # specific parts of the containing object.
1301 # For example, the `Breakpoint.status` field can indicate an error referring
1302 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
1303 "isError": True or False, # Distinguishes errors from informational messages.
1304 "refersTo": "A String", # Reference to which the message applies.
1305 "description": { # Represents a message with parameters. # Status message text.
1306 "parameters": [ # Optional parameters to be embedded into the message.
1307 "A String",
1308 ],
1309 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
1310 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
1311 # character.
1312 #
1313 # Examples:
1314 #
1315 # * `Failed to load '$0' which helps debug $1 the first time it
1316 # is loaded. Again, $0 is very important.`
1317 # * `Please pay $$10 to use $0 instead of $1.`
1318 },
1319 },
1320 "name": "A String", # Name of the variable, if any.
1321 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
1322 # one variable can reference the same variable in the table. The
1323 # `var_table_index` field is an index into `variable_table` in Breakpoint.
1324 "value": "A String", # Simple value of the variable.
1325 "members": [ # Members contained or pointed to by the variable.
1326 # Object with schema name: Variable
1327 ],
1328 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
1329 # `var_table_index`, `type` goes next to `value`. The interpretation of
1330 # a type is agent specific. It is recommended to include the dynamic type
1331 # rather than a static type of an object.
1332 },
1333 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07001334 "arguments": [ # Set of arguments passed to this function.
1335 # Note that this might not be populated for all stack frames.
1336 { # Represents a variable or an argument possibly of a compound object type.
1337 # Note how the following variables are represented:
1338 #
1339 # 1) A simple variable:
1340 #
1341 # int x = 5
1342 #
1343 # { name: "x", value: "5", type: "int" } // Captured variable
1344 #
1345 # 2) A compound object:
1346 #
1347 # struct T {
1348 # int m1;
1349 # int m2;
1350 # };
1351 # T x = { 3, 7 };
1352 #
1353 # { // Captured variable
1354 # name: "x",
1355 # type: "T",
1356 # members { name: "m1", value: "3", type: "int" },
1357 # members { name: "m2", value: "7", type: "int" }
1358 # }
1359 #
1360 # 3) A pointer where the pointee was captured:
1361 #
1362 # T x = { 3, 7 };
1363 # T* p = &x;
1364 #
1365 # { // Captured variable
1366 # name: "p",
1367 # type: "T*",
1368 # value: "0x00500500",
1369 # members { name: "m1", value: "3", type: "int" },
1370 # members { name: "m2", value: "7", type: "int" }
1371 # }
1372 #
1373 # 4) A pointer where the pointee was not captured:
1374 #
1375 # T* p = new T;
1376 #
1377 # { // Captured variable
1378 # name: "p",
1379 # type: "T*",
1380 # value: "0x00400400"
1381 # status { is_error: true, description { format: "unavailable" } }
1382 # }
1383 #
1384 # The status should describe the reason for the missing value,
1385 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
1386 #
1387 # Note that a null pointer should not have members.
1388 #
1389 # 5) An unnamed value:
1390 #
1391 # int* p = new int(7);
1392 #
1393 # { // Captured variable
1394 # name: "p",
1395 # value: "0x00500500",
1396 # type: "int*",
1397 # members { value: "7", type: "int" } }
1398 #
1399 # 6) An unnamed pointer where the pointee was not captured:
1400 #
1401 # int* p = new int(7);
1402 # int** pp = &p;
1403 #
1404 # { // Captured variable
1405 # name: "pp",
1406 # value: "0x00500500",
1407 # type: "int**",
1408 # members {
1409 # value: "0x00400400",
1410 # type: "int*"
1411 # status {
1412 # is_error: true,
1413 # description: { format: "unavailable" } }
1414 # }
1415 # }
1416 # }
1417 #
1418 # To optimize computation, memory and network traffic, variables that
1419 # repeat in the output multiple times can be stored once in a shared
1420 # variable table and be referenced using the `var_table_index` field. The
1421 # variables stored in the shared table are nameless and are essentially
1422 # a partition of the complete variable. To reconstruct the complete
1423 # variable, merge the referencing variable with the referenced variable.
1424 #
1425 # When using the shared variable table, the following variables:
1426 #
1427 # T x = { 3, 7 };
1428 # T* p = &x;
1429 # T& r = x;
1430 #
1431 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
1432 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
1433 # { name: "r", type="T&", var_table_index: 3 }
1434 #
1435 # { // Shared variable table entry #3:
1436 # members { name: "m1", value: "3", type: "int" },
1437 # members { name: "m2", value: "7", type: "int" }
1438 # }
1439 #
1440 # Note that the pointer address is stored with the referencing variable
1441 # and not with the referenced variable. This allows the referenced variable
1442 # to be shared between pointers and references.
1443 #
1444 # The type field is optional. The debugger agent may or may not support it.
1445 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
1446 # unset. A status of a single variable only applies to that variable or
1447 # expression. The rest of breakpoint data still remains valid. Variables
1448 # might be reported in error state even when breakpoint is not in final
1449 # state.
1450 #
1451 # The message may refer to variable name with `refers_to` set to
1452 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
1453 # In either case variable value and members will be unset.
1454 #
1455 # Example of error message applied to name: `Invalid expression syntax`.
1456 #
1457 # Example of information message applied to value: `Not captured`.
1458 #
1459 # Examples of error message applied to value:
1460 #
1461 # * `Malformed string`,
1462 # * `Field f not found in class C`
1463 # * `Null pointer dereference`
1464 # The message can indicate an error or informational status, and refer to
1465 # specific parts of the containing object.
1466 # For example, the `Breakpoint.status` field can indicate an error referring
1467 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
1468 "isError": True or False, # Distinguishes errors from informational messages.
1469 "refersTo": "A String", # Reference to which the message applies.
1470 "description": { # Represents a message with parameters. # Status message text.
1471 "parameters": [ # Optional parameters to be embedded into the message.
1472 "A String",
1473 ],
1474 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
1475 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
1476 # character.
1477 #
1478 # Examples:
1479 #
1480 # * `Failed to load '$0' which helps debug $1 the first time it
1481 # is loaded. Again, $0 is very important.`
1482 # * `Please pay $$10 to use $0 instead of $1.`
1483 },
1484 },
1485 "name": "A String", # Name of the variable, if any.
1486 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
1487 # one variable can reference the same variable in the table. The
1488 # `var_table_index` field is an index into `variable_table` in Breakpoint.
1489 "value": "A String", # Simple value of the variable.
1490 "members": [ # Members contained or pointed to by the variable.
1491 # Object with schema name: Variable
1492 ],
1493 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
1494 # `var_table_index`, `type` goes next to `value`. The interpretation of
1495 # a type is agent specific. It is recommended to include the dynamic type
1496 # rather than a static type of an object.
1497 },
1498 ],
Takashi Matsuo06694102015-09-11 13:55:40 -07001499 },
1500 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07001501 "location": { # Represents a location in the source code. # Breakpoint source location.
1502 "path": "A String", # Path to the source file within the source context of the target binary.
1503 "line": 42, # Line inside the file. The first line in the file has the value `1`.
1504 },
1505 "action": "A String", # Action that the agent should perform when the code at the
1506 # breakpoint location is hit.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001507 "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
1508 # The expressions are composed using expressions in the programming language
1509 # at the source location. If the breakpoint action is `LOG`, the evaluated
1510 # expressions are included in log statements.
Takashi Matsuo06694102015-09-11 13:55:40 -07001511 "A String",
1512 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001513 "isFinalState": True or False, # When true, indicates that this is a final result and the
1514 # breakpoint state will not change from here on.
1515 "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
1516 # The evaluated expressions appear in exactly the same order they
1517 # are listed in the `expressions` field.
1518 # The `name` field holds the original expression text, the `value` or
1519 # `members` field holds the result of the evaluated expression.
1520 # If the expression cannot be evaluated, the `status` inside the `Variable`
1521 # will indicate an error and contain the error text.
1522 { # Represents a variable or an argument possibly of a compound object type.
1523 # Note how the following variables are represented:
1524 #
1525 # 1) A simple variable:
1526 #
1527 # int x = 5
1528 #
1529 # { name: "x", value: "5", type: "int" } // Captured variable
1530 #
1531 # 2) A compound object:
1532 #
1533 # struct T {
1534 # int m1;
1535 # int m2;
1536 # };
1537 # T x = { 3, 7 };
1538 #
1539 # { // Captured variable
1540 # name: "x",
1541 # type: "T",
1542 # members { name: "m1", value: "3", type: "int" },
1543 # members { name: "m2", value: "7", type: "int" }
1544 # }
1545 #
1546 # 3) A pointer where the pointee was captured:
1547 #
1548 # T x = { 3, 7 };
1549 # T* p = &x;
1550 #
1551 # { // Captured variable
1552 # name: "p",
1553 # type: "T*",
1554 # value: "0x00500500",
1555 # members { name: "m1", value: "3", type: "int" },
1556 # members { name: "m2", value: "7", type: "int" }
1557 # }
1558 #
1559 # 4) A pointer where the pointee was not captured:
1560 #
1561 # T* p = new T;
1562 #
1563 # { // Captured variable
1564 # name: "p",
1565 # type: "T*",
1566 # value: "0x00400400"
1567 # status { is_error: true, description { format: "unavailable" } }
1568 # }
1569 #
1570 # The status should describe the reason for the missing value,
1571 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
1572 #
1573 # Note that a null pointer should not have members.
1574 #
1575 # 5) An unnamed value:
1576 #
1577 # int* p = new int(7);
1578 #
1579 # { // Captured variable
1580 # name: "p",
1581 # value: "0x00500500",
1582 # type: "int*",
1583 # members { value: "7", type: "int" } }
1584 #
1585 # 6) An unnamed pointer where the pointee was not captured:
1586 #
1587 # int* p = new int(7);
1588 # int** pp = &p;
1589 #
1590 # { // Captured variable
1591 # name: "pp",
1592 # value: "0x00500500",
1593 # type: "int**",
1594 # members {
1595 # value: "0x00400400",
1596 # type: "int*"
1597 # status {
1598 # is_error: true,
1599 # description: { format: "unavailable" } }
1600 # }
1601 # }
1602 # }
1603 #
1604 # To optimize computation, memory and network traffic, variables that
1605 # repeat in the output multiple times can be stored once in a shared
1606 # variable table and be referenced using the `var_table_index` field. The
1607 # variables stored in the shared table are nameless and are essentially
1608 # a partition of the complete variable. To reconstruct the complete
1609 # variable, merge the referencing variable with the referenced variable.
1610 #
1611 # When using the shared variable table, the following variables:
1612 #
1613 # T x = { 3, 7 };
1614 # T* p = &x;
1615 # T& r = x;
1616 #
1617 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
1618 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
1619 # { name: "r", type="T&", var_table_index: 3 }
1620 #
1621 # { // Shared variable table entry #3:
1622 # members { name: "m1", value: "3", type: "int" },
1623 # members { name: "m2", value: "7", type: "int" }
1624 # }
1625 #
1626 # Note that the pointer address is stored with the referencing variable
1627 # and not with the referenced variable. This allows the referenced variable
1628 # to be shared between pointers and references.
1629 #
1630 # The type field is optional. The debugger agent may or may not support it.
1631 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
1632 # unset. A status of a single variable only applies to that variable or
1633 # expression. The rest of breakpoint data still remains valid. Variables
1634 # might be reported in error state even when breakpoint is not in final
1635 # state.
1636 #
1637 # The message may refer to variable name with `refers_to` set to
1638 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
1639 # In either case variable value and members will be unset.
1640 #
1641 # Example of error message applied to name: `Invalid expression syntax`.
1642 #
1643 # Example of information message applied to value: `Not captured`.
1644 #
1645 # Examples of error message applied to value:
1646 #
1647 # * `Malformed string`,
1648 # * `Field f not found in class C`
1649 # * `Null pointer dereference`
1650 # The message can indicate an error or informational status, and refer to
1651 # specific parts of the containing object.
1652 # For example, the `Breakpoint.status` field can indicate an error referring
1653 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07001654 "isError": True or False, # Distinguishes errors from informational messages.
1655 "refersTo": "A String", # Reference to which the message applies.
1656 "description": { # Represents a message with parameters. # Status message text.
1657 "parameters": [ # Optional parameters to be embedded into the message.
1658 "A String",
1659 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001660 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
1661 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
1662 # character.
1663 #
1664 # Examples:
1665 #
1666 # * `Failed to load '$0' which helps debug $1 the first time it
1667 # is loaded. Again, $0 is very important.`
1668 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07001669 },
1670 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001671 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001672 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
1673 # one variable can reference the same variable in the table. The
1674 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001675 "value": "A String", # Simple value of the variable.
1676 "members": [ # Members contained or pointed to by the variable.
1677 # Object with schema name: Variable
1678 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001679 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
1680 # `var_table_index`, `type` goes next to `value`. The interpretation of
1681 # a type is agent specific. It is recommended to include the dynamic type
1682 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -07001683 },
1684 ],
1685 "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001686 "condition": "A String", # Condition that triggers the breakpoint.
1687 # The condition is a compound boolean expression composed using expressions
1688 # in a programming language at the source location.
Takashi Matsuo06694102015-09-11 13:55:40 -07001689 },
1690 ],
1691 }</pre>
1692</div>
1693
1694<div class="method">
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -07001695 <code class="details" id="set">set(debuggeeId, body, clientVersion=None, x__xgafv=None)</code>
Takashi Matsuo06694102015-09-11 13:55:40 -07001696 <pre>Sets the breakpoint to the debuggee.
1697
1698Args:
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001699 debuggeeId: string, ID of the debuggee where the breakpoint is to be set. (required)
Takashi Matsuo06694102015-09-11 13:55:40 -07001700 body: object, The request body. (required)
1701 The object takes the form of:
1702
1703{ # Represents the breakpoint specification, status and results.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001704 "status": { # Represents a contextual status message. # Breakpoint status.
1705 #
1706 # The status includes an error flag and a human readable message.
1707 # This field is usually unset. The message can be either
1708 # informational or an error message. Regardless, clients should always
1709 # display the text message back to the user.
1710 #
1711 # Error status indicates complete failure of the breakpoint.
1712 #
1713 # Example (non-final state): `Still loading symbols...`
1714 #
1715 # Examples (final state):
1716 #
1717 # * `Invalid line number` referring to location
1718 # * `Field f not found in class C` referring to condition
1719 # The message can indicate an error or informational status, and refer to
1720 # specific parts of the containing object.
1721 # For example, the `Breakpoint.status` field can indicate an error referring
1722 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07001723 "isError": True or False, # Distinguishes errors from informational messages.
1724 "refersTo": "A String", # Reference to which the message applies.
1725 "description": { # Represents a message with parameters. # Status message text.
1726 "parameters": [ # Optional parameters to be embedded into the message.
1727 "A String",
1728 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001729 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
1730 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
1731 # character.
1732 #
1733 # Examples:
1734 #
1735 # * `Failed to load '$0' which helps debug $1 the first time it
1736 # is loaded. Again, $0 is very important.`
1737 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07001738 },
1739 },
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001740 "variableTable": [ # The `variable_table` exists to aid with computation, memory and network
1741 # traffic optimization. It enables storing a variable once and reference
1742 # it from multiple variables, including variables stored in the
1743 # `variable_table` itself.
1744 # For example, the same `this` object, which may appear at many levels of
1745 # the stack, can have all of its data stored once in this table. The
1746 # stack frame variables then would hold only a reference to it.
1747 #
1748 # The variable `var_table_index` field is an index into this repeated field.
1749 # The stored objects are nameless and get their name from the referencing
1750 # variable. The effective variable is a merge of the referencing variable
1751 # and the referenced variable.
1752 { # Represents a variable or an argument possibly of a compound object type.
1753 # Note how the following variables are represented:
1754 #
1755 # 1) A simple variable:
1756 #
1757 # int x = 5
1758 #
1759 # { name: "x", value: "5", type: "int" } // Captured variable
1760 #
1761 # 2) A compound object:
1762 #
1763 # struct T {
1764 # int m1;
1765 # int m2;
1766 # };
1767 # T x = { 3, 7 };
1768 #
1769 # { // Captured variable
1770 # name: "x",
1771 # type: "T",
1772 # members { name: "m1", value: "3", type: "int" },
1773 # members { name: "m2", value: "7", type: "int" }
1774 # }
1775 #
1776 # 3) A pointer where the pointee was captured:
1777 #
1778 # T x = { 3, 7 };
1779 # T* p = &x;
1780 #
1781 # { // Captured variable
1782 # name: "p",
1783 # type: "T*",
1784 # value: "0x00500500",
1785 # members { name: "m1", value: "3", type: "int" },
1786 # members { name: "m2", value: "7", type: "int" }
1787 # }
1788 #
1789 # 4) A pointer where the pointee was not captured:
1790 #
1791 # T* p = new T;
1792 #
1793 # { // Captured variable
1794 # name: "p",
1795 # type: "T*",
1796 # value: "0x00400400"
1797 # status { is_error: true, description { format: "unavailable" } }
1798 # }
1799 #
1800 # The status should describe the reason for the missing value,
1801 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
1802 #
1803 # Note that a null pointer should not have members.
1804 #
1805 # 5) An unnamed value:
1806 #
1807 # int* p = new int(7);
1808 #
1809 # { // Captured variable
1810 # name: "p",
1811 # value: "0x00500500",
1812 # type: "int*",
1813 # members { value: "7", type: "int" } }
1814 #
1815 # 6) An unnamed pointer where the pointee was not captured:
1816 #
1817 # int* p = new int(7);
1818 # int** pp = &p;
1819 #
1820 # { // Captured variable
1821 # name: "pp",
1822 # value: "0x00500500",
1823 # type: "int**",
1824 # members {
1825 # value: "0x00400400",
1826 # type: "int*"
1827 # status {
1828 # is_error: true,
1829 # description: { format: "unavailable" } }
1830 # }
1831 # }
1832 # }
1833 #
1834 # To optimize computation, memory and network traffic, variables that
1835 # repeat in the output multiple times can be stored once in a shared
1836 # variable table and be referenced using the `var_table_index` field. The
1837 # variables stored in the shared table are nameless and are essentially
1838 # a partition of the complete variable. To reconstruct the complete
1839 # variable, merge the referencing variable with the referenced variable.
1840 #
1841 # When using the shared variable table, the following variables:
1842 #
1843 # T x = { 3, 7 };
1844 # T* p = &x;
1845 # T& r = x;
1846 #
1847 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
1848 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
1849 # { name: "r", type="T&", var_table_index: 3 }
1850 #
1851 # { // Shared variable table entry #3:
1852 # members { name: "m1", value: "3", type: "int" },
1853 # members { name: "m2", value: "7", type: "int" }
1854 # }
1855 #
1856 # Note that the pointer address is stored with the referencing variable
1857 # and not with the referenced variable. This allows the referenced variable
1858 # to be shared between pointers and references.
1859 #
1860 # The type field is optional. The debugger agent may or may not support it.
1861 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
1862 # unset. A status of a single variable only applies to that variable or
1863 # expression. The rest of breakpoint data still remains valid. Variables
1864 # might be reported in error state even when breakpoint is not in final
1865 # state.
1866 #
1867 # The message may refer to variable name with `refers_to` set to
1868 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
1869 # In either case variable value and members will be unset.
1870 #
1871 # Example of error message applied to name: `Invalid expression syntax`.
1872 #
1873 # Example of information message applied to value: `Not captured`.
1874 #
1875 # Examples of error message applied to value:
1876 #
1877 # * `Malformed string`,
1878 # * `Field f not found in class C`
1879 # * `Null pointer dereference`
1880 # The message can indicate an error or informational status, and refer to
1881 # specific parts of the containing object.
1882 # For example, the `Breakpoint.status` field can indicate an error referring
1883 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07001884 "isError": True or False, # Distinguishes errors from informational messages.
1885 "refersTo": "A String", # Reference to which the message applies.
1886 "description": { # Represents a message with parameters. # Status message text.
1887 "parameters": [ # Optional parameters to be embedded into the message.
1888 "A String",
1889 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001890 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
1891 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
1892 # character.
1893 #
1894 # Examples:
1895 #
1896 # * `Failed to load '$0' which helps debug $1 the first time it
1897 # is loaded. Again, $0 is very important.`
1898 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07001899 },
1900 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001901 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001902 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
1903 # one variable can reference the same variable in the table. The
1904 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001905 "value": "A String", # Simple value of the variable.
1906 "members": [ # Members contained or pointed to by the variable.
1907 # Object with schema name: Variable
1908 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001909 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
1910 # `var_table_index`, `type` goes next to `value`. The interpretation of
1911 # a type is agent specific. It is recommended to include the dynamic type
1912 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -07001913 },
1914 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07001915 "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
1916 # resolution.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001917 "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04001918 "labels": { # A set of custom breakpoint properties, populated by the agent, to be
1919 # displayed to the user.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -07001920 "a_key": "A String",
1921 },
Thomas Coffee2f245372017-03-27 10:39:26 -07001922 "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when
1923 # the breakpoint hits. The message may include parameter placeholders `$0`,
1924 # `$1`, etc. These placeholders are replaced with the evaluated value
1925 # of the appropriate expression. Expressions not referenced in
1926 # `log_message_format` are not logged.
1927 #
1928 # Example: `Message received, id = $0, count = $1` with
1929 # `expressions` = `[ message.id, message.count ]`.
1930 "userEmail": "A String", # E-mail address of the user that created this breakpoint
1931 "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.
Takashi Matsuo06694102015-09-11 13:55:40 -07001932 "stackFrames": [ # The stack at breakpoint time.
1933 { # Represents a stack frame context.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08001934 "function": "A String", # Demangled function name at the call site.
Thomas Coffee2f245372017-03-27 10:39:26 -07001935 "location": { # Represents a location in the source code. # Source location of the call site.
1936 "path": "A String", # Path to the source file within the source context of the target binary.
1937 "line": 42, # Line inside the file. The first line in the file has the value `1`.
1938 },
Sai Cheemalapatie833b792017-03-24 15:06:46 -07001939 "locals": [ # Set of local variables at the stack frame location.
1940 # Note that this might not be populated for all stack frames.
1941 { # Represents a variable or an argument possibly of a compound object type.
1942 # Note how the following variables are represented:
1943 #
1944 # 1) A simple variable:
1945 #
1946 # int x = 5
1947 #
1948 # { name: "x", value: "5", type: "int" } // Captured variable
1949 #
1950 # 2) A compound object:
1951 #
1952 # struct T {
1953 # int m1;
1954 # int m2;
1955 # };
1956 # T x = { 3, 7 };
1957 #
1958 # { // Captured variable
1959 # name: "x",
1960 # type: "T",
1961 # members { name: "m1", value: "3", type: "int" },
1962 # members { name: "m2", value: "7", type: "int" }
1963 # }
1964 #
1965 # 3) A pointer where the pointee was captured:
1966 #
1967 # T x = { 3, 7 };
1968 # T* p = &x;
1969 #
1970 # { // Captured variable
1971 # name: "p",
1972 # type: "T*",
1973 # value: "0x00500500",
1974 # members { name: "m1", value: "3", type: "int" },
1975 # members { name: "m2", value: "7", type: "int" }
1976 # }
1977 #
1978 # 4) A pointer where the pointee was not captured:
1979 #
1980 # T* p = new T;
1981 #
1982 # { // Captured variable
1983 # name: "p",
1984 # type: "T*",
1985 # value: "0x00400400"
1986 # status { is_error: true, description { format: "unavailable" } }
1987 # }
1988 #
1989 # The status should describe the reason for the missing value,
1990 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
1991 #
1992 # Note that a null pointer should not have members.
1993 #
1994 # 5) An unnamed value:
1995 #
1996 # int* p = new int(7);
1997 #
1998 # { // Captured variable
1999 # name: "p",
2000 # value: "0x00500500",
2001 # type: "int*",
2002 # members { value: "7", type: "int" } }
2003 #
2004 # 6) An unnamed pointer where the pointee was not captured:
2005 #
2006 # int* p = new int(7);
2007 # int** pp = &p;
2008 #
2009 # { // Captured variable
2010 # name: "pp",
2011 # value: "0x00500500",
2012 # type: "int**",
2013 # members {
2014 # value: "0x00400400",
2015 # type: "int*"
2016 # status {
2017 # is_error: true,
2018 # description: { format: "unavailable" } }
2019 # }
2020 # }
2021 # }
2022 #
2023 # To optimize computation, memory and network traffic, variables that
2024 # repeat in the output multiple times can be stored once in a shared
2025 # variable table and be referenced using the `var_table_index` field. The
2026 # variables stored in the shared table are nameless and are essentially
2027 # a partition of the complete variable. To reconstruct the complete
2028 # variable, merge the referencing variable with the referenced variable.
2029 #
2030 # When using the shared variable table, the following variables:
2031 #
2032 # T x = { 3, 7 };
2033 # T* p = &x;
2034 # T& r = x;
2035 #
2036 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
2037 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
2038 # { name: "r", type="T&", var_table_index: 3 }
2039 #
2040 # { // Shared variable table entry #3:
2041 # members { name: "m1", value: "3", type: "int" },
2042 # members { name: "m2", value: "7", type: "int" }
2043 # }
2044 #
2045 # Note that the pointer address is stored with the referencing variable
2046 # and not with the referenced variable. This allows the referenced variable
2047 # to be shared between pointers and references.
2048 #
2049 # The type field is optional. The debugger agent may or may not support it.
2050 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
2051 # unset. A status of a single variable only applies to that variable or
2052 # expression. The rest of breakpoint data still remains valid. Variables
2053 # might be reported in error state even when breakpoint is not in final
2054 # state.
2055 #
2056 # The message may refer to variable name with `refers_to` set to
2057 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
2058 # In either case variable value and members will be unset.
2059 #
2060 # Example of error message applied to name: `Invalid expression syntax`.
2061 #
2062 # Example of information message applied to value: `Not captured`.
2063 #
2064 # Examples of error message applied to value:
2065 #
2066 # * `Malformed string`,
2067 # * `Field f not found in class C`
2068 # * `Null pointer dereference`
2069 # The message can indicate an error or informational status, and refer to
2070 # specific parts of the containing object.
2071 # For example, the `Breakpoint.status` field can indicate an error referring
2072 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
2073 "isError": True or False, # Distinguishes errors from informational messages.
2074 "refersTo": "A String", # Reference to which the message applies.
2075 "description": { # Represents a message with parameters. # Status message text.
2076 "parameters": [ # Optional parameters to be embedded into the message.
2077 "A String",
2078 ],
2079 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
2080 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
2081 # character.
2082 #
2083 # Examples:
2084 #
2085 # * `Failed to load '$0' which helps debug $1 the first time it
2086 # is loaded. Again, $0 is very important.`
2087 # * `Please pay $$10 to use $0 instead of $1.`
2088 },
2089 },
2090 "name": "A String", # Name of the variable, if any.
2091 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
2092 # one variable can reference the same variable in the table. The
2093 # `var_table_index` field is an index into `variable_table` in Breakpoint.
2094 "value": "A String", # Simple value of the variable.
2095 "members": [ # Members contained or pointed to by the variable.
2096 # Object with schema name: Variable
2097 ],
2098 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
2099 # `var_table_index`, `type` goes next to `value`. The interpretation of
2100 # a type is agent specific. It is recommended to include the dynamic type
2101 # rather than a static type of an object.
2102 },
2103 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07002104 "arguments": [ # Set of arguments passed to this function.
2105 # Note that this might not be populated for all stack frames.
2106 { # Represents a variable or an argument possibly of a compound object type.
2107 # Note how the following variables are represented:
2108 #
2109 # 1) A simple variable:
2110 #
2111 # int x = 5
2112 #
2113 # { name: "x", value: "5", type: "int" } // Captured variable
2114 #
2115 # 2) A compound object:
2116 #
2117 # struct T {
2118 # int m1;
2119 # int m2;
2120 # };
2121 # T x = { 3, 7 };
2122 #
2123 # { // Captured variable
2124 # name: "x",
2125 # type: "T",
2126 # members { name: "m1", value: "3", type: "int" },
2127 # members { name: "m2", value: "7", type: "int" }
2128 # }
2129 #
2130 # 3) A pointer where the pointee was captured:
2131 #
2132 # T x = { 3, 7 };
2133 # T* p = &x;
2134 #
2135 # { // Captured variable
2136 # name: "p",
2137 # type: "T*",
2138 # value: "0x00500500",
2139 # members { name: "m1", value: "3", type: "int" },
2140 # members { name: "m2", value: "7", type: "int" }
2141 # }
2142 #
2143 # 4) A pointer where the pointee was not captured:
2144 #
2145 # T* p = new T;
2146 #
2147 # { // Captured variable
2148 # name: "p",
2149 # type: "T*",
2150 # value: "0x00400400"
2151 # status { is_error: true, description { format: "unavailable" } }
2152 # }
2153 #
2154 # The status should describe the reason for the missing value,
2155 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
2156 #
2157 # Note that a null pointer should not have members.
2158 #
2159 # 5) An unnamed value:
2160 #
2161 # int* p = new int(7);
2162 #
2163 # { // Captured variable
2164 # name: "p",
2165 # value: "0x00500500",
2166 # type: "int*",
2167 # members { value: "7", type: "int" } }
2168 #
2169 # 6) An unnamed pointer where the pointee was not captured:
2170 #
2171 # int* p = new int(7);
2172 # int** pp = &p;
2173 #
2174 # { // Captured variable
2175 # name: "pp",
2176 # value: "0x00500500",
2177 # type: "int**",
2178 # members {
2179 # value: "0x00400400",
2180 # type: "int*"
2181 # status {
2182 # is_error: true,
2183 # description: { format: "unavailable" } }
2184 # }
2185 # }
2186 # }
2187 #
2188 # To optimize computation, memory and network traffic, variables that
2189 # repeat in the output multiple times can be stored once in a shared
2190 # variable table and be referenced using the `var_table_index` field. The
2191 # variables stored in the shared table are nameless and are essentially
2192 # a partition of the complete variable. To reconstruct the complete
2193 # variable, merge the referencing variable with the referenced variable.
2194 #
2195 # When using the shared variable table, the following variables:
2196 #
2197 # T x = { 3, 7 };
2198 # T* p = &x;
2199 # T& r = x;
2200 #
2201 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
2202 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
2203 # { name: "r", type="T&", var_table_index: 3 }
2204 #
2205 # { // Shared variable table entry #3:
2206 # members { name: "m1", value: "3", type: "int" },
2207 # members { name: "m2", value: "7", type: "int" }
2208 # }
2209 #
2210 # Note that the pointer address is stored with the referencing variable
2211 # and not with the referenced variable. This allows the referenced variable
2212 # to be shared between pointers and references.
2213 #
2214 # The type field is optional. The debugger agent may or may not support it.
2215 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
2216 # unset. A status of a single variable only applies to that variable or
2217 # expression. The rest of breakpoint data still remains valid. Variables
2218 # might be reported in error state even when breakpoint is not in final
2219 # state.
2220 #
2221 # The message may refer to variable name with `refers_to` set to
2222 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
2223 # In either case variable value and members will be unset.
2224 #
2225 # Example of error message applied to name: `Invalid expression syntax`.
2226 #
2227 # Example of information message applied to value: `Not captured`.
2228 #
2229 # Examples of error message applied to value:
2230 #
2231 # * `Malformed string`,
2232 # * `Field f not found in class C`
2233 # * `Null pointer dereference`
2234 # The message can indicate an error or informational status, and refer to
2235 # specific parts of the containing object.
2236 # For example, the `Breakpoint.status` field can indicate an error referring
2237 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
2238 "isError": True or False, # Distinguishes errors from informational messages.
2239 "refersTo": "A String", # Reference to which the message applies.
2240 "description": { # Represents a message with parameters. # Status message text.
2241 "parameters": [ # Optional parameters to be embedded into the message.
2242 "A String",
2243 ],
2244 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
2245 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
2246 # character.
2247 #
2248 # Examples:
2249 #
2250 # * `Failed to load '$0' which helps debug $1 the first time it
2251 # is loaded. Again, $0 is very important.`
2252 # * `Please pay $$10 to use $0 instead of $1.`
2253 },
2254 },
2255 "name": "A String", # Name of the variable, if any.
2256 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
2257 # one variable can reference the same variable in the table. The
2258 # `var_table_index` field is an index into `variable_table` in Breakpoint.
2259 "value": "A String", # Simple value of the variable.
2260 "members": [ # Members contained or pointed to by the variable.
2261 # Object with schema name: Variable
2262 ],
2263 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
2264 # `var_table_index`, `type` goes next to `value`. The interpretation of
2265 # a type is agent specific. It is recommended to include the dynamic type
2266 # rather than a static type of an object.
2267 },
2268 ],
Takashi Matsuo06694102015-09-11 13:55:40 -07002269 },
2270 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07002271 "location": { # Represents a location in the source code. # Breakpoint source location.
2272 "path": "A String", # Path to the source file within the source context of the target binary.
2273 "line": 42, # Line inside the file. The first line in the file has the value `1`.
2274 },
2275 "action": "A String", # Action that the agent should perform when the code at the
2276 # breakpoint location is hit.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002277 "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
2278 # The expressions are composed using expressions in the programming language
2279 # at the source location. If the breakpoint action is `LOG`, the evaluated
2280 # expressions are included in log statements.
Takashi Matsuo06694102015-09-11 13:55:40 -07002281 "A String",
2282 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002283 "isFinalState": True or False, # When true, indicates that this is a final result and the
2284 # breakpoint state will not change from here on.
2285 "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
2286 # The evaluated expressions appear in exactly the same order they
2287 # are listed in the `expressions` field.
2288 # The `name` field holds the original expression text, the `value` or
2289 # `members` field holds the result of the evaluated expression.
2290 # If the expression cannot be evaluated, the `status` inside the `Variable`
2291 # will indicate an error and contain the error text.
2292 { # Represents a variable or an argument possibly of a compound object type.
2293 # Note how the following variables are represented:
2294 #
2295 # 1) A simple variable:
2296 #
2297 # int x = 5
2298 #
2299 # { name: "x", value: "5", type: "int" } // Captured variable
2300 #
2301 # 2) A compound object:
2302 #
2303 # struct T {
2304 # int m1;
2305 # int m2;
2306 # };
2307 # T x = { 3, 7 };
2308 #
2309 # { // Captured variable
2310 # name: "x",
2311 # type: "T",
2312 # members { name: "m1", value: "3", type: "int" },
2313 # members { name: "m2", value: "7", type: "int" }
2314 # }
2315 #
2316 # 3) A pointer where the pointee was captured:
2317 #
2318 # T x = { 3, 7 };
2319 # T* p = &x;
2320 #
2321 # { // Captured variable
2322 # name: "p",
2323 # type: "T*",
2324 # value: "0x00500500",
2325 # members { name: "m1", value: "3", type: "int" },
2326 # members { name: "m2", value: "7", type: "int" }
2327 # }
2328 #
2329 # 4) A pointer where the pointee was not captured:
2330 #
2331 # T* p = new T;
2332 #
2333 # { // Captured variable
2334 # name: "p",
2335 # type: "T*",
2336 # value: "0x00400400"
2337 # status { is_error: true, description { format: "unavailable" } }
2338 # }
2339 #
2340 # The status should describe the reason for the missing value,
2341 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
2342 #
2343 # Note that a null pointer should not have members.
2344 #
2345 # 5) An unnamed value:
2346 #
2347 # int* p = new int(7);
2348 #
2349 # { // Captured variable
2350 # name: "p",
2351 # value: "0x00500500",
2352 # type: "int*",
2353 # members { value: "7", type: "int" } }
2354 #
2355 # 6) An unnamed pointer where the pointee was not captured:
2356 #
2357 # int* p = new int(7);
2358 # int** pp = &p;
2359 #
2360 # { // Captured variable
2361 # name: "pp",
2362 # value: "0x00500500",
2363 # type: "int**",
2364 # members {
2365 # value: "0x00400400",
2366 # type: "int*"
2367 # status {
2368 # is_error: true,
2369 # description: { format: "unavailable" } }
2370 # }
2371 # }
2372 # }
2373 #
2374 # To optimize computation, memory and network traffic, variables that
2375 # repeat in the output multiple times can be stored once in a shared
2376 # variable table and be referenced using the `var_table_index` field. The
2377 # variables stored in the shared table are nameless and are essentially
2378 # a partition of the complete variable. To reconstruct the complete
2379 # variable, merge the referencing variable with the referenced variable.
2380 #
2381 # When using the shared variable table, the following variables:
2382 #
2383 # T x = { 3, 7 };
2384 # T* p = &x;
2385 # T& r = x;
2386 #
2387 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
2388 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
2389 # { name: "r", type="T&", var_table_index: 3 }
2390 #
2391 # { // Shared variable table entry #3:
2392 # members { name: "m1", value: "3", type: "int" },
2393 # members { name: "m2", value: "7", type: "int" }
2394 # }
2395 #
2396 # Note that the pointer address is stored with the referencing variable
2397 # and not with the referenced variable. This allows the referenced variable
2398 # to be shared between pointers and references.
2399 #
2400 # The type field is optional. The debugger agent may or may not support it.
2401 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
2402 # unset. A status of a single variable only applies to that variable or
2403 # expression. The rest of breakpoint data still remains valid. Variables
2404 # might be reported in error state even when breakpoint is not in final
2405 # state.
2406 #
2407 # The message may refer to variable name with `refers_to` set to
2408 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
2409 # In either case variable value and members will be unset.
2410 #
2411 # Example of error message applied to name: `Invalid expression syntax`.
2412 #
2413 # Example of information message applied to value: `Not captured`.
2414 #
2415 # Examples of error message applied to value:
2416 #
2417 # * `Malformed string`,
2418 # * `Field f not found in class C`
2419 # * `Null pointer dereference`
2420 # The message can indicate an error or informational status, and refer to
2421 # specific parts of the containing object.
2422 # For example, the `Breakpoint.status` field can indicate an error referring
2423 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07002424 "isError": True or False, # Distinguishes errors from informational messages.
2425 "refersTo": "A String", # Reference to which the message applies.
2426 "description": { # Represents a message with parameters. # Status message text.
2427 "parameters": [ # Optional parameters to be embedded into the message.
2428 "A String",
2429 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002430 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
2431 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
2432 # character.
2433 #
2434 # Examples:
2435 #
2436 # * `Failed to load '$0' which helps debug $1 the first time it
2437 # is loaded. Again, $0 is very important.`
2438 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07002439 },
2440 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002441 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002442 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
2443 # one variable can reference the same variable in the table. The
2444 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002445 "value": "A String", # Simple value of the variable.
2446 "members": [ # Members contained or pointed to by the variable.
2447 # Object with schema name: Variable
2448 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002449 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
2450 # `var_table_index`, `type` goes next to `value`. The interpretation of
2451 # a type is agent specific. It is recommended to include the dynamic type
2452 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -07002453 },
2454 ],
2455 "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002456 "condition": "A String", # Condition that triggers the breakpoint.
2457 # The condition is a compound boolean expression composed using expressions
2458 # in a programming language at the source location.
Takashi Matsuo06694102015-09-11 13:55:40 -07002459}
2460
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002461 clientVersion: string, The client version making the call.
2462Following: `domain/type/version` (e.g., `google.com/intellij/v1`).
Takashi Matsuo06694102015-09-11 13:55:40 -07002463 x__xgafv: string, V1 error format.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002464 Allowed values
2465 1 - v1 error format
2466 2 - v2 error format
Takashi Matsuo06694102015-09-11 13:55:40 -07002467
2468Returns:
2469 An object of the form:
2470
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002471 { # Response for setting a breakpoint.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002472 "breakpoint": { # Represents the breakpoint specification, status and results. # Breakpoint resource.
2473 # The field `id` is guaranteed to be set (in addition to the echoed fileds).
2474 "status": { # Represents a contextual status message. # Breakpoint status.
2475 #
2476 # The status includes an error flag and a human readable message.
2477 # This field is usually unset. The message can be either
2478 # informational or an error message. Regardless, clients should always
2479 # display the text message back to the user.
2480 #
2481 # Error status indicates complete failure of the breakpoint.
2482 #
2483 # Example (non-final state): `Still loading symbols...`
2484 #
2485 # Examples (final state):
2486 #
2487 # * `Invalid line number` referring to location
2488 # * `Field f not found in class C` referring to condition
2489 # The message can indicate an error or informational status, and refer to
2490 # specific parts of the containing object.
2491 # For example, the `Breakpoint.status` field can indicate an error referring
2492 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07002493 "isError": True or False, # Distinguishes errors from informational messages.
2494 "refersTo": "A String", # Reference to which the message applies.
2495 "description": { # Represents a message with parameters. # Status message text.
2496 "parameters": [ # Optional parameters to be embedded into the message.
2497 "A String",
2498 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002499 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
2500 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
2501 # character.
2502 #
2503 # Examples:
2504 #
2505 # * `Failed to load '$0' which helps debug $1 the first time it
2506 # is loaded. Again, $0 is very important.`
2507 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07002508 },
2509 },
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002510 "variableTable": [ # The `variable_table` exists to aid with computation, memory and network
2511 # traffic optimization. It enables storing a variable once and reference
2512 # it from multiple variables, including variables stored in the
2513 # `variable_table` itself.
2514 # For example, the same `this` object, which may appear at many levels of
2515 # the stack, can have all of its data stored once in this table. The
2516 # stack frame variables then would hold only a reference to it.
2517 #
2518 # The variable `var_table_index` field is an index into this repeated field.
2519 # The stored objects are nameless and get their name from the referencing
2520 # variable. The effective variable is a merge of the referencing variable
2521 # and the referenced variable.
2522 { # Represents a variable or an argument possibly of a compound object type.
2523 # Note how the following variables are represented:
2524 #
2525 # 1) A simple variable:
2526 #
2527 # int x = 5
2528 #
2529 # { name: "x", value: "5", type: "int" } // Captured variable
2530 #
2531 # 2) A compound object:
2532 #
2533 # struct T {
2534 # int m1;
2535 # int m2;
2536 # };
2537 # T x = { 3, 7 };
2538 #
2539 # { // Captured variable
2540 # name: "x",
2541 # type: "T",
2542 # members { name: "m1", value: "3", type: "int" },
2543 # members { name: "m2", value: "7", type: "int" }
2544 # }
2545 #
2546 # 3) A pointer where the pointee was captured:
2547 #
2548 # T x = { 3, 7 };
2549 # T* p = &x;
2550 #
2551 # { // Captured variable
2552 # name: "p",
2553 # type: "T*",
2554 # value: "0x00500500",
2555 # members { name: "m1", value: "3", type: "int" },
2556 # members { name: "m2", value: "7", type: "int" }
2557 # }
2558 #
2559 # 4) A pointer where the pointee was not captured:
2560 #
2561 # T* p = new T;
2562 #
2563 # { // Captured variable
2564 # name: "p",
2565 # type: "T*",
2566 # value: "0x00400400"
2567 # status { is_error: true, description { format: "unavailable" } }
2568 # }
2569 #
2570 # The status should describe the reason for the missing value,
2571 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
2572 #
2573 # Note that a null pointer should not have members.
2574 #
2575 # 5) An unnamed value:
2576 #
2577 # int* p = new int(7);
2578 #
2579 # { // Captured variable
2580 # name: "p",
2581 # value: "0x00500500",
2582 # type: "int*",
2583 # members { value: "7", type: "int" } }
2584 #
2585 # 6) An unnamed pointer where the pointee was not captured:
2586 #
2587 # int* p = new int(7);
2588 # int** pp = &p;
2589 #
2590 # { // Captured variable
2591 # name: "pp",
2592 # value: "0x00500500",
2593 # type: "int**",
2594 # members {
2595 # value: "0x00400400",
2596 # type: "int*"
2597 # status {
2598 # is_error: true,
2599 # description: { format: "unavailable" } }
2600 # }
2601 # }
2602 # }
2603 #
2604 # To optimize computation, memory and network traffic, variables that
2605 # repeat in the output multiple times can be stored once in a shared
2606 # variable table and be referenced using the `var_table_index` field. The
2607 # variables stored in the shared table are nameless and are essentially
2608 # a partition of the complete variable. To reconstruct the complete
2609 # variable, merge the referencing variable with the referenced variable.
2610 #
2611 # When using the shared variable table, the following variables:
2612 #
2613 # T x = { 3, 7 };
2614 # T* p = &x;
2615 # T& r = x;
2616 #
2617 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
2618 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
2619 # { name: "r", type="T&", var_table_index: 3 }
2620 #
2621 # { // Shared variable table entry #3:
2622 # members { name: "m1", value: "3", type: "int" },
2623 # members { name: "m2", value: "7", type: "int" }
2624 # }
2625 #
2626 # Note that the pointer address is stored with the referencing variable
2627 # and not with the referenced variable. This allows the referenced variable
2628 # to be shared between pointers and references.
2629 #
2630 # The type field is optional. The debugger agent may or may not support it.
2631 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
2632 # unset. A status of a single variable only applies to that variable or
2633 # expression. The rest of breakpoint data still remains valid. Variables
2634 # might be reported in error state even when breakpoint is not in final
2635 # state.
2636 #
2637 # The message may refer to variable name with `refers_to` set to
2638 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
2639 # In either case variable value and members will be unset.
2640 #
2641 # Example of error message applied to name: `Invalid expression syntax`.
2642 #
2643 # Example of information message applied to value: `Not captured`.
2644 #
2645 # Examples of error message applied to value:
2646 #
2647 # * `Malformed string`,
2648 # * `Field f not found in class C`
2649 # * `Null pointer dereference`
2650 # The message can indicate an error or informational status, and refer to
2651 # specific parts of the containing object.
2652 # For example, the `Breakpoint.status` field can indicate an error referring
2653 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07002654 "isError": True or False, # Distinguishes errors from informational messages.
2655 "refersTo": "A String", # Reference to which the message applies.
2656 "description": { # Represents a message with parameters. # Status message text.
2657 "parameters": [ # Optional parameters to be embedded into the message.
2658 "A String",
2659 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002660 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
2661 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
2662 # character.
2663 #
2664 # Examples:
2665 #
2666 # * `Failed to load '$0' which helps debug $1 the first time it
2667 # is loaded. Again, $0 is very important.`
2668 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07002669 },
2670 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002671 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002672 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
2673 # one variable can reference the same variable in the table. The
2674 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002675 "value": "A String", # Simple value of the variable.
2676 "members": [ # Members contained or pointed to by the variable.
2677 # Object with schema name: Variable
2678 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002679 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
2680 # `var_table_index`, `type` goes next to `value`. The interpretation of
2681 # a type is agent specific. It is recommended to include the dynamic type
2682 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -07002683 },
2684 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07002685 "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds
2686 # resolution.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002687 "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04002688 "labels": { # A set of custom breakpoint properties, populated by the agent, to be
2689 # displayed to the user.
Jon Wayne Parrott0a471d32016-05-19 10:54:38 -07002690 "a_key": "A String",
2691 },
Thomas Coffee2f245372017-03-27 10:39:26 -07002692 "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when
2693 # the breakpoint hits. The message may include parameter placeholders `$0`,
2694 # `$1`, etc. These placeholders are replaced with the evaluated value
2695 # of the appropriate expression. Expressions not referenced in
2696 # `log_message_format` are not logged.
2697 #
2698 # Example: `Message received, id = $0, count = $1` with
2699 # `expressions` = `[ message.id, message.count ]`.
2700 "userEmail": "A String", # E-mail address of the user that created this breakpoint
2701 "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.
Takashi Matsuo06694102015-09-11 13:55:40 -07002702 "stackFrames": [ # The stack at breakpoint time.
2703 { # Represents a stack frame context.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08002704 "function": "A String", # Demangled function name at the call site.
Thomas Coffee2f245372017-03-27 10:39:26 -07002705 "location": { # Represents a location in the source code. # Source location of the call site.
2706 "path": "A String", # Path to the source file within the source context of the target binary.
2707 "line": 42, # Line inside the file. The first line in the file has the value `1`.
2708 },
Sai Cheemalapatie833b792017-03-24 15:06:46 -07002709 "locals": [ # Set of local variables at the stack frame location.
2710 # Note that this might not be populated for all stack frames.
2711 { # Represents a variable or an argument possibly of a compound object type.
2712 # Note how the following variables are represented:
2713 #
2714 # 1) A simple variable:
2715 #
2716 # int x = 5
2717 #
2718 # { name: "x", value: "5", type: "int" } // Captured variable
2719 #
2720 # 2) A compound object:
2721 #
2722 # struct T {
2723 # int m1;
2724 # int m2;
2725 # };
2726 # T x = { 3, 7 };
2727 #
2728 # { // Captured variable
2729 # name: "x",
2730 # type: "T",
2731 # members { name: "m1", value: "3", type: "int" },
2732 # members { name: "m2", value: "7", type: "int" }
2733 # }
2734 #
2735 # 3) A pointer where the pointee was captured:
2736 #
2737 # T x = { 3, 7 };
2738 # T* p = &x;
2739 #
2740 # { // Captured variable
2741 # name: "p",
2742 # type: "T*",
2743 # value: "0x00500500",
2744 # members { name: "m1", value: "3", type: "int" },
2745 # members { name: "m2", value: "7", type: "int" }
2746 # }
2747 #
2748 # 4) A pointer where the pointee was not captured:
2749 #
2750 # T* p = new T;
2751 #
2752 # { // Captured variable
2753 # name: "p",
2754 # type: "T*",
2755 # value: "0x00400400"
2756 # status { is_error: true, description { format: "unavailable" } }
2757 # }
2758 #
2759 # The status should describe the reason for the missing value,
2760 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
2761 #
2762 # Note that a null pointer should not have members.
2763 #
2764 # 5) An unnamed value:
2765 #
2766 # int* p = new int(7);
2767 #
2768 # { // Captured variable
2769 # name: "p",
2770 # value: "0x00500500",
2771 # type: "int*",
2772 # members { value: "7", type: "int" } }
2773 #
2774 # 6) An unnamed pointer where the pointee was not captured:
2775 #
2776 # int* p = new int(7);
2777 # int** pp = &p;
2778 #
2779 # { // Captured variable
2780 # name: "pp",
2781 # value: "0x00500500",
2782 # type: "int**",
2783 # members {
2784 # value: "0x00400400",
2785 # type: "int*"
2786 # status {
2787 # is_error: true,
2788 # description: { format: "unavailable" } }
2789 # }
2790 # }
2791 # }
2792 #
2793 # To optimize computation, memory and network traffic, variables that
2794 # repeat in the output multiple times can be stored once in a shared
2795 # variable table and be referenced using the `var_table_index` field. The
2796 # variables stored in the shared table are nameless and are essentially
2797 # a partition of the complete variable. To reconstruct the complete
2798 # variable, merge the referencing variable with the referenced variable.
2799 #
2800 # When using the shared variable table, the following variables:
2801 #
2802 # T x = { 3, 7 };
2803 # T* p = &x;
2804 # T& r = x;
2805 #
2806 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
2807 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
2808 # { name: "r", type="T&", var_table_index: 3 }
2809 #
2810 # { // Shared variable table entry #3:
2811 # members { name: "m1", value: "3", type: "int" },
2812 # members { name: "m2", value: "7", type: "int" }
2813 # }
2814 #
2815 # Note that the pointer address is stored with the referencing variable
2816 # and not with the referenced variable. This allows the referenced variable
2817 # to be shared between pointers and references.
2818 #
2819 # The type field is optional. The debugger agent may or may not support it.
2820 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
2821 # unset. A status of a single variable only applies to that variable or
2822 # expression. The rest of breakpoint data still remains valid. Variables
2823 # might be reported in error state even when breakpoint is not in final
2824 # state.
2825 #
2826 # The message may refer to variable name with `refers_to` set to
2827 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
2828 # In either case variable value and members will be unset.
2829 #
2830 # Example of error message applied to name: `Invalid expression syntax`.
2831 #
2832 # Example of information message applied to value: `Not captured`.
2833 #
2834 # Examples of error message applied to value:
2835 #
2836 # * `Malformed string`,
2837 # * `Field f not found in class C`
2838 # * `Null pointer dereference`
2839 # The message can indicate an error or informational status, and refer to
2840 # specific parts of the containing object.
2841 # For example, the `Breakpoint.status` field can indicate an error referring
2842 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
2843 "isError": True or False, # Distinguishes errors from informational messages.
2844 "refersTo": "A String", # Reference to which the message applies.
2845 "description": { # Represents a message with parameters. # Status message text.
2846 "parameters": [ # Optional parameters to be embedded into the message.
2847 "A String",
2848 ],
2849 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
2850 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
2851 # character.
2852 #
2853 # Examples:
2854 #
2855 # * `Failed to load '$0' which helps debug $1 the first time it
2856 # is loaded. Again, $0 is very important.`
2857 # * `Please pay $$10 to use $0 instead of $1.`
2858 },
2859 },
2860 "name": "A String", # Name of the variable, if any.
2861 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
2862 # one variable can reference the same variable in the table. The
2863 # `var_table_index` field is an index into `variable_table` in Breakpoint.
2864 "value": "A String", # Simple value of the variable.
2865 "members": [ # Members contained or pointed to by the variable.
2866 # Object with schema name: Variable
2867 ],
2868 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
2869 # `var_table_index`, `type` goes next to `value`. The interpretation of
2870 # a type is agent specific. It is recommended to include the dynamic type
2871 # rather than a static type of an object.
2872 },
2873 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07002874 "arguments": [ # Set of arguments passed to this function.
2875 # Note that this might not be populated for all stack frames.
2876 { # Represents a variable or an argument possibly of a compound object type.
2877 # Note how the following variables are represented:
2878 #
2879 # 1) A simple variable:
2880 #
2881 # int x = 5
2882 #
2883 # { name: "x", value: "5", type: "int" } // Captured variable
2884 #
2885 # 2) A compound object:
2886 #
2887 # struct T {
2888 # int m1;
2889 # int m2;
2890 # };
2891 # T x = { 3, 7 };
2892 #
2893 # { // Captured variable
2894 # name: "x",
2895 # type: "T",
2896 # members { name: "m1", value: "3", type: "int" },
2897 # members { name: "m2", value: "7", type: "int" }
2898 # }
2899 #
2900 # 3) A pointer where the pointee was captured:
2901 #
2902 # T x = { 3, 7 };
2903 # T* p = &x;
2904 #
2905 # { // Captured variable
2906 # name: "p",
2907 # type: "T*",
2908 # value: "0x00500500",
2909 # members { name: "m1", value: "3", type: "int" },
2910 # members { name: "m2", value: "7", type: "int" }
2911 # }
2912 #
2913 # 4) A pointer where the pointee was not captured:
2914 #
2915 # T* p = new T;
2916 #
2917 # { // Captured variable
2918 # name: "p",
2919 # type: "T*",
2920 # value: "0x00400400"
2921 # status { is_error: true, description { format: "unavailable" } }
2922 # }
2923 #
2924 # The status should describe the reason for the missing value,
2925 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
2926 #
2927 # Note that a null pointer should not have members.
2928 #
2929 # 5) An unnamed value:
2930 #
2931 # int* p = new int(7);
2932 #
2933 # { // Captured variable
2934 # name: "p",
2935 # value: "0x00500500",
2936 # type: "int*",
2937 # members { value: "7", type: "int" } }
2938 #
2939 # 6) An unnamed pointer where the pointee was not captured:
2940 #
2941 # int* p = new int(7);
2942 # int** pp = &p;
2943 #
2944 # { // Captured variable
2945 # name: "pp",
2946 # value: "0x00500500",
2947 # type: "int**",
2948 # members {
2949 # value: "0x00400400",
2950 # type: "int*"
2951 # status {
2952 # is_error: true,
2953 # description: { format: "unavailable" } }
2954 # }
2955 # }
2956 # }
2957 #
2958 # To optimize computation, memory and network traffic, variables that
2959 # repeat in the output multiple times can be stored once in a shared
2960 # variable table and be referenced using the `var_table_index` field. The
2961 # variables stored in the shared table are nameless and are essentially
2962 # a partition of the complete variable. To reconstruct the complete
2963 # variable, merge the referencing variable with the referenced variable.
2964 #
2965 # When using the shared variable table, the following variables:
2966 #
2967 # T x = { 3, 7 };
2968 # T* p = &x;
2969 # T& r = x;
2970 #
2971 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
2972 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
2973 # { name: "r", type="T&", var_table_index: 3 }
2974 #
2975 # { // Shared variable table entry #3:
2976 # members { name: "m1", value: "3", type: "int" },
2977 # members { name: "m2", value: "7", type: "int" }
2978 # }
2979 #
2980 # Note that the pointer address is stored with the referencing variable
2981 # and not with the referenced variable. This allows the referenced variable
2982 # to be shared between pointers and references.
2983 #
2984 # The type field is optional. The debugger agent may or may not support it.
2985 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
2986 # unset. A status of a single variable only applies to that variable or
2987 # expression. The rest of breakpoint data still remains valid. Variables
2988 # might be reported in error state even when breakpoint is not in final
2989 # state.
2990 #
2991 # The message may refer to variable name with `refers_to` set to
2992 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
2993 # In either case variable value and members will be unset.
2994 #
2995 # Example of error message applied to name: `Invalid expression syntax`.
2996 #
2997 # Example of information message applied to value: `Not captured`.
2998 #
2999 # Examples of error message applied to value:
3000 #
3001 # * `Malformed string`,
3002 # * `Field f not found in class C`
3003 # * `Null pointer dereference`
3004 # The message can indicate an error or informational status, and refer to
3005 # specific parts of the containing object.
3006 # For example, the `Breakpoint.status` field can indicate an error referring
3007 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
3008 "isError": True or False, # Distinguishes errors from informational messages.
3009 "refersTo": "A String", # Reference to which the message applies.
3010 "description": { # Represents a message with parameters. # Status message text.
3011 "parameters": [ # Optional parameters to be embedded into the message.
3012 "A String",
3013 ],
3014 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
3015 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
3016 # character.
3017 #
3018 # Examples:
3019 #
3020 # * `Failed to load '$0' which helps debug $1 the first time it
3021 # is loaded. Again, $0 is very important.`
3022 # * `Please pay $$10 to use $0 instead of $1.`
3023 },
3024 },
3025 "name": "A String", # Name of the variable, if any.
3026 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
3027 # one variable can reference the same variable in the table. The
3028 # `var_table_index` field is an index into `variable_table` in Breakpoint.
3029 "value": "A String", # Simple value of the variable.
3030 "members": [ # Members contained or pointed to by the variable.
3031 # Object with schema name: Variable
3032 ],
3033 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
3034 # `var_table_index`, `type` goes next to `value`. The interpretation of
3035 # a type is agent specific. It is recommended to include the dynamic type
3036 # rather than a static type of an object.
3037 },
3038 ],
Takashi Matsuo06694102015-09-11 13:55:40 -07003039 },
3040 ],
Thomas Coffee2f245372017-03-27 10:39:26 -07003041 "location": { # Represents a location in the source code. # Breakpoint source location.
3042 "path": "A String", # Path to the source file within the source context of the target binary.
3043 "line": 42, # Line inside the file. The first line in the file has the value `1`.
3044 },
3045 "action": "A String", # Action that the agent should perform when the code at the
3046 # breakpoint location is hit.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04003047 "expressions": [ # List of read-only expressions to evaluate at the breakpoint location.
3048 # The expressions are composed using expressions in the programming language
3049 # at the source location. If the breakpoint action is `LOG`, the evaluated
3050 # expressions are included in log statements.
Takashi Matsuo06694102015-09-11 13:55:40 -07003051 "A String",
3052 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04003053 "isFinalState": True or False, # When true, indicates that this is a final result and the
3054 # breakpoint state will not change from here on.
3055 "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.
3056 # The evaluated expressions appear in exactly the same order they
3057 # are listed in the `expressions` field.
3058 # The `name` field holds the original expression text, the `value` or
3059 # `members` field holds the result of the evaluated expression.
3060 # If the expression cannot be evaluated, the `status` inside the `Variable`
3061 # will indicate an error and contain the error text.
3062 { # Represents a variable or an argument possibly of a compound object type.
3063 # Note how the following variables are represented:
3064 #
3065 # 1) A simple variable:
3066 #
3067 # int x = 5
3068 #
3069 # { name: "x", value: "5", type: "int" } // Captured variable
3070 #
3071 # 2) A compound object:
3072 #
3073 # struct T {
3074 # int m1;
3075 # int m2;
3076 # };
3077 # T x = { 3, 7 };
3078 #
3079 # { // Captured variable
3080 # name: "x",
3081 # type: "T",
3082 # members { name: "m1", value: "3", type: "int" },
3083 # members { name: "m2", value: "7", type: "int" }
3084 # }
3085 #
3086 # 3) A pointer where the pointee was captured:
3087 #
3088 # T x = { 3, 7 };
3089 # T* p = &x;
3090 #
3091 # { // Captured variable
3092 # name: "p",
3093 # type: "T*",
3094 # value: "0x00500500",
3095 # members { name: "m1", value: "3", type: "int" },
3096 # members { name: "m2", value: "7", type: "int" }
3097 # }
3098 #
3099 # 4) A pointer where the pointee was not captured:
3100 #
3101 # T* p = new T;
3102 #
3103 # { // Captured variable
3104 # name: "p",
3105 # type: "T*",
3106 # value: "0x00400400"
3107 # status { is_error: true, description { format: "unavailable" } }
3108 # }
3109 #
3110 # The status should describe the reason for the missing value,
3111 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.
3112 #
3113 # Note that a null pointer should not have members.
3114 #
3115 # 5) An unnamed value:
3116 #
3117 # int* p = new int(7);
3118 #
3119 # { // Captured variable
3120 # name: "p",
3121 # value: "0x00500500",
3122 # type: "int*",
3123 # members { value: "7", type: "int" } }
3124 #
3125 # 6) An unnamed pointer where the pointee was not captured:
3126 #
3127 # int* p = new int(7);
3128 # int** pp = &p;
3129 #
3130 # { // Captured variable
3131 # name: "pp",
3132 # value: "0x00500500",
3133 # type: "int**",
3134 # members {
3135 # value: "0x00400400",
3136 # type: "int*"
3137 # status {
3138 # is_error: true,
3139 # description: { format: "unavailable" } }
3140 # }
3141 # }
3142 # }
3143 #
3144 # To optimize computation, memory and network traffic, variables that
3145 # repeat in the output multiple times can be stored once in a shared
3146 # variable table and be referenced using the `var_table_index` field. The
3147 # variables stored in the shared table are nameless and are essentially
3148 # a partition of the complete variable. To reconstruct the complete
3149 # variable, merge the referencing variable with the referenced variable.
3150 #
3151 # When using the shared variable table, the following variables:
3152 #
3153 # T x = { 3, 7 };
3154 # T* p = &x;
3155 # T& r = x;
3156 #
3157 # { name: "x", var_table_index: 3, type: "T" } // Captured variables
3158 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 }
3159 # { name: "r", type="T&", var_table_index: 3 }
3160 #
3161 # { // Shared variable table entry #3:
3162 # members { name: "m1", value: "3", type: "int" },
3163 # members { name: "m2", value: "7", type: "int" }
3164 # }
3165 #
3166 # Note that the pointer address is stored with the referencing variable
3167 # and not with the referenced variable. This allows the referenced variable
3168 # to be shared between pointers and references.
3169 #
3170 # The type field is optional. The debugger agent may or may not support it.
3171 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay
3172 # unset. A status of a single variable only applies to that variable or
3173 # expression. The rest of breakpoint data still remains valid. Variables
3174 # might be reported in error state even when breakpoint is not in final
3175 # state.
3176 #
3177 # The message may refer to variable name with `refers_to` set to
3178 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.
3179 # In either case variable value and members will be unset.
3180 #
3181 # Example of error message applied to name: `Invalid expression syntax`.
3182 #
3183 # Example of information message applied to value: `Not captured`.
3184 #
3185 # Examples of error message applied to value:
3186 #
3187 # * `Malformed string`,
3188 # * `Field f not found in class C`
3189 # * `Null pointer dereference`
3190 # The message can indicate an error or informational status, and refer to
3191 # specific parts of the containing object.
3192 # For example, the `Breakpoint.status` field can indicate an error referring
3193 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.
Takashi Matsuo06694102015-09-11 13:55:40 -07003194 "isError": True or False, # Distinguishes errors from informational messages.
3195 "refersTo": "A String", # Reference to which the message applies.
3196 "description": { # Represents a message with parameters. # Status message text.
3197 "parameters": [ # Optional parameters to be embedded into the message.
3198 "A String",
3199 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04003200 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`,
3201 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$`
3202 # character.
3203 #
3204 # Examples:
3205 #
3206 # * `Failed to load '$0' which helps debug $1 the first time it
3207 # is loaded. Again, $0 is very important.`
3208 # * `Please pay $$10 to use $0 instead of $1.`
Takashi Matsuo06694102015-09-11 13:55:40 -07003209 },
3210 },
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08003211 "name": "A String", # Name of the variable, if any.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04003212 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than
3213 # one variable can reference the same variable in the table. The
3214 # `var_table_index` field is an index into `variable_table` in Breakpoint.
Jon Wayne Parrott36e41bc2016-02-19 16:02:29 -08003215 "value": "A String", # Simple value of the variable.
3216 "members": [ # Members contained or pointed to by the variable.
3217 # Object with schema name: Variable
3218 ],
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04003219 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with
3220 # `var_table_index`, `type` goes next to `value`. The interpretation of
3221 # a type is agent specific. It is recommended to include the dynamic type
3222 # rather than a static type of an object.
Takashi Matsuo06694102015-09-11 13:55:40 -07003223 },
3224 ],
3225 "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.
Sai Cheemalapatic30d2b52017-03-13 12:12:03 -04003226 "condition": "A String", # Condition that triggers the breakpoint.
3227 # The condition is a compound boolean expression composed using expressions
3228 # in a programming language at the source location.
Takashi Matsuo06694102015-09-11 13:55:40 -07003229 },
3230 }</pre>
3231</div>
3232
3233</body></html>