1<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 75<h1><a href="clouddebugger_v2.html">Stackdriver Debugger API</a> . <a href="clouddebugger_v2.controller.html">controller</a> . <a href="clouddebugger_v2.controller.debuggees.html">debuggees</a> . <a href="clouddebugger_v2.controller.debuggees.breakpoints.html">breakpoints</a></h1> 76<h2>Instance Methods</h2> 77<p class="toc_element"> 78 <code><a href="#list">list(debuggeeId, waitToken=None, successOnTimeout=None, x__xgafv=None)</a></code></p> 79<p class="firstline">Returns the list of all active breakpoints for the debuggee.</p> 80<p class="toc_element"> 81 <code><a href="#update">update(debuggeeId, id, body, x__xgafv=None)</a></code></p> 82<p class="firstline">Updates the breakpoint state or mutable fields.</p> 83<h3>Method Details</h3> 84<div class="method"> 85 <code class="details" id="list">list(debuggeeId, waitToken=None, successOnTimeout=None, x__xgafv=None)</code> 86 <pre>Returns the list of all active breakpoints for the debuggee. 87 88The breakpoint specification (`location`, `condition`, and `expressions` 89fields) is semantically immutable, although the field values may 90change. For example, an agent may update the location line number 91to reflect the actual line where the breakpoint was set, but this 92doesn't change the breakpoint semantics. 93 94This means that an agent does not need to check if a breakpoint has changed 95when it encounters the same breakpoint on a successive call. 96Moreover, an agent should remember the breakpoints that are completed 97until the controller removes them from the active list to avoid 98setting those breakpoints again. 99 100Args: 101 debuggeeId: string, Identifies the debuggee. (required) 102 waitToken: string, A token that, if specified, blocks the method call until the list 103of active breakpoints has changed, or a server-selected timeout has 104expired. The value should be set from the `next_wait_token` field in 105the last response. The initial value should be set to `"init"`. 106 successOnTimeout: boolean, If set to `true` (recommended), returns `google.rpc.Code.OK` status and 107sets the `wait_expired` response field to `true` when the server-selected 108timeout has expired. 109 110If set to `false` (deprecated), returns `google.rpc.Code.ABORTED` status 111when the server-selected timeout has expired. 112 x__xgafv: string, V1 error format. 113 Allowed values 114 1 - v1 error format 115 2 - v2 error format 116 117Returns: 118 An object of the form: 119 120 { # Response for listing active breakpoints. 121 "waitExpired": True or False, # If set to `true`, indicates that there is no change to the 122 # list of active breakpoints and the server-selected timeout has expired. 123 # The `breakpoints` field would be empty and should be ignored. 124 "nextWaitToken": "A String", # A token that can be used in the next method call to block until 125 # the list of breakpoints changes. 126 "breakpoints": [ # List of all active breakpoints. 127 # The fields `id` and `location` are guaranteed to be set on each breakpoint. 128 { # Represents the breakpoint specification, status and results. 129 "status": { # Represents a contextual status message. # Breakpoint status. 130 # 131 # The status includes an error flag and a human readable message. 132 # This field is usually unset. The message can be either 133 # informational or an error message. Regardless, clients should always 134 # display the text message back to the user. 135 # 136 # Error status indicates complete failure of the breakpoint. 137 # 138 # Example (non-final state): `Still loading symbols...` 139 # 140 # Examples (final state): 141 # 142 # * `Invalid line number` referring to location 143 # * `Field f not found in class C` referring to condition 144 # The message can indicate an error or informational status, and refer to 145 # specific parts of the containing object. 146 # For example, the `Breakpoint.status` field can indicate an error referring 147 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 148 "isError": True or False, # Distinguishes errors from informational messages. 149 "refersTo": "A String", # Reference to which the message applies. 150 "description": { # Represents a message with parameters. # Status message text. 151 "parameters": [ # Optional parameters to be embedded into the message. 152 "A String", 153 ], 154 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 155 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 156 # character. 157 # 158 # Examples: 159 # 160 # * `Failed to load '$0' which helps debug $1 the first time it 161 # is loaded. Again, $0 is very important.` 162 # * `Please pay $$10 to use $0 instead of $1.` 163 }, 164 }, 165 "variableTable": [ # The `variable_table` exists to aid with computation, memory and network 166 # traffic optimization. It enables storing a variable once and reference 167 # it from multiple variables, including variables stored in the 168 # `variable_table` itself. 169 # For example, the same `this` object, which may appear at many levels of 170 # the stack, can have all of its data stored once in this table. The 171 # stack frame variables then would hold only a reference to it. 172 # 173 # The variable `var_table_index` field is an index into this repeated field. 174 # The stored objects are nameless and get their name from the referencing 175 # variable. The effective variable is a merge of the referencing variable 176 # and the referenced variable. 177 { # Represents a variable or an argument possibly of a compound object type. 178 # Note how the following variables are represented: 179 # 180 # 1) A simple variable: 181 # 182 # int x = 5 183 # 184 # { name: "x", value: "5", type: "int" } // Captured variable 185 # 186 # 2) A compound object: 187 # 188 # struct T { 189 # int m1; 190 # int m2; 191 # }; 192 # T x = { 3, 7 }; 193 # 194 # { // Captured variable 195 # name: "x", 196 # type: "T", 197 # members { name: "m1", value: "3", type: "int" }, 198 # members { name: "m2", value: "7", type: "int" } 199 # } 200 # 201 # 3) A pointer where the pointee was captured: 202 # 203 # T x = { 3, 7 }; 204 # T* p = &x; 205 # 206 # { // Captured variable 207 # name: "p", 208 # type: "T*", 209 # value: "0x00500500", 210 # members { name: "m1", value: "3", type: "int" }, 211 # members { name: "m2", value: "7", type: "int" } 212 # } 213 # 214 # 4) A pointer where the pointee was not captured: 215 # 216 # T* p = new T; 217 # 218 # { // Captured variable 219 # name: "p", 220 # type: "T*", 221 # value: "0x00400400" 222 # status { is_error: true, description { format: "unavailable" } } 223 # } 224 # 225 # The status should describe the reason for the missing value, 226 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 227 # 228 # Note that a null pointer should not have members. 229 # 230 # 5) An unnamed value: 231 # 232 # int* p = new int(7); 233 # 234 # { // Captured variable 235 # name: "p", 236 # value: "0x00500500", 237 # type: "int*", 238 # members { value: "7", type: "int" } } 239 # 240 # 6) An unnamed pointer where the pointee was not captured: 241 # 242 # int* p = new int(7); 243 # int** pp = &p; 244 # 245 # { // Captured variable 246 # name: "pp", 247 # value: "0x00500500", 248 # type: "int**", 249 # members { 250 # value: "0x00400400", 251 # type: "int*" 252 # status { 253 # is_error: true, 254 # description: { format: "unavailable" } } 255 # } 256 # } 257 # } 258 # 259 # To optimize computation, memory and network traffic, variables that 260 # repeat in the output multiple times can be stored once in a shared 261 # variable table and be referenced using the `var_table_index` field. The 262 # variables stored in the shared table are nameless and are essentially 263 # a partition of the complete variable. To reconstruct the complete 264 # variable, merge the referencing variable with the referenced variable. 265 # 266 # When using the shared variable table, the following variables: 267 # 268 # T x = { 3, 7 }; 269 # T* p = &x; 270 # T& r = x; 271 # 272 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 273 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 274 # { name: "r", type="T&", var_table_index: 3 } 275 # 276 # { // Shared variable table entry #3: 277 # members { name: "m1", value: "3", type: "int" }, 278 # members { name: "m2", value: "7", type: "int" } 279 # } 280 # 281 # Note that the pointer address is stored with the referencing variable 282 # and not with the referenced variable. This allows the referenced variable 283 # to be shared between pointers and references. 284 # 285 # The type field is optional. The debugger agent may or may not support it. 286 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 287 # unset. A status of a single variable only applies to that variable or 288 # expression. The rest of breakpoint data still remains valid. Variables 289 # might be reported in error state even when breakpoint is not in final 290 # state. 291 # 292 # The message may refer to variable name with `refers_to` set to 293 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 294 # In either case variable value and members will be unset. 295 # 296 # Example of error message applied to name: `Invalid expression syntax`. 297 # 298 # Example of information message applied to value: `Not captured`. 299 # 300 # Examples of error message applied to value: 301 # 302 # * `Malformed string`, 303 # * `Field f not found in class C` 304 # * `Null pointer dereference` 305 # The message can indicate an error or informational status, and refer to 306 # specific parts of the containing object. 307 # For example, the `Breakpoint.status` field can indicate an error referring 308 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 309 "isError": True or False, # Distinguishes errors from informational messages. 310 "refersTo": "A String", # Reference to which the message applies. 311 "description": { # Represents a message with parameters. # Status message text. 312 "parameters": [ # Optional parameters to be embedded into the message. 313 "A String", 314 ], 315 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 316 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 317 # character. 318 # 319 # Examples: 320 # 321 # * `Failed to load '$0' which helps debug $1 the first time it 322 # is loaded. Again, $0 is very important.` 323 # * `Please pay $$10 to use $0 instead of $1.` 324 }, 325 }, 326 "name": "A String", # Name of the variable, if any. 327 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 328 # one variable can reference the same variable in the table. The 329 # `var_table_index` field is an index into `variable_table` in Breakpoint. 330 "value": "A String", # Simple value of the variable. 331 "members": [ # Members contained or pointed to by the variable. 332 # Object with schema name: Variable 333 ], 334 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 335 # `var_table_index`, `type` goes next to `value`. The interpretation of 336 # a type is agent specific. It is recommended to include the dynamic type 337 # rather than a static type of an object. 338 }, 339 ], 340 "userEmail": "A String", # E-mail address of the user that created this breakpoint 341 "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when 342 # the breakpoint hits. The message may include parameter placeholders `$0`, 343 # `$1`, etc. These placeholders are replaced with the evaluated value 344 # of the appropriate expression. Expressions not referenced in 345 # `log_message_format` are not logged. 346 # 347 # Example: `Message received, id = $0, count = $1` with 348 # `expressions` = `[ message.id, message.count ]`. 349 "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`. 350 "labels": { # A set of custom breakpoint properties, populated by the agent, to be 351 # displayed to the user. 352 "a_key": "A String", 353 }, 354 "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most 355 # recently entered function. 356 { # Represents a stack frame context. 357 "function": "A String", # Demangled function name at the call site. 358 "arguments": [ # Set of arguments passed to this function. 359 # Note that this might not be populated for all stack frames. 360 { # Represents a variable or an argument possibly of a compound object type. 361 # Note how the following variables are represented: 362 # 363 # 1) A simple variable: 364 # 365 # int x = 5 366 # 367 # { name: "x", value: "5", type: "int" } // Captured variable 368 # 369 # 2) A compound object: 370 # 371 # struct T { 372 # int m1; 373 # int m2; 374 # }; 375 # T x = { 3, 7 }; 376 # 377 # { // Captured variable 378 # name: "x", 379 # type: "T", 380 # members { name: "m1", value: "3", type: "int" }, 381 # members { name: "m2", value: "7", type: "int" } 382 # } 383 # 384 # 3) A pointer where the pointee was captured: 385 # 386 # T x = { 3, 7 }; 387 # T* p = &x; 388 # 389 # { // Captured variable 390 # name: "p", 391 # type: "T*", 392 # value: "0x00500500", 393 # members { name: "m1", value: "3", type: "int" }, 394 # members { name: "m2", value: "7", type: "int" } 395 # } 396 # 397 # 4) A pointer where the pointee was not captured: 398 # 399 # T* p = new T; 400 # 401 # { // Captured variable 402 # name: "p", 403 # type: "T*", 404 # value: "0x00400400" 405 # status { is_error: true, description { format: "unavailable" } } 406 # } 407 # 408 # The status should describe the reason for the missing value, 409 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 410 # 411 # Note that a null pointer should not have members. 412 # 413 # 5) An unnamed value: 414 # 415 # int* p = new int(7); 416 # 417 # { // Captured variable 418 # name: "p", 419 # value: "0x00500500", 420 # type: "int*", 421 # members { value: "7", type: "int" } } 422 # 423 # 6) An unnamed pointer where the pointee was not captured: 424 # 425 # int* p = new int(7); 426 # int** pp = &p; 427 # 428 # { // Captured variable 429 # name: "pp", 430 # value: "0x00500500", 431 # type: "int**", 432 # members { 433 # value: "0x00400400", 434 # type: "int*" 435 # status { 436 # is_error: true, 437 # description: { format: "unavailable" } } 438 # } 439 # } 440 # } 441 # 442 # To optimize computation, memory and network traffic, variables that 443 # repeat in the output multiple times can be stored once in a shared 444 # variable table and be referenced using the `var_table_index` field. The 445 # variables stored in the shared table are nameless and are essentially 446 # a partition of the complete variable. To reconstruct the complete 447 # variable, merge the referencing variable with the referenced variable. 448 # 449 # When using the shared variable table, the following variables: 450 # 451 # T x = { 3, 7 }; 452 # T* p = &x; 453 # T& r = x; 454 # 455 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 456 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 457 # { name: "r", type="T&", var_table_index: 3 } 458 # 459 # { // Shared variable table entry #3: 460 # members { name: "m1", value: "3", type: "int" }, 461 # members { name: "m2", value: "7", type: "int" } 462 # } 463 # 464 # Note that the pointer address is stored with the referencing variable 465 # and not with the referenced variable. This allows the referenced variable 466 # to be shared between pointers and references. 467 # 468 # The type field is optional. The debugger agent may or may not support it. 469 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 470 # unset. A status of a single variable only applies to that variable or 471 # expression. The rest of breakpoint data still remains valid. Variables 472 # might be reported in error state even when breakpoint is not in final 473 # state. 474 # 475 # The message may refer to variable name with `refers_to` set to 476 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 477 # In either case variable value and members will be unset. 478 # 479 # Example of error message applied to name: `Invalid expression syntax`. 480 # 481 # Example of information message applied to value: `Not captured`. 482 # 483 # Examples of error message applied to value: 484 # 485 # * `Malformed string`, 486 # * `Field f not found in class C` 487 # * `Null pointer dereference` 488 # The message can indicate an error or informational status, and refer to 489 # specific parts of the containing object. 490 # For example, the `Breakpoint.status` field can indicate an error referring 491 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 492 "isError": True or False, # Distinguishes errors from informational messages. 493 "refersTo": "A String", # Reference to which the message applies. 494 "description": { # Represents a message with parameters. # Status message text. 495 "parameters": [ # Optional parameters to be embedded into the message. 496 "A String", 497 ], 498 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 499 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 500 # character. 501 # 502 # Examples: 503 # 504 # * `Failed to load '$0' which helps debug $1 the first time it 505 # is loaded. Again, $0 is very important.` 506 # * `Please pay $$10 to use $0 instead of $1.` 507 }, 508 }, 509 "name": "A String", # Name of the variable, if any. 510 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 511 # one variable can reference the same variable in the table. The 512 # `var_table_index` field is an index into `variable_table` in Breakpoint. 513 "value": "A String", # Simple value of the variable. 514 "members": [ # Members contained or pointed to by the variable. 515 # Object with schema name: Variable 516 ], 517 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 518 # `var_table_index`, `type` goes next to `value`. The interpretation of 519 # a type is agent specific. It is recommended to include the dynamic type 520 # rather than a static type of an object. 521 }, 522 ], 523 "locals": [ # Set of local variables at the stack frame location. 524 # Note that this might not be populated for all stack frames. 525 { # Represents a variable or an argument possibly of a compound object type. 526 # Note how the following variables are represented: 527 # 528 # 1) A simple variable: 529 # 530 # int x = 5 531 # 532 # { name: "x", value: "5", type: "int" } // Captured variable 533 # 534 # 2) A compound object: 535 # 536 # struct T { 537 # int m1; 538 # int m2; 539 # }; 540 # T x = { 3, 7 }; 541 # 542 # { // Captured variable 543 # name: "x", 544 # type: "T", 545 # members { name: "m1", value: "3", type: "int" }, 546 # members { name: "m2", value: "7", type: "int" } 547 # } 548 # 549 # 3) A pointer where the pointee was captured: 550 # 551 # T x = { 3, 7 }; 552 # T* p = &x; 553 # 554 # { // Captured variable 555 # name: "p", 556 # type: "T*", 557 # value: "0x00500500", 558 # members { name: "m1", value: "3", type: "int" }, 559 # members { name: "m2", value: "7", type: "int" } 560 # } 561 # 562 # 4) A pointer where the pointee was not captured: 563 # 564 # T* p = new T; 565 # 566 # { // Captured variable 567 # name: "p", 568 # type: "T*", 569 # value: "0x00400400" 570 # status { is_error: true, description { format: "unavailable" } } 571 # } 572 # 573 # The status should describe the reason for the missing value, 574 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 575 # 576 # Note that a null pointer should not have members. 577 # 578 # 5) An unnamed value: 579 # 580 # int* p = new int(7); 581 # 582 # { // Captured variable 583 # name: "p", 584 # value: "0x00500500", 585 # type: "int*", 586 # members { value: "7", type: "int" } } 587 # 588 # 6) An unnamed pointer where the pointee was not captured: 589 # 590 # int* p = new int(7); 591 # int** pp = &p; 592 # 593 # { // Captured variable 594 # name: "pp", 595 # value: "0x00500500", 596 # type: "int**", 597 # members { 598 # value: "0x00400400", 599 # type: "int*" 600 # status { 601 # is_error: true, 602 # description: { format: "unavailable" } } 603 # } 604 # } 605 # } 606 # 607 # To optimize computation, memory and network traffic, variables that 608 # repeat in the output multiple times can be stored once in a shared 609 # variable table and be referenced using the `var_table_index` field. The 610 # variables stored in the shared table are nameless and are essentially 611 # a partition of the complete variable. To reconstruct the complete 612 # variable, merge the referencing variable with the referenced variable. 613 # 614 # When using the shared variable table, the following variables: 615 # 616 # T x = { 3, 7 }; 617 # T* p = &x; 618 # T& r = x; 619 # 620 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 621 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 622 # { name: "r", type="T&", var_table_index: 3 } 623 # 624 # { // Shared variable table entry #3: 625 # members { name: "m1", value: "3", type: "int" }, 626 # members { name: "m2", value: "7", type: "int" } 627 # } 628 # 629 # Note that the pointer address is stored with the referencing variable 630 # and not with the referenced variable. This allows the referenced variable 631 # to be shared between pointers and references. 632 # 633 # The type field is optional. The debugger agent may or may not support it. 634 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 635 # unset. A status of a single variable only applies to that variable or 636 # expression. The rest of breakpoint data still remains valid. Variables 637 # might be reported in error state even when breakpoint is not in final 638 # state. 639 # 640 # The message may refer to variable name with `refers_to` set to 641 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 642 # In either case variable value and members will be unset. 643 # 644 # Example of error message applied to name: `Invalid expression syntax`. 645 # 646 # Example of information message applied to value: `Not captured`. 647 # 648 # Examples of error message applied to value: 649 # 650 # * `Malformed string`, 651 # * `Field f not found in class C` 652 # * `Null pointer dereference` 653 # The message can indicate an error or informational status, and refer to 654 # specific parts of the containing object. 655 # For example, the `Breakpoint.status` field can indicate an error referring 656 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 657 "isError": True or False, # Distinguishes errors from informational messages. 658 "refersTo": "A String", # Reference to which the message applies. 659 "description": { # Represents a message with parameters. # Status message text. 660 "parameters": [ # Optional parameters to be embedded into the message. 661 "A String", 662 ], 663 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 664 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 665 # character. 666 # 667 # Examples: 668 # 669 # * `Failed to load '$0' which helps debug $1 the first time it 670 # is loaded. Again, $0 is very important.` 671 # * `Please pay $$10 to use $0 instead of $1.` 672 }, 673 }, 674 "name": "A String", # Name of the variable, if any. 675 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 676 # one variable can reference the same variable in the table. The 677 # `var_table_index` field is an index into `variable_table` in Breakpoint. 678 "value": "A String", # Simple value of the variable. 679 "members": [ # Members contained or pointed to by the variable. 680 # Object with schema name: Variable 681 ], 682 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 683 # `var_table_index`, `type` goes next to `value`. The interpretation of 684 # a type is agent specific. It is recommended to include the dynamic type 685 # rather than a static type of an object. 686 }, 687 ], 688 "location": { # Represents a location in the source code. # Source location of the call site. 689 "column": 42, # Column within a line. The first column in a line as the value `1`. 690 # Agents that do not support setting breakpoints on specific columns ignore 691 # this field. 692 "path": "A String", # Path to the source file within the source context of the target binary. 693 "line": 42, # Line inside the file. The first line in the file has the value `1`. 694 }, 695 }, 696 ], 697 "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution. 698 "location": { # Represents a location in the source code. # Breakpoint source location. 699 "column": 42, # Column within a line. The first column in a line as the value `1`. 700 # Agents that do not support setting breakpoints on specific columns ignore 701 # this field. 702 "path": "A String", # Path to the source file within the source context of the target binary. 703 "line": 42, # Line inside the file. The first line in the file has the value `1`. 704 }, 705 "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds 706 # resolution. 707 "action": "A String", # Action that the agent should perform when the code at the 708 # breakpoint location is hit. 709 "expressions": [ # List of read-only expressions to evaluate at the breakpoint location. 710 # The expressions are composed using expressions in the programming language 711 # at the source location. If the breakpoint action is `LOG`, the evaluated 712 # expressions are included in log statements. 713 "A String", 714 ], 715 "isFinalState": True or False, # When true, indicates that this is a final result and the 716 # breakpoint state will not change from here on. 717 "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time. 718 # The evaluated expressions appear in exactly the same order they 719 # are listed in the `expressions` field. 720 # The `name` field holds the original expression text, the `value` or 721 # `members` field holds the result of the evaluated expression. 722 # If the expression cannot be evaluated, the `status` inside the `Variable` 723 # will indicate an error and contain the error text. 724 { # Represents a variable or an argument possibly of a compound object type. 725 # Note how the following variables are represented: 726 # 727 # 1) A simple variable: 728 # 729 # int x = 5 730 # 731 # { name: "x", value: "5", type: "int" } // Captured variable 732 # 733 # 2) A compound object: 734 # 735 # struct T { 736 # int m1; 737 # int m2; 738 # }; 739 # T x = { 3, 7 }; 740 # 741 # { // Captured variable 742 # name: "x", 743 # type: "T", 744 # members { name: "m1", value: "3", type: "int" }, 745 # members { name: "m2", value: "7", type: "int" } 746 # } 747 # 748 # 3) A pointer where the pointee was captured: 749 # 750 # T x = { 3, 7 }; 751 # T* p = &x; 752 # 753 # { // Captured variable 754 # name: "p", 755 # type: "T*", 756 # value: "0x00500500", 757 # members { name: "m1", value: "3", type: "int" }, 758 # members { name: "m2", value: "7", type: "int" } 759 # } 760 # 761 # 4) A pointer where the pointee was not captured: 762 # 763 # T* p = new T; 764 # 765 # { // Captured variable 766 # name: "p", 767 # type: "T*", 768 # value: "0x00400400" 769 # status { is_error: true, description { format: "unavailable" } } 770 # } 771 # 772 # The status should describe the reason for the missing value, 773 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 774 # 775 # Note that a null pointer should not have members. 776 # 777 # 5) An unnamed value: 778 # 779 # int* p = new int(7); 780 # 781 # { // Captured variable 782 # name: "p", 783 # value: "0x00500500", 784 # type: "int*", 785 # members { value: "7", type: "int" } } 786 # 787 # 6) An unnamed pointer where the pointee was not captured: 788 # 789 # int* p = new int(7); 790 # int** pp = &p; 791 # 792 # { // Captured variable 793 # name: "pp", 794 # value: "0x00500500", 795 # type: "int**", 796 # members { 797 # value: "0x00400400", 798 # type: "int*" 799 # status { 800 # is_error: true, 801 # description: { format: "unavailable" } } 802 # } 803 # } 804 # } 805 # 806 # To optimize computation, memory and network traffic, variables that 807 # repeat in the output multiple times can be stored once in a shared 808 # variable table and be referenced using the `var_table_index` field. The 809 # variables stored in the shared table are nameless and are essentially 810 # a partition of the complete variable. To reconstruct the complete 811 # variable, merge the referencing variable with the referenced variable. 812 # 813 # When using the shared variable table, the following variables: 814 # 815 # T x = { 3, 7 }; 816 # T* p = &x; 817 # T& r = x; 818 # 819 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 820 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 821 # { name: "r", type="T&", var_table_index: 3 } 822 # 823 # { // Shared variable table entry #3: 824 # members { name: "m1", value: "3", type: "int" }, 825 # members { name: "m2", value: "7", type: "int" } 826 # } 827 # 828 # Note that the pointer address is stored with the referencing variable 829 # and not with the referenced variable. This allows the referenced variable 830 # to be shared between pointers and references. 831 # 832 # The type field is optional. The debugger agent may or may not support it. 833 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 834 # unset. A status of a single variable only applies to that variable or 835 # expression. The rest of breakpoint data still remains valid. Variables 836 # might be reported in error state even when breakpoint is not in final 837 # state. 838 # 839 # The message may refer to variable name with `refers_to` set to 840 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 841 # In either case variable value and members will be unset. 842 # 843 # Example of error message applied to name: `Invalid expression syntax`. 844 # 845 # Example of information message applied to value: `Not captured`. 846 # 847 # Examples of error message applied to value: 848 # 849 # * `Malformed string`, 850 # * `Field f not found in class C` 851 # * `Null pointer dereference` 852 # The message can indicate an error or informational status, and refer to 853 # specific parts of the containing object. 854 # For example, the `Breakpoint.status` field can indicate an error referring 855 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 856 "isError": True or False, # Distinguishes errors from informational messages. 857 "refersTo": "A String", # Reference to which the message applies. 858 "description": { # Represents a message with parameters. # Status message text. 859 "parameters": [ # Optional parameters to be embedded into the message. 860 "A String", 861 ], 862 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 863 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 864 # character. 865 # 866 # Examples: 867 # 868 # * `Failed to load '$0' which helps debug $1 the first time it 869 # is loaded. Again, $0 is very important.` 870 # * `Please pay $$10 to use $0 instead of $1.` 871 }, 872 }, 873 "name": "A String", # Name of the variable, if any. 874 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 875 # one variable can reference the same variable in the table. The 876 # `var_table_index` field is an index into `variable_table` in Breakpoint. 877 "value": "A String", # Simple value of the variable. 878 "members": [ # Members contained or pointed to by the variable. 879 # Object with schema name: Variable 880 ], 881 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 882 # `var_table_index`, `type` goes next to `value`. The interpretation of 883 # a type is agent specific. It is recommended to include the dynamic type 884 # rather than a static type of an object. 885 }, 886 ], 887 "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee. 888 "condition": "A String", # Condition that triggers the breakpoint. 889 # The condition is a compound boolean expression composed using expressions 890 # in a programming language at the source location. 891 }, 892 ], 893 }</pre> 894</div> 895 896<div class="method"> 897 <code class="details" id="update">update(debuggeeId, id, body, x__xgafv=None)</code> 898 <pre>Updates the breakpoint state or mutable fields. 899The entire Breakpoint message must be sent back to the controller service. 900 901Updates to active breakpoint fields are only allowed if the new value 902does not change the breakpoint specification. Updates to the `location`, 903`condition` and `expressions` fields should not alter the breakpoint 904semantics. These may only make changes such as canonicalizing a value 905or snapping the location to the correct line of code. 906 907Args: 908 debuggeeId: string, Identifies the debuggee being debugged. (required) 909 id: string, Breakpoint identifier, unique in the scope of the debuggee. (required) 910 body: object, The request body. (required) 911 The object takes the form of: 912 913{ # Request to update an active breakpoint. 914 "breakpoint": { # Represents the breakpoint specification, status and results. # Updated breakpoint information. 915 # The field `id` must be set. 916 # The agent must echo all Breakpoint specification fields in the update. 917 "status": { # Represents a contextual status message. # Breakpoint status. 918 # 919 # The status includes an error flag and a human readable message. 920 # This field is usually unset. The message can be either 921 # informational or an error message. Regardless, clients should always 922 # display the text message back to the user. 923 # 924 # Error status indicates complete failure of the breakpoint. 925 # 926 # Example (non-final state): `Still loading symbols...` 927 # 928 # Examples (final state): 929 # 930 # * `Invalid line number` referring to location 931 # * `Field f not found in class C` referring to condition 932 # The message can indicate an error or informational status, and refer to 933 # specific parts of the containing object. 934 # For example, the `Breakpoint.status` field can indicate an error referring 935 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 936 "isError": True or False, # Distinguishes errors from informational messages. 937 "refersTo": "A String", # Reference to which the message applies. 938 "description": { # Represents a message with parameters. # Status message text. 939 "parameters": [ # Optional parameters to be embedded into the message. 940 "A String", 941 ], 942 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 943 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 944 # character. 945 # 946 # Examples: 947 # 948 # * `Failed to load '$0' which helps debug $1 the first time it 949 # is loaded. Again, $0 is very important.` 950 # * `Please pay $$10 to use $0 instead of $1.` 951 }, 952 }, 953 "variableTable": [ # The `variable_table` exists to aid with computation, memory and network 954 # traffic optimization. It enables storing a variable once and reference 955 # it from multiple variables, including variables stored in the 956 # `variable_table` itself. 957 # For example, the same `this` object, which may appear at many levels of 958 # the stack, can have all of its data stored once in this table. The 959 # stack frame variables then would hold only a reference to it. 960 # 961 # The variable `var_table_index` field is an index into this repeated field. 962 # The stored objects are nameless and get their name from the referencing 963 # variable. The effective variable is a merge of the referencing variable 964 # and the referenced variable. 965 { # Represents a variable or an argument possibly of a compound object type. 966 # Note how the following variables are represented: 967 # 968 # 1) A simple variable: 969 # 970 # int x = 5 971 # 972 # { name: "x", value: "5", type: "int" } // Captured variable 973 # 974 # 2) A compound object: 975 # 976 # struct T { 977 # int m1; 978 # int m2; 979 # }; 980 # T x = { 3, 7 }; 981 # 982 # { // Captured variable 983 # name: "x", 984 # type: "T", 985 # members { name: "m1", value: "3", type: "int" }, 986 # members { name: "m2", value: "7", type: "int" } 987 # } 988 # 989 # 3) A pointer where the pointee was captured: 990 # 991 # T x = { 3, 7 }; 992 # T* p = &x; 993 # 994 # { // Captured variable 995 # name: "p", 996 # type: "T*", 997 # value: "0x00500500", 998 # members { name: "m1", value: "3", type: "int" }, 999 # members { name: "m2", value: "7", type: "int" } 1000 # } 1001 # 1002 # 4) A pointer where the pointee was not captured: 1003 # 1004 # T* p = new T; 1005 # 1006 # { // Captured variable 1007 # name: "p", 1008 # type: "T*", 1009 # value: "0x00400400" 1010 # status { is_error: true, description { format: "unavailable" } } 1011 # } 1012 # 1013 # The status should describe the reason for the missing value, 1014 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 1015 # 1016 # Note that a null pointer should not have members. 1017 # 1018 # 5) An unnamed value: 1019 # 1020 # int* p = new int(7); 1021 # 1022 # { // Captured variable 1023 # name: "p", 1024 # value: "0x00500500", 1025 # type: "int*", 1026 # members { value: "7", type: "int" } } 1027 # 1028 # 6) An unnamed pointer where the pointee was not captured: 1029 # 1030 # int* p = new int(7); 1031 # int** pp = &p; 1032 # 1033 # { // Captured variable 1034 # name: "pp", 1035 # value: "0x00500500", 1036 # type: "int**", 1037 # members { 1038 # value: "0x00400400", 1039 # type: "int*" 1040 # status { 1041 # is_error: true, 1042 # description: { format: "unavailable" } } 1043 # } 1044 # } 1045 # } 1046 # 1047 # To optimize computation, memory and network traffic, variables that 1048 # repeat in the output multiple times can be stored once in a shared 1049 # variable table and be referenced using the `var_table_index` field. The 1050 # variables stored in the shared table are nameless and are essentially 1051 # a partition of the complete variable. To reconstruct the complete 1052 # variable, merge the referencing variable with the referenced variable. 1053 # 1054 # When using the shared variable table, the following variables: 1055 # 1056 # T x = { 3, 7 }; 1057 # T* p = &x; 1058 # T& r = x; 1059 # 1060 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 1061 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 1062 # { name: "r", type="T&", var_table_index: 3 } 1063 # 1064 # { // Shared variable table entry #3: 1065 # members { name: "m1", value: "3", type: "int" }, 1066 # members { name: "m2", value: "7", type: "int" } 1067 # } 1068 # 1069 # Note that the pointer address is stored with the referencing variable 1070 # and not with the referenced variable. This allows the referenced variable 1071 # to be shared between pointers and references. 1072 # 1073 # The type field is optional. The debugger agent may or may not support it. 1074 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 1075 # unset. A status of a single variable only applies to that variable or 1076 # expression. The rest of breakpoint data still remains valid. Variables 1077 # might be reported in error state even when breakpoint is not in final 1078 # state. 1079 # 1080 # The message may refer to variable name with `refers_to` set to 1081 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 1082 # In either case variable value and members will be unset. 1083 # 1084 # Example of error message applied to name: `Invalid expression syntax`. 1085 # 1086 # Example of information message applied to value: `Not captured`. 1087 # 1088 # Examples of error message applied to value: 1089 # 1090 # * `Malformed string`, 1091 # * `Field f not found in class C` 1092 # * `Null pointer dereference` 1093 # The message can indicate an error or informational status, and refer to 1094 # specific parts of the containing object. 1095 # For example, the `Breakpoint.status` field can indicate an error referring 1096 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 1097 "isError": True or False, # Distinguishes errors from informational messages. 1098 "refersTo": "A String", # Reference to which the message applies. 1099 "description": { # Represents a message with parameters. # Status message text. 1100 "parameters": [ # Optional parameters to be embedded into the message. 1101 "A String", 1102 ], 1103 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 1104 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 1105 # character. 1106 # 1107 # Examples: 1108 # 1109 # * `Failed to load '$0' which helps debug $1 the first time it 1110 # is loaded. Again, $0 is very important.` 1111 # * `Please pay $$10 to use $0 instead of $1.` 1112 }, 1113 }, 1114 "name": "A String", # Name of the variable, if any. 1115 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 1116 # one variable can reference the same variable in the table. The 1117 # `var_table_index` field is an index into `variable_table` in Breakpoint. 1118 "value": "A String", # Simple value of the variable. 1119 "members": [ # Members contained or pointed to by the variable. 1120 # Object with schema name: Variable 1121 ], 1122 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 1123 # `var_table_index`, `type` goes next to `value`. The interpretation of 1124 # a type is agent specific. It is recommended to include the dynamic type 1125 # rather than a static type of an object. 1126 }, 1127 ], 1128 "userEmail": "A String", # E-mail address of the user that created this breakpoint 1129 "logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when 1130 # the breakpoint hits. The message may include parameter placeholders `$0`, 1131 # `$1`, etc. These placeholders are replaced with the evaluated value 1132 # of the appropriate expression. Expressions not referenced in 1133 # `log_message_format` are not logged. 1134 # 1135 # Example: `Message received, id = $0, count = $1` with 1136 # `expressions` = `[ message.id, message.count ]`. 1137 "logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`. 1138 "labels": { # A set of custom breakpoint properties, populated by the agent, to be 1139 # displayed to the user. 1140 "a_key": "A String", 1141 }, 1142 "stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most 1143 # recently entered function. 1144 { # Represents a stack frame context. 1145 "function": "A String", # Demangled function name at the call site. 1146 "arguments": [ # Set of arguments passed to this function. 1147 # Note that this might not be populated for all stack frames. 1148 { # Represents a variable or an argument possibly of a compound object type. 1149 # Note how the following variables are represented: 1150 # 1151 # 1) A simple variable: 1152 # 1153 # int x = 5 1154 # 1155 # { name: "x", value: "5", type: "int" } // Captured variable 1156 # 1157 # 2) A compound object: 1158 # 1159 # struct T { 1160 # int m1; 1161 # int m2; 1162 # }; 1163 # T x = { 3, 7 }; 1164 # 1165 # { // Captured variable 1166 # name: "x", 1167 # type: "T", 1168 # members { name: "m1", value: "3", type: "int" }, 1169 # members { name: "m2", value: "7", type: "int" } 1170 # } 1171 # 1172 # 3) A pointer where the pointee was captured: 1173 # 1174 # T x = { 3, 7 }; 1175 # T* p = &x; 1176 # 1177 # { // Captured variable 1178 # name: "p", 1179 # type: "T*", 1180 # value: "0x00500500", 1181 # members { name: "m1", value: "3", type: "int" }, 1182 # members { name: "m2", value: "7", type: "int" } 1183 # } 1184 # 1185 # 4) A pointer where the pointee was not captured: 1186 # 1187 # T* p = new T; 1188 # 1189 # { // Captured variable 1190 # name: "p", 1191 # type: "T*", 1192 # value: "0x00400400" 1193 # status { is_error: true, description { format: "unavailable" } } 1194 # } 1195 # 1196 # The status should describe the reason for the missing value, 1197 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 1198 # 1199 # Note that a null pointer should not have members. 1200 # 1201 # 5) An unnamed value: 1202 # 1203 # int* p = new int(7); 1204 # 1205 # { // Captured variable 1206 # name: "p", 1207 # value: "0x00500500", 1208 # type: "int*", 1209 # members { value: "7", type: "int" } } 1210 # 1211 # 6) An unnamed pointer where the pointee was not captured: 1212 # 1213 # int* p = new int(7); 1214 # int** pp = &p; 1215 # 1216 # { // Captured variable 1217 # name: "pp", 1218 # value: "0x00500500", 1219 # type: "int**", 1220 # members { 1221 # value: "0x00400400", 1222 # type: "int*" 1223 # status { 1224 # is_error: true, 1225 # description: { format: "unavailable" } } 1226 # } 1227 # } 1228 # } 1229 # 1230 # To optimize computation, memory and network traffic, variables that 1231 # repeat in the output multiple times can be stored once in a shared 1232 # variable table and be referenced using the `var_table_index` field. The 1233 # variables stored in the shared table are nameless and are essentially 1234 # a partition of the complete variable. To reconstruct the complete 1235 # variable, merge the referencing variable with the referenced variable. 1236 # 1237 # When using the shared variable table, the following variables: 1238 # 1239 # T x = { 3, 7 }; 1240 # T* p = &x; 1241 # T& r = x; 1242 # 1243 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 1244 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 1245 # { name: "r", type="T&", var_table_index: 3 } 1246 # 1247 # { // Shared variable table entry #3: 1248 # members { name: "m1", value: "3", type: "int" }, 1249 # members { name: "m2", value: "7", type: "int" } 1250 # } 1251 # 1252 # Note that the pointer address is stored with the referencing variable 1253 # and not with the referenced variable. This allows the referenced variable 1254 # to be shared between pointers and references. 1255 # 1256 # The type field is optional. The debugger agent may or may not support it. 1257 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 1258 # unset. A status of a single variable only applies to that variable or 1259 # expression. The rest of breakpoint data still remains valid. Variables 1260 # might be reported in error state even when breakpoint is not in final 1261 # state. 1262 # 1263 # The message may refer to variable name with `refers_to` set to 1264 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 1265 # In either case variable value and members will be unset. 1266 # 1267 # Example of error message applied to name: `Invalid expression syntax`. 1268 # 1269 # Example of information message applied to value: `Not captured`. 1270 # 1271 # Examples of error message applied to value: 1272 # 1273 # * `Malformed string`, 1274 # * `Field f not found in class C` 1275 # * `Null pointer dereference` 1276 # The message can indicate an error or informational status, and refer to 1277 # specific parts of the containing object. 1278 # For example, the `Breakpoint.status` field can indicate an error referring 1279 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 1280 "isError": True or False, # Distinguishes errors from informational messages. 1281 "refersTo": "A String", # Reference to which the message applies. 1282 "description": { # Represents a message with parameters. # Status message text. 1283 "parameters": [ # Optional parameters to be embedded into the message. 1284 "A String", 1285 ], 1286 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 1287 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 1288 # character. 1289 # 1290 # Examples: 1291 # 1292 # * `Failed to load '$0' which helps debug $1 the first time it 1293 # is loaded. Again, $0 is very important.` 1294 # * `Please pay $$10 to use $0 instead of $1.` 1295 }, 1296 }, 1297 "name": "A String", # Name of the variable, if any. 1298 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 1299 # one variable can reference the same variable in the table. The 1300 # `var_table_index` field is an index into `variable_table` in Breakpoint. 1301 "value": "A String", # Simple value of the variable. 1302 "members": [ # Members contained or pointed to by the variable. 1303 # Object with schema name: Variable 1304 ], 1305 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 1306 # `var_table_index`, `type` goes next to `value`. The interpretation of 1307 # a type is agent specific. It is recommended to include the dynamic type 1308 # rather than a static type of an object. 1309 }, 1310 ], 1311 "locals": [ # Set of local variables at the stack frame location. 1312 # Note that this might not be populated for all stack frames. 1313 { # Represents a variable or an argument possibly of a compound object type. 1314 # Note how the following variables are represented: 1315 # 1316 # 1) A simple variable: 1317 # 1318 # int x = 5 1319 # 1320 # { name: "x", value: "5", type: "int" } // Captured variable 1321 # 1322 # 2) A compound object: 1323 # 1324 # struct T { 1325 # int m1; 1326 # int m2; 1327 # }; 1328 # T x = { 3, 7 }; 1329 # 1330 # { // Captured variable 1331 # name: "x", 1332 # type: "T", 1333 # members { name: "m1", value: "3", type: "int" }, 1334 # members { name: "m2", value: "7", type: "int" } 1335 # } 1336 # 1337 # 3) A pointer where the pointee was captured: 1338 # 1339 # T x = { 3, 7 }; 1340 # T* p = &x; 1341 # 1342 # { // Captured variable 1343 # name: "p", 1344 # type: "T*", 1345 # value: "0x00500500", 1346 # members { name: "m1", value: "3", type: "int" }, 1347 # members { name: "m2", value: "7", type: "int" } 1348 # } 1349 # 1350 # 4) A pointer where the pointee was not captured: 1351 # 1352 # T* p = new T; 1353 # 1354 # { // Captured variable 1355 # name: "p", 1356 # type: "T*", 1357 # value: "0x00400400" 1358 # status { is_error: true, description { format: "unavailable" } } 1359 # } 1360 # 1361 # The status should describe the reason for the missing value, 1362 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 1363 # 1364 # Note that a null pointer should not have members. 1365 # 1366 # 5) An unnamed value: 1367 # 1368 # int* p = new int(7); 1369 # 1370 # { // Captured variable 1371 # name: "p", 1372 # value: "0x00500500", 1373 # type: "int*", 1374 # members { value: "7", type: "int" } } 1375 # 1376 # 6) An unnamed pointer where the pointee was not captured: 1377 # 1378 # int* p = new int(7); 1379 # int** pp = &p; 1380 # 1381 # { // Captured variable 1382 # name: "pp", 1383 # value: "0x00500500", 1384 # type: "int**", 1385 # members { 1386 # value: "0x00400400", 1387 # type: "int*" 1388 # status { 1389 # is_error: true, 1390 # description: { format: "unavailable" } } 1391 # } 1392 # } 1393 # } 1394 # 1395 # To optimize computation, memory and network traffic, variables that 1396 # repeat in the output multiple times can be stored once in a shared 1397 # variable table and be referenced using the `var_table_index` field. The 1398 # variables stored in the shared table are nameless and are essentially 1399 # a partition of the complete variable. To reconstruct the complete 1400 # variable, merge the referencing variable with the referenced variable. 1401 # 1402 # When using the shared variable table, the following variables: 1403 # 1404 # T x = { 3, 7 }; 1405 # T* p = &x; 1406 # T& r = x; 1407 # 1408 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 1409 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 1410 # { name: "r", type="T&", var_table_index: 3 } 1411 # 1412 # { // Shared variable table entry #3: 1413 # members { name: "m1", value: "3", type: "int" }, 1414 # members { name: "m2", value: "7", type: "int" } 1415 # } 1416 # 1417 # Note that the pointer address is stored with the referencing variable 1418 # and not with the referenced variable. This allows the referenced variable 1419 # to be shared between pointers and references. 1420 # 1421 # The type field is optional. The debugger agent may or may not support it. 1422 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 1423 # unset. A status of a single variable only applies to that variable or 1424 # expression. The rest of breakpoint data still remains valid. Variables 1425 # might be reported in error state even when breakpoint is not in final 1426 # state. 1427 # 1428 # The message may refer to variable name with `refers_to` set to 1429 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 1430 # In either case variable value and members will be unset. 1431 # 1432 # Example of error message applied to name: `Invalid expression syntax`. 1433 # 1434 # Example of information message applied to value: `Not captured`. 1435 # 1436 # Examples of error message applied to value: 1437 # 1438 # * `Malformed string`, 1439 # * `Field f not found in class C` 1440 # * `Null pointer dereference` 1441 # The message can indicate an error or informational status, and refer to 1442 # specific parts of the containing object. 1443 # For example, the `Breakpoint.status` field can indicate an error referring 1444 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 1445 "isError": True or False, # Distinguishes errors from informational messages. 1446 "refersTo": "A String", # Reference to which the message applies. 1447 "description": { # Represents a message with parameters. # Status message text. 1448 "parameters": [ # Optional parameters to be embedded into the message. 1449 "A String", 1450 ], 1451 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 1452 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 1453 # character. 1454 # 1455 # Examples: 1456 # 1457 # * `Failed to load '$0' which helps debug $1 the first time it 1458 # is loaded. Again, $0 is very important.` 1459 # * `Please pay $$10 to use $0 instead of $1.` 1460 }, 1461 }, 1462 "name": "A String", # Name of the variable, if any. 1463 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 1464 # one variable can reference the same variable in the table. The 1465 # `var_table_index` field is an index into `variable_table` in Breakpoint. 1466 "value": "A String", # Simple value of the variable. 1467 "members": [ # Members contained or pointed to by the variable. 1468 # Object with schema name: Variable 1469 ], 1470 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 1471 # `var_table_index`, `type` goes next to `value`. The interpretation of 1472 # a type is agent specific. It is recommended to include the dynamic type 1473 # rather than a static type of an object. 1474 }, 1475 ], 1476 "location": { # Represents a location in the source code. # Source location of the call site. 1477 "column": 42, # Column within a line. The first column in a line as the value `1`. 1478 # Agents that do not support setting breakpoints on specific columns ignore 1479 # this field. 1480 "path": "A String", # Path to the source file within the source context of the target binary. 1481 "line": 42, # Line inside the file. The first line in the file has the value `1`. 1482 }, 1483 }, 1484 ], 1485 "createTime": "A String", # Time this breakpoint was created by the server in seconds resolution. 1486 "location": { # Represents a location in the source code. # Breakpoint source location. 1487 "column": 42, # Column within a line. The first column in a line as the value `1`. 1488 # Agents that do not support setting breakpoints on specific columns ignore 1489 # this field. 1490 "path": "A String", # Path to the source file within the source context of the target binary. 1491 "line": 42, # Line inside the file. The first line in the file has the value `1`. 1492 }, 1493 "finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds 1494 # resolution. 1495 "action": "A String", # Action that the agent should perform when the code at the 1496 # breakpoint location is hit. 1497 "expressions": [ # List of read-only expressions to evaluate at the breakpoint location. 1498 # The expressions are composed using expressions in the programming language 1499 # at the source location. If the breakpoint action is `LOG`, the evaluated 1500 # expressions are included in log statements. 1501 "A String", 1502 ], 1503 "isFinalState": True or False, # When true, indicates that this is a final result and the 1504 # breakpoint state will not change from here on. 1505 "evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time. 1506 # The evaluated expressions appear in exactly the same order they 1507 # are listed in the `expressions` field. 1508 # The `name` field holds the original expression text, the `value` or 1509 # `members` field holds the result of the evaluated expression. 1510 # If the expression cannot be evaluated, the `status` inside the `Variable` 1511 # will indicate an error and contain the error text. 1512 { # Represents a variable or an argument possibly of a compound object type. 1513 # Note how the following variables are represented: 1514 # 1515 # 1) A simple variable: 1516 # 1517 # int x = 5 1518 # 1519 # { name: "x", value: "5", type: "int" } // Captured variable 1520 # 1521 # 2) A compound object: 1522 # 1523 # struct T { 1524 # int m1; 1525 # int m2; 1526 # }; 1527 # T x = { 3, 7 }; 1528 # 1529 # { // Captured variable 1530 # name: "x", 1531 # type: "T", 1532 # members { name: "m1", value: "3", type: "int" }, 1533 # members { name: "m2", value: "7", type: "int" } 1534 # } 1535 # 1536 # 3) A pointer where the pointee was captured: 1537 # 1538 # T x = { 3, 7 }; 1539 # T* p = &x; 1540 # 1541 # { // Captured variable 1542 # name: "p", 1543 # type: "T*", 1544 # value: "0x00500500", 1545 # members { name: "m1", value: "3", type: "int" }, 1546 # members { name: "m2", value: "7", type: "int" } 1547 # } 1548 # 1549 # 4) A pointer where the pointee was not captured: 1550 # 1551 # T* p = new T; 1552 # 1553 # { // Captured variable 1554 # name: "p", 1555 # type: "T*", 1556 # value: "0x00400400" 1557 # status { is_error: true, description { format: "unavailable" } } 1558 # } 1559 # 1560 # The status should describe the reason for the missing value, 1561 # such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`. 1562 # 1563 # Note that a null pointer should not have members. 1564 # 1565 # 5) An unnamed value: 1566 # 1567 # int* p = new int(7); 1568 # 1569 # { // Captured variable 1570 # name: "p", 1571 # value: "0x00500500", 1572 # type: "int*", 1573 # members { value: "7", type: "int" } } 1574 # 1575 # 6) An unnamed pointer where the pointee was not captured: 1576 # 1577 # int* p = new int(7); 1578 # int** pp = &p; 1579 # 1580 # { // Captured variable 1581 # name: "pp", 1582 # value: "0x00500500", 1583 # type: "int**", 1584 # members { 1585 # value: "0x00400400", 1586 # type: "int*" 1587 # status { 1588 # is_error: true, 1589 # description: { format: "unavailable" } } 1590 # } 1591 # } 1592 # } 1593 # 1594 # To optimize computation, memory and network traffic, variables that 1595 # repeat in the output multiple times can be stored once in a shared 1596 # variable table and be referenced using the `var_table_index` field. The 1597 # variables stored in the shared table are nameless and are essentially 1598 # a partition of the complete variable. To reconstruct the complete 1599 # variable, merge the referencing variable with the referenced variable. 1600 # 1601 # When using the shared variable table, the following variables: 1602 # 1603 # T x = { 3, 7 }; 1604 # T* p = &x; 1605 # T& r = x; 1606 # 1607 # { name: "x", var_table_index: 3, type: "T" } // Captured variables 1608 # { name: "p", value "0x00500500", type="T*", var_table_index: 3 } 1609 # { name: "r", type="T&", var_table_index: 3 } 1610 # 1611 # { // Shared variable table entry #3: 1612 # members { name: "m1", value: "3", type: "int" }, 1613 # members { name: "m2", value: "7", type: "int" } 1614 # } 1615 # 1616 # Note that the pointer address is stored with the referencing variable 1617 # and not with the referenced variable. This allows the referenced variable 1618 # to be shared between pointers and references. 1619 # 1620 # The type field is optional. The debugger agent may or may not support it. 1621 "status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay 1622 # unset. A status of a single variable only applies to that variable or 1623 # expression. The rest of breakpoint data still remains valid. Variables 1624 # might be reported in error state even when breakpoint is not in final 1625 # state. 1626 # 1627 # The message may refer to variable name with `refers_to` set to 1628 # `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`. 1629 # In either case variable value and members will be unset. 1630 # 1631 # Example of error message applied to name: `Invalid expression syntax`. 1632 # 1633 # Example of information message applied to value: `Not captured`. 1634 # 1635 # Examples of error message applied to value: 1636 # 1637 # * `Malformed string`, 1638 # * `Field f not found in class C` 1639 # * `Null pointer dereference` 1640 # The message can indicate an error or informational status, and refer to 1641 # specific parts of the containing object. 1642 # For example, the `Breakpoint.status` field can indicate an error referring 1643 # to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`. 1644 "isError": True or False, # Distinguishes errors from informational messages. 1645 "refersTo": "A String", # Reference to which the message applies. 1646 "description": { # Represents a message with parameters. # Status message text. 1647 "parameters": [ # Optional parameters to be embedded into the message. 1648 "A String", 1649 ], 1650 "format": "A String", # Format template for the message. The `format` uses placeholders `$0`, 1651 # `$1`, etc. to reference parameters. `$$` can be used to denote the `$` 1652 # character. 1653 # 1654 # Examples: 1655 # 1656 # * `Failed to load '$0' which helps debug $1 the first time it 1657 # is loaded. Again, $0 is very important.` 1658 # * `Please pay $$10 to use $0 instead of $1.` 1659 }, 1660 }, 1661 "name": "A String", # Name of the variable, if any. 1662 "varTableIndex": 42, # Reference to a variable in the shared variable table. More than 1663 # one variable can reference the same variable in the table. The 1664 # `var_table_index` field is an index into `variable_table` in Breakpoint. 1665 "value": "A String", # Simple value of the variable. 1666 "members": [ # Members contained or pointed to by the variable. 1667 # Object with schema name: Variable 1668 ], 1669 "type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with 1670 # `var_table_index`, `type` goes next to `value`. The interpretation of 1671 # a type is agent specific. It is recommended to include the dynamic type 1672 # rather than a static type of an object. 1673 }, 1674 ], 1675 "id": "A String", # Breakpoint identifier, unique in the scope of the debuggee. 1676 "condition": "A String", # Condition that triggers the breakpoint. 1677 # The condition is a compound boolean expression composed using expressions 1678 # in a programming language at the source location. 1679 }, 1680 } 1681 1682 x__xgafv: string, V1 error format. 1683 Allowed values 1684 1 - v1 error format 1685 2 - v2 error format 1686 1687Returns: 1688 An object of the form: 1689 1690 { # Response for updating an active breakpoint. 1691 # The message is defined to allow future extensions. 1692 }</pre> 1693</div> 1694 1695</body></html>