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