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