Blame - docs/dyn/clouddebugger_v2.debugger.debuggees.breakpoints.html - platform/external/python/google-api-python-client

2015-09-11 13:55:40 -0700

[diff] [blame]

76

<h2>Instance Methods</h2>

77

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

78

<code><a href="#delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

79

<p class="firstline">Deletes the breakpoint from the debuggee.</p>

80

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

81

<code><a href="#get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

82

<p class="firstline">Gets breakpoint information.</p>

83

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

84

<code><a href="#list">list(debuggeeId, waitToken=None, clientVersion=None, action_value=None, includeAllUsers=None, includeInactive=None, stripResults=None, x__xgafv=None)</a></code></p>

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

85

<p class="firstline">Lists all breakpoints for the debuggee.</p>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

86

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

87

<code><a href="#set">set(debuggeeId, body=None, canaryOption=None, clientVersion=None, x__xgafv=None)</a></code></p>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

88

<p class="firstline">Sets the breakpoint to the debuggee.</p>

89

<h3>Method Details</h3>

90

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

91

<code class="details" id="delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

92

<pre>Deletes the breakpoint from the debuggee.

93

94

Args:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

95

debuggeeId: string, Required. ID of the debuggee whose breakpoint to delete. (required)

96

breakpointId: string, Required. ID of the breakpoint to delete. (required)

97

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

98

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

99

x__xgafv: string, V1 error format.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

100

Allowed values

101

1 - v1 error format

102

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

103

104

Returns:

105

An object of the form:

106

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

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 `{}`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

}</pre>

</div>

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

120

<code class="details" id="get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

121

<pre>Gets breakpoint information.

122

123

Args:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

124

debuggeeId: string, Required. ID of the debuggee whose breakpoint to get. (required)

125

breakpointId: string, Required. ID of the breakpoint to get. (required)

126

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

127

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

128

x__xgafv: string, V1 error format.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

129

Allowed values

130

1 - v1 error format

131

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

132

133

Returns:

134

An object of the form:

135

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

136

{ # Response for getting breakpoint information.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

137

"breakpoint": { # ------------------------------------------------------------------------------ # Complete breakpoint state.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

138

# The fields `id` and `location` are guaranteed to be set.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

139

# ## Breakpoint (the resource)

140

#

141

# Represents the breakpoint specification, status and results.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

142

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

143

# The expressions are composed using expressions in the programming language

144

# at the source location. If the breakpoint action is `LOG`, the evaluated

145

# expressions are included in log statements.

146

"A String",

147

],

148

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

149

# The evaluated expressions appear in exactly the same order they

150

# are listed in the `expressions` field.

151

# The `name` field holds the original expression text, the `value` or

152

# `members` field holds the result of the evaluated expression.

153

# If the expression cannot be evaluated, the `status` inside the `Variable`

154

# will indicate an error and contain the error text.

155

{ # Represents a variable or an argument possibly of a compound object type.

156

# Note how the following variables are represented:

157

#

158

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

163

#

164

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

173

# name: "x",

174

# type: "T",

175

# members { name: "m1", value: "3", type: "int" },

176

# members { name: "m2", value: "7", type: "int" }

177

# }

178

#

179

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

185

# name: "p",

186

# type: "T*",

187

# value: "0x00500500",

188

# members { name: "m1", value: "3", type: "int" },

189

# members { name: "m2", value: "7", type: "int" }

190

# }

191

#

192

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

197

# name: "p",

198

# type: "T*",

199

# value: "0x00400400"

200

# status { is_error: true, description { format: "unavailable" } }

201

# }

202

#

203

# The status should describe the reason for the missing value,

204

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

205

#

206

# Note that a null pointer should not have members.

207

#

208

# 5) An unnamed value:

209

#

210

# int* p = new int(7);

211

#

212

# { // Captured variable

213

# name: "p",

214

# value: "0x00500500",

215

# type: "int*",

216

# members { value: "7", type: "int" } }

217

#

218

# 6) An unnamed pointer where the pointee was not captured:

219

#

220

# int* p = new int(7);

221

# int** pp = &p;

222

#

223

# { // Captured variable

224

# name: "pp",

225

# value: "0x00500500",

226

# type: "int**",

227

# members {

228

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

238

# repeat in the output multiple times can be stored once in a shared

239

# variable table and be referenced using the `var_table_index` field. The

240

# variables stored in the shared table are nameless and are essentially

241

# a partition of the complete variable. To reconstruct the complete

242

# variable, merge the referencing variable with the referenced variable.

243

#

244

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

251

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

252

# { name: "r", type="T&", var_table_index: 3 }

253

#

254

# { // Shared variable table entry #3:

255

# members { name: "m1", value: "3", type: "int" },

256

# members { name: "m2", value: "7", type: "int" }

257

# }

258

#

259

# Note that the pointer address is stored with the referencing variable

260

# and not with the referenced variable. This allows the referenced variable

261

# to be shared between pointers and references.

262

#

263

# The type field is optional. The debugger agent may or may not support it.

264

"members": [ # Members contained or pointed to by the variable.

265

# Object with schema name: Variable

266

],

267

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

268

# unset. A status of a single variable only applies to that variable or

269

# expression. The rest of breakpoint data still remains valid. Variables

270

# might be reported in error state even when breakpoint is not in final

271

# state.

272

#

273

# The message may refer to variable name with `refers_to` set to

274

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

275

# In either case variable value and members will be unset.

276

#

277

# Example of error message applied to name: `Invalid expression syntax`.

278

#

279

# Example of information message applied to value: `Not captured`.

280

#

281

# Examples of error message applied to value:

282

#

283

# * `Malformed string`,

284

# * `Field f not found in class C`

285

# * `Null pointer dereference`

286

# The message can indicate an error or informational status, and refer to

287

# specific parts of the containing object.

288

# For example, the `Breakpoint.status` field can indicate an error referring

289

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

290

"isError": True or False, # Distinguishes errors from informational messages.

291

"description": { # Represents a message with parameters. # Status message text.

292

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

293

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

299

# is loaded. Again, $0 is very important.`

300

# * `Please pay $$10 to use $0 instead of $1.`

301

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

306

},

307

"name": "A String", # Name of the variable, if any.

308

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

309

# `var_table_index`, `type` goes next to `value`. The interpretation of

310

# a type is agent specific. It is recommended to include the dynamic type

311

# rather than a static type of an object.

312

"value": "A String", # Simple value of the variable.

313

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

314

# one variable can reference the same variable in the table. The

315

# `var_table_index` field is an index into `variable_table` in Breakpoint.

316

},

317

],

318

"isFinalState": True or False, # When true, indicates that this is a final result and the

319

# breakpoint state will not change from here on.

320

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

321

# recently entered function.

322

{ # Represents a stack frame context.

323

"locals": [ # Set of local variables at the stack frame location.

324

# Note that this might not be populated for all stack frames.

325

{ # Represents a variable or an argument possibly of a compound object type.

326

# Note how the following variables are represented:

327

#

328

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

333

#

334

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

343

# name: "x",

344

# type: "T",

345

# members { name: "m1", value: "3", type: "int" },

346

# members { name: "m2", value: "7", type: "int" }

347

# }

348

#

349

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

355

# name: "p",

356

# type: "T*",

357

# value: "0x00500500",

358

# members { name: "m1", value: "3", type: "int" },

359

# members { name: "m2", value: "7", type: "int" }

360

# }

361

#

362

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

367

# name: "p",

368

# type: "T*",

369

# value: "0x00400400"

370

# status { is_error: true, description { format: "unavailable" } }

371

# }

372

#

373

# The status should describe the reason for the missing value,

374

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

375

#

376

# Note that a null pointer should not have members.

377

#

378

# 5) An unnamed value:

379

#

380

# int* p = new int(7);

381

#

382

# { // Captured variable

383

# name: "p",

384

# value: "0x00500500",

385

# type: "int*",

386

# members { value: "7", type: "int" } }

387

#

388

# 6) An unnamed pointer where the pointee was not captured:

389

#

390

# int* p = new int(7);

391

# int** pp = &p;

392

#

393

# { // Captured variable

394

# name: "pp",

395

# value: "0x00500500",

396

# type: "int**",

397

# members {

398

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

408

# repeat in the output multiple times can be stored once in a shared

409

# variable table and be referenced using the `var_table_index` field. The

410

# variables stored in the shared table are nameless and are essentially

411

# a partition of the complete variable. To reconstruct the complete

412

# variable, merge the referencing variable with the referenced variable.

413

#

414

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

421

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

422

# { name: "r", type="T&", var_table_index: 3 }

423

#

424

# { // Shared variable table entry #3:

425

# members { name: "m1", value: "3", type: "int" },

426

# members { name: "m2", value: "7", type: "int" }

427

# }

428

#

429

# Note that the pointer address is stored with the referencing variable

430

# and not with the referenced variable. This allows the referenced variable

431

# to be shared between pointers and references.

432

#

433

# The type field is optional. The debugger agent may or may not support it.

434

"members": [ # Members contained or pointed to by the variable.

435

# Object with schema name: Variable

436

],

437

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

438

# unset. A status of a single variable only applies to that variable or

439

# expression. The rest of breakpoint data still remains valid. Variables

440

# might be reported in error state even when breakpoint is not in final

441

# state.

442

#

443

# The message may refer to variable name with `refers_to` set to

444

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

445

# In either case variable value and members will be unset.

446

#

447

# Example of error message applied to name: `Invalid expression syntax`.

448

#

449

# Example of information message applied to value: `Not captured`.

450

#

451

# Examples of error message applied to value:

452

#

453

# * `Malformed string`,

454

# * `Field f not found in class C`

455

# * `Null pointer dereference`

456

# The message can indicate an error or informational status, and refer to

457

# specific parts of the containing object.

458

# For example, the `Breakpoint.status` field can indicate an error referring

459

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

460

"isError": True or False, # Distinguishes errors from informational messages.

461

"description": { # Represents a message with parameters. # Status message text.

462

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

463

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

469

# is loaded. Again, $0 is very important.`

470

# * `Please pay $$10 to use $0 instead of $1.`

471

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

476

},

477

"name": "A String", # Name of the variable, if any.

478

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

479

# `var_table_index`, `type` goes next to `value`. The interpretation of

480

# a type is agent specific. It is recommended to include the dynamic type

481

# rather than a static type of an object.

482

"value": "A String", # Simple value of the variable.

483

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

484

# one variable can reference the same variable in the table. The

485

# `var_table_index` field is an index into `variable_table` in Breakpoint.

486

},

487

],

488

"location": { # Represents a location in the source code. # Source location of the call site.

489

"path": "A String", # Path to the source file within the source context of the target binary.

490

"column": 42, # Column within a line. The first column in a line as the value `1`.

491

# Agents that do not support setting breakpoints on specific columns ignore

492

# this field.

493

"line": 42, # Line inside the file. The first line in the file has the value `1`.

494

},

495

"function": "A String", # Demangled function name at the call site.

496

"arguments": [ # Set of arguments passed to this function.

497

# Note that this might not be populated for all stack frames.

498

{ # Represents a variable or an argument possibly of a compound object type.

499

# Note how the following variables are represented:

500

#

501

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

506

#

507

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

516

# name: "x",

517

# type: "T",

518

# members { name: "m1", value: "3", type: "int" },

519

# members { name: "m2", value: "7", type: "int" }

520

# }

521

#

522

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

528

# name: "p",

529

# type: "T*",

530

# value: "0x00500500",

531

# members { name: "m1", value: "3", type: "int" },

532

# members { name: "m2", value: "7", type: "int" }

533

# }

534

#

535

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

540

# name: "p",

541

# type: "T*",

542

# value: "0x00400400"

543

# status { is_error: true, description { format: "unavailable" } }

544

# }

545

#

546

# The status should describe the reason for the missing value,

547

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

548

#

549

# Note that a null pointer should not have members.

550

#

551

# 5) An unnamed value:

552

#

553

# int* p = new int(7);

554

#

555

# { // Captured variable

556

# name: "p",

557

# value: "0x00500500",

558

# type: "int*",

559

# members { value: "7", type: "int" } }

560

#

561

# 6) An unnamed pointer where the pointee was not captured:

562

#

563

# int* p = new int(7);

564

# int** pp = &p;

565

#

566

# { // Captured variable

567

# name: "pp",

568

# value: "0x00500500",

569

# type: "int**",

570

# members {

571

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

581

# repeat in the output multiple times can be stored once in a shared

582

# variable table and be referenced using the `var_table_index` field. The

583

# variables stored in the shared table are nameless and are essentially

584

# a partition of the complete variable. To reconstruct the complete

585

# variable, merge the referencing variable with the referenced variable.

586

#

587

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

594

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

595

# { name: "r", type="T&", var_table_index: 3 }

596

#

597

# { // Shared variable table entry #3:

598

# members { name: "m1", value: "3", type: "int" },

599

# members { name: "m2", value: "7", type: "int" }

600

# }

601

#

602

# Note that the pointer address is stored with the referencing variable

603

# and not with the referenced variable. This allows the referenced variable

604

# to be shared between pointers and references.

605

#

606

# The type field is optional. The debugger agent may or may not support it.

607

"members": [ # Members contained or pointed to by the variable.

608

# Object with schema name: Variable

609

],

610

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

611

# unset. A status of a single variable only applies to that variable or

612

# expression. The rest of breakpoint data still remains valid. Variables

613

# might be reported in error state even when breakpoint is not in final

614

# state.

615

#

616

# The message may refer to variable name with `refers_to` set to

617

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

618

# In either case variable value and members will be unset.

619

#

620

# Example of error message applied to name: `Invalid expression syntax`.

621

#

622

# Example of information message applied to value: `Not captured`.

623

#

624

# Examples of error message applied to value:

625

#

626

# * `Malformed string`,

627

# * `Field f not found in class C`

628

# * `Null pointer dereference`

629

# The message can indicate an error or informational status, and refer to

630

# specific parts of the containing object.

631

# For example, the `Breakpoint.status` field can indicate an error referring

632

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

633

"isError": True or False, # Distinguishes errors from informational messages.

634

"description": { # Represents a message with parameters. # Status message text.

635

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

636

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

642

# is loaded. Again, $0 is very important.`

643

# * `Please pay $$10 to use $0 instead of $1.`

644

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

649

},

650

"name": "A String", # Name of the variable, if any.

651

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

652

# `var_table_index`, `type` goes next to `value`. The interpretation of

653

# a type is agent specific. It is recommended to include the dynamic type

654

# rather than a static type of an object.

655

"value": "A String", # Simple value of the variable.

656

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

657

# one variable can reference the same variable in the table. The

658

# `var_table_index` field is an index into `variable_table` in Breakpoint.

},

],

},

],

"condition": "A String", # Condition that triggers the breakpoint.

664

# The condition is a compound boolean expression composed using expressions

665

# in a programming language at the source location.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

666

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

667

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

668

"status": { # Represents a contextual status message. # Breakpoint status.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

669

#

670

# The status includes an error flag and a human readable message.

671

# This field is usually unset. The message can be either

672

# informational or an error message. Regardless, clients should always

673

# display the text message back to the user.

674

#

675

# Error status indicates complete failure of the breakpoint.

676

#

677

# Example (non-final state): `Still loading symbols...`

678

#

679

# Examples (final state):

680

#

681

# * `Invalid line number` referring to location

682

# * `Field f not found in class C` referring to condition

683

# The message can indicate an error or informational status, and refer to

684

# specific parts of the containing object.

685

# For example, the `Breakpoint.status` field can indicate an error referring

686

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

687

"isError": True or False, # Distinguishes errors from informational messages.

688

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

689

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

690

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

695

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

696

# is loaded. Again, $0 is very important.`

697

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

698

"parameters": [ # Optional parameters to be embedded into the message.

699

"A String",

700

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

701

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

702

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

703

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

704

"state": "A String", # The current state of the breakpoint.

705

"userEmail": "A String", # E-mail address of the user that created this breakpoint

706

"action": "A String", # Action that the agent should perform when the code at the

707

# breakpoint location is hit.

708

"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.

709

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

710

"location": { # Represents a location in the source code. # Breakpoint source location.

711

"path": "A String", # Path to the source file within the source context of the target binary.

712

"column": 42, # Column within a line. The first column in a line as the value `1`.

713

# Agents that do not support setting breakpoints on specific columns ignore

714

# this field.

715

"line": 42, # Line inside the file. The first line in the file has the value `1`.

716

},

717

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

718

# resolution.

719

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

720

# traffic optimization. It enables storing a variable once and reference

721

# it from multiple variables, including variables stored in the

722

# `variable_table` itself.

723

# For example, the same `this` object, which may appear at many levels of

724

# the stack, can have all of its data stored once in this table. The

725

# stack frame variables then would hold only a reference to it.

726

#

727

# The variable `var_table_index` field is an index into this repeated field.

728

# The stored objects are nameless and get their name from the referencing

729

# variable. The effective variable is a merge of the referencing variable

730

# and the referenced variable.

731

{ # Represents a variable or an argument possibly of a compound object type.

732

# Note how the following variables are represented:

733

#

734

# 1) A simple variable:

735

#

736

# int x = 5

737

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

738

# { name: "x", value: "5", type: "int" } // Captured variable

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

739

#

740

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

749

# name: "x",

750

# type: "T",

751

# members { name: "m1", value: "3", type: "int" },

752

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

753

# }

754

#

755

# 3) A pointer where the pointee was captured:

756

#

757

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

758

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

759

#

760

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

761

# name: "p",

762

# type: "T*",

763

# value: "0x00500500",

764

# members { name: "m1", value: "3", type: "int" },

765

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

766

# }

767

#

768

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

773

# name: "p",

774

# type: "T*",

775

# value: "0x00400400"

776

# status { is_error: true, description { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

777

# }

778

#

779

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

780

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

781

#

782

# Note that a null pointer should not have members.

783

#

784

# 5) An unnamed value:

785

#

786

# int* p = new int(7);

787

#

788

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

789

# name: "p",

790

# value: "0x00500500",

791

# type: "int*",

792

# members { value: "7", type: "int" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

793

#

794

# 6) An unnamed pointer where the pointee was not captured:

795

#

796

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

797

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

798

#

799

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

800

# name: "pp",

801

# value: "0x00500500",

802

# type: "int**",

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

803

# members {

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

804

# value: "0x00400400",

805

# type: "int*"

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

806

# status {

807

# is_error: true,

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

808

# description: { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

814

# repeat in the output multiple times can be stored once in a shared

815

# variable table and be referenced using the `var_table_index` field. The

816

# variables stored in the shared table are nameless and are essentially

817

# a partition of the complete variable. To reconstruct the complete

818

# variable, merge the referencing variable with the referenced variable.

819

#

820

# When using the shared variable table, the following variables:

821

#

822

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

823

# T* p = &x;

824

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

825

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

826

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

827

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

828

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

829

#

830

# { // Shared variable table entry #3:

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

831

# members { name: "m1", value: "3", type: "int" },

832

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

833

# }

834

#

835

# Note that the pointer address is stored with the referencing variable

836

# and not with the referenced variable. This allows the referenced variable

837

# to be shared between pointers and references.

838

#

839

# The type field is optional. The debugger agent may or may not support it.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

840

"members": [ # Members contained or pointed to by the variable.

841

# Object with schema name: Variable

842

],

843

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

844

# unset. A status of a single variable only applies to that variable or

845

# expression. The rest of breakpoint data still remains valid. Variables

846

# might be reported in error state even when breakpoint is not in final

847

# state.

848

#

849

# The message may refer to variable name with `refers_to` set to

850

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

851

# In either case variable value and members will be unset.

852

#

853

# Example of error message applied to name: `Invalid expression syntax`.

854

#

855

# Example of information message applied to value: `Not captured`.

856

#

857

# Examples of error message applied to value:

858

#

859

# * `Malformed string`,

860

# * `Field f not found in class C`

861

# * `Null pointer dereference`

862

# The message can indicate an error or informational status, and refer to

863

# specific parts of the containing object.

864

# For example, the `Breakpoint.status` field can indicate an error referring

865

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

866

"isError": True or False, # Distinguishes errors from informational messages.

867

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

868

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

869

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

874

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

875

# is loaded. Again, $0 is very important.`

876

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

877

"parameters": [ # Optional parameters to be embedded into the message.

878

"A String",

879

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

880

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

881

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

882

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

883

"name": "A String", # Name of the variable, if any.

884

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

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.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

888

"value": "A String", # Simple value of the variable.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

889

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

890

# one variable can reference the same variable in the table. The

891

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

892

},

893

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

894

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

895

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

896

# the breakpoint hits. The message may include parameter placeholders `$0`,

897

# `$1`, etc. These placeholders are replaced with the evaluated value

898

# of the appropriate expression. Expressions not referenced in

899

# `log_message_format` are not logged.

900

#

901

# Example: `Message received, id = $0, count = $1` with

902

# `expressions` = `[ message.id, message.count ]`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

903

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

904

# displayed to the user.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

905

"a_key": "A String",

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

906

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

},

}</pre>

</div>

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

912

<code class="details" id="list">list(debuggeeId, waitToken=None, clientVersion=None, action_value=None, includeAllUsers=None, includeInactive=None, stripResults=None, x__xgafv=None)</code>

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

913

<pre>Lists all breakpoints for the debuggee.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

914

915

Args:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

916

debuggeeId: string, Required. ID of the debuggee whose breakpoints to list. (required)

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

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`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

922

clientVersion: string, Required. The client version making the call.

923

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

924

action_value: string, Only breakpoints with the specified action will pass the filter.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

925

includeAllUsers: boolean, When set to `true`, the response includes the list of breakpoints set by

926

any user. Otherwise, it includes only breakpoints set by the caller.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

927

includeInactive: boolean, When set to `true`, the response includes active and inactive

928

breakpoints. Otherwise, it includes only active breakpoints.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

929

stripResults: boolean, This field is deprecated. The following fields are always stripped out of

930

the result: `stack_frames`, `evaluated_expressions` and `variable_table`.

931

x__xgafv: string, V1 error format.

932

Allowed values

933

1 - v1 error format

934

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

935

936

Returns:

937

An object of the form:

938

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

939

{ # Response for listing breakpoints.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

940

"breakpoints": [ # List of breakpoints matching the request.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

941

# The fields `id` and `location` are guaranteed to be set on each breakpoint.

942

# The fields: `stack_frames`, `evaluated_expressions` and `variable_table`

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

943

# are cleared on each breakpoint regardless of its status.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

944

{ # ------------------------------------------------------------------------------

945

# ## Breakpoint (the resource)

946

#

947

# Represents the breakpoint specification, status and results.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

948

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

949

# The expressions are composed using expressions in the programming language

950

# at the source location. If the breakpoint action is `LOG`, the evaluated

951

# expressions are included in log statements.

952

"A String",

953

],

954

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

955

# The evaluated expressions appear in exactly the same order they

956

# are listed in the `expressions` field.

957

# The `name` field holds the original expression text, the `value` or

958

# `members` field holds the result of the evaluated expression.

959

# If the expression cannot be evaluated, the `status` inside the `Variable`

960

# will indicate an error and contain the error text.

961

{ # Represents a variable or an argument possibly of a compound object type.

962

# Note how the following variables are represented:

963

#

964

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

969

#

970

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

979

# name: "x",

980

# type: "T",

981

# members { name: "m1", value: "3", type: "int" },

982

# members { name: "m2", value: "7", type: "int" }

983

# }

984

#

985

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

991

# name: "p",

992

# type: "T*",

993

# value: "0x00500500",

994

# members { name: "m1", value: "3", type: "int" },

995

# members { name: "m2", value: "7", type: "int" }

996

# }

997

#

998

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

1003

# name: "p",

1004

# type: "T*",

1005

# value: "0x00400400"

1006

# status { is_error: true, description { format: "unavailable" } }

1007

# }

1008

#

1009

# The status should describe the reason for the missing value,

1010

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

1011

#

1012

# Note that a null pointer should not have members.

1013

#

1014

# 5) An unnamed value:

1015

#

1016

# int* p = new int(7);

1017

#

1018

# { // Captured variable

1019

# name: "p",

1020

# value: "0x00500500",

1021

# type: "int*",

1022

# members { value: "7", type: "int" } }

1023

#

1024

# 6) An unnamed pointer where the pointee was not captured:

1025

#

1026

# int* p = new int(7);

1027

# int** pp = &p;

1028

#

1029

# { // Captured variable

1030

# name: "pp",

1031

# value: "0x00500500",

1032

# type: "int**",

1033

# members {

1034

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1044

# repeat in the output multiple times can be stored once in a shared

1045

# variable table and be referenced using the `var_table_index` field. The

1046

# variables stored in the shared table are nameless and are essentially

1047

# a partition of the complete variable. To reconstruct the complete

1048

# variable, merge the referencing variable with the referenced variable.

1049

#

1050

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

1057

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

1058

# { name: "r", type="T&", var_table_index: 3 }

1059

#

1060

# { // Shared variable table entry #3:

1061

# members { name: "m1", value: "3", type: "int" },

1062

# members { name: "m2", value: "7", type: "int" }

1063

# }

1064

#

1065

# Note that the pointer address is stored with the referencing variable

1066

# and not with the referenced variable. This allows the referenced variable

1067

# to be shared between pointers and references.

1068

#

1069

# The type field is optional. The debugger agent may or may not support it.

1070

"members": [ # Members contained or pointed to by the variable.

1071

# Object with schema name: Variable

1072

],

1073

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

1074

# unset. A status of a single variable only applies to that variable or

1075

# expression. The rest of breakpoint data still remains valid. Variables

1076

# might be reported in error state even when breakpoint is not in final

1077

# state.

1078

#

1079

# The message may refer to variable name with `refers_to` set to

1080

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

1081

# In either case variable value and members will be unset.

1082

#

1083

# Example of error message applied to name: `Invalid expression syntax`.

1084

#

1085

# Example of information message applied to value: `Not captured`.

1086

#

1087

# Examples of error message applied to value:

1088

#

1089

# * `Malformed string`,

1090

# * `Field f not found in class C`

1091

# * `Null pointer dereference`

1092

# The message can indicate an error or informational status, and refer to

1093

# specific parts of the containing object.

1094

# For example, the `Breakpoint.status` field can indicate an error referring

1095

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

1096

"isError": True or False, # Distinguishes errors from informational messages.

1097

"description": { # Represents a message with parameters. # Status message text.

1098

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

1099

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

1105

# is loaded. Again, $0 is very important.`

1106

# * `Please pay $$10 to use $0 instead of $1.`

1107

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

1112

},

1113

"name": "A String", # Name of the variable, if any.

1114

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

1115

# `var_table_index`, `type` goes next to `value`. The interpretation of

1116

# a type is agent specific. It is recommended to include the dynamic type

1117

# rather than a static type of an object.

1118

"value": "A String", # Simple value of the variable.

1119

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

1120

# one variable can reference the same variable in the table. The

1121

# `var_table_index` field is an index into `variable_table` in Breakpoint.

1122

},

1123

],

1124

"isFinalState": True or False, # When true, indicates that this is a final result and the

1125

# breakpoint state will not change from here on.

1126

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

1127

# recently entered function.

1128

{ # Represents a stack frame context.

1129

"locals": [ # Set of local variables at the stack frame location.

1130

# Note that this might not be populated for all stack frames.

1131

{ # Represents a variable or an argument possibly of a compound object type.

1132

# Note how the following variables are represented:

1133

#

1134

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

1139

#

1140

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1149

# name: "x",

1150

# type: "T",

1151

# members { name: "m1", value: "3", type: "int" },

1152

# members { name: "m2", value: "7", type: "int" }

1153

# }

1154

#

1155

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1161

# name: "p",

1162

# type: "T*",

1163

# value: "0x00500500",

1164

# members { name: "m1", value: "3", type: "int" },

1165

# members { name: "m2", value: "7", type: "int" }

1166

# }

1167

#

1168

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

1173

# name: "p",

1174

# type: "T*",

1175

# value: "0x00400400"

1176

# status { is_error: true, description { format: "unavailable" } }

1177

# }

1178

#

1179

# The status should describe the reason for the missing value,

1180

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

1181

#

1182

# Note that a null pointer should not have members.

1183

#

1184

# 5) An unnamed value:

1185

#

1186

# int* p = new int(7);

1187

#

1188

# { // Captured variable

1189

# name: "p",

1190

# value: "0x00500500",

1191

# type: "int*",

1192

# members { value: "7", type: "int" } }

1193

#

1194

# 6) An unnamed pointer where the pointee was not captured:

1195

#

1196

# int* p = new int(7);

1197

# int** pp = &p;

1198

#

1199

# { // Captured variable

1200

# name: "pp",

1201

# value: "0x00500500",

1202

# type: "int**",

1203

# members {

1204

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1214

# repeat in the output multiple times can be stored once in a shared

1215

# variable table and be referenced using the `var_table_index` field. The

1216

# variables stored in the shared table are nameless and are essentially

1217

# a partition of the complete variable. To reconstruct the complete

1218

# variable, merge the referencing variable with the referenced variable.

1219

#

1220

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

1227

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

1228

# { name: "r", type="T&", var_table_index: 3 }

1229

#

1230

# { // Shared variable table entry #3:

1231

# members { name: "m1", value: "3", type: "int" },

1232

# members { name: "m2", value: "7", type: "int" }

1233

# }

1234

#

1235

# Note that the pointer address is stored with the referencing variable

1236

# and not with the referenced variable. This allows the referenced variable

1237

# to be shared between pointers and references.

1238

#

1239

# The type field is optional. The debugger agent may or may not support it.

1240

"members": [ # Members contained or pointed to by the variable.

1241

# Object with schema name: Variable

1242

],

1243

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

1244

# unset. A status of a single variable only applies to that variable or

1245

# expression. The rest of breakpoint data still remains valid. Variables

1246

# might be reported in error state even when breakpoint is not in final

1247

# state.

1248

#

1249

# The message may refer to variable name with `refers_to` set to

1250

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

1251

# In either case variable value and members will be unset.

1252

#

1253

# Example of error message applied to name: `Invalid expression syntax`.

1254

#

1255

# Example of information message applied to value: `Not captured`.

1256

#

1257

# Examples of error message applied to value:

1258

#

1259

# * `Malformed string`,

1260

# * `Field f not found in class C`

1261

# * `Null pointer dereference`

1262

# The message can indicate an error or informational status, and refer to

1263

# specific parts of the containing object.

1264

# For example, the `Breakpoint.status` field can indicate an error referring

1265

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

1266

"isError": True or False, # Distinguishes errors from informational messages.

1267

"description": { # Represents a message with parameters. # Status message text.

1268

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

1269

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

1275

# is loaded. Again, $0 is very important.`

1276

# * `Please pay $$10 to use $0 instead of $1.`

1277

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

1282

},

1283

"name": "A String", # Name of the variable, if any.

1284

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

1285

# `var_table_index`, `type` goes next to `value`. The interpretation of

1286

# a type is agent specific. It is recommended to include the dynamic type

1287

# rather than a static type of an object.

1288

"value": "A String", # Simple value of the variable.

1289

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

1290

# one variable can reference the same variable in the table. The

1291

# `var_table_index` field is an index into `variable_table` in Breakpoint.

1292

},

1293

],

1294

"location": { # Represents a location in the source code. # Source location of the call site.

1295

"path": "A String", # Path to the source file within the source context of the target binary.

1296

"column": 42, # Column within a line. The first column in a line as the value `1`.

1297

# Agents that do not support setting breakpoints on specific columns ignore

1298

# this field.

1299

"line": 42, # Line inside the file. The first line in the file has the value `1`.

1300

},

1301

"function": "A String", # Demangled function name at the call site.

1302

"arguments": [ # Set of arguments passed to this function.

1303

# Note that this might not be populated for all stack frames.

1304

{ # Represents a variable or an argument possibly of a compound object type.

1305

# Note how the following variables are represented:

1306

#

1307

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

1312

#

1313

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1322

# name: "x",

1323

# type: "T",

1324

# members { name: "m1", value: "3", type: "int" },

1325

# members { name: "m2", value: "7", type: "int" }

1326

# }

1327

#

1328

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1334

# name: "p",

1335

# type: "T*",

1336

# value: "0x00500500",

1337

# members { name: "m1", value: "3", type: "int" },

1338

# members { name: "m2", value: "7", type: "int" }

1339

# }

1340

#

1341

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

1346

# name: "p",

1347

# type: "T*",

1348

# value: "0x00400400"

1349

# status { is_error: true, description { format: "unavailable" } }

1350

# }

1351

#

1352

# The status should describe the reason for the missing value,

1353

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

1354

#

1355

# Note that a null pointer should not have members.

1356

#

1357

# 5) An unnamed value:

1358

#

1359

# int* p = new int(7);

1360

#

1361

# { // Captured variable

1362

# name: "p",

1363

# value: "0x00500500",

1364

# type: "int*",

1365

# members { value: "7", type: "int" } }

1366

#

1367

# 6) An unnamed pointer where the pointee was not captured:

1368

#

1369

# int* p = new int(7);

1370

# int** pp = &p;

1371

#

1372

# { // Captured variable

1373

# name: "pp",

1374

# value: "0x00500500",

1375

# type: "int**",

1376

# members {

1377

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1387

# repeat in the output multiple times can be stored once in a shared

1388

# variable table and be referenced using the `var_table_index` field. The

1389

# variables stored in the shared table are nameless and are essentially

1390

# a partition of the complete variable. To reconstruct the complete

1391

# variable, merge the referencing variable with the referenced variable.

1392

#

1393

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

1400

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

1401

# { name: "r", type="T&", var_table_index: 3 }

1402

#

1403

# { // Shared variable table entry #3:

1404

# members { name: "m1", value: "3", type: "int" },

1405

# members { name: "m2", value: "7", type: "int" }

1406

# }

1407

#

1408

# Note that the pointer address is stored with the referencing variable

1409

# and not with the referenced variable. This allows the referenced variable

1410

# to be shared between pointers and references.

1411

#

1412

# The type field is optional. The debugger agent may or may not support it.

1413

"members": [ # Members contained or pointed to by the variable.

1414

# Object with schema name: Variable

1415

],

1416

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

1417

# unset. A status of a single variable only applies to that variable or

1418

# expression. The rest of breakpoint data still remains valid. Variables

1419

# might be reported in error state even when breakpoint is not in final

1420

# state.

1421

#

1422

# The message may refer to variable name with `refers_to` set to

1423

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

1424

# In either case variable value and members will be unset.

1425

#

1426

# Example of error message applied to name: `Invalid expression syntax`.

1427

#

1428

# Example of information message applied to value: `Not captured`.

1429

#

1430

# Examples of error message applied to value:

1431

#

1432

# * `Malformed string`,

1433

# * `Field f not found in class C`

1434

# * `Null pointer dereference`

1435

# The message can indicate an error or informational status, and refer to

1436

# specific parts of the containing object.

1437

# For example, the `Breakpoint.status` field can indicate an error referring

1438

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

1439

"isError": True or False, # Distinguishes errors from informational messages.

1440

"description": { # Represents a message with parameters. # Status message text.

1441

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

1442

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

1448

# is loaded. Again, $0 is very important.`

1449

# * `Please pay $$10 to use $0 instead of $1.`

1450

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

1455

},

1456

"name": "A String", # Name of the variable, if any.

1457

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

1458

# `var_table_index`, `type` goes next to `value`. The interpretation of

1459

# a type is agent specific. It is recommended to include the dynamic type

1460

# rather than a static type of an object.

1461

"value": "A String", # Simple value of the variable.

1462

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

1463

# one variable can reference the same variable in the table. The

1464

# `var_table_index` field is an index into `variable_table` in Breakpoint.

},

],

},

],

"condition": "A String", # Condition that triggers the breakpoint.

1470

# The condition is a compound boolean expression composed using expressions

1471

# in a programming language at the source location.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1472

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

1473

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

1474

"status": { # Represents a contextual status message. # Breakpoint status.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1475

#

1476

# The status includes an error flag and a human readable message.

1477

# This field is usually unset. The message can be either

1478

# informational or an error message. Regardless, clients should always

1479

# display the text message back to the user.

1480

#

1481

# Error status indicates complete failure of the breakpoint.

1482

#

1483

# Example (non-final state): `Still loading symbols...`

1484

#

1485

# Examples (final state):

1486

#

1487

# * `Invalid line number` referring to location

1488

# * `Field f not found in class C` referring to condition

1489

# The message can indicate an error or informational status, and refer to

1490

# specific parts of the containing object.

1491

# For example, the `Breakpoint.status` field can indicate an error referring

1492

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1493

"isError": True or False, # Distinguishes errors from informational messages.

1494

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1495

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1496

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1501

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1502

# is loaded. Again, $0 is very important.`

1503

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

1504

"parameters": [ # Optional parameters to be embedded into the message.

1505

"A String",

1506

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1507

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1508

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1509

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1510

"state": "A String", # The current state of the breakpoint.

1511

"userEmail": "A String", # E-mail address of the user that created this breakpoint

1512

"action": "A String", # Action that the agent should perform when the code at the

1513

# breakpoint location is hit.

1514

"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.

1515

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

1516

"location": { # Represents a location in the source code. # Breakpoint source location.

1517

"path": "A String", # Path to the source file within the source context of the target binary.

1518

"column": 42, # Column within a line. The first column in a line as the value `1`.

1519

# Agents that do not support setting breakpoints on specific columns ignore

1520

# this field.

1521

"line": 42, # Line inside the file. The first line in the file has the value `1`.

1522

},

1523

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

1524

# resolution.

1525

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1526

# traffic optimization. It enables storing a variable once and reference

1527

# it from multiple variables, including variables stored in the

1528

# `variable_table` itself.

1529

# For example, the same `this` object, which may appear at many levels of

1530

# the stack, can have all of its data stored once in this table. The

1531

# stack frame variables then would hold only a reference to it.

1532

#

1533

# The variable `var_table_index` field is an index into this repeated field.

1534

# The stored objects are nameless and get their name from the referencing

1535

# variable. The effective variable is a merge of the referencing variable

1536

# and the referenced variable.

1537

{ # Represents a variable or an argument possibly of a compound object type.

1538

# Note how the following variables are represented:

1539

#

1540

# 1) A simple variable:

1541

#

1542

# int x = 5

1543

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1544

# { name: "x", value: "5", type: "int" } // Captured variable

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1545

#

1546

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1555

# name: "x",

1556

# type: "T",

1557

# members { name: "m1", value: "3", type: "int" },

1558

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1559

# }

1560

#

1561

# 3) A pointer where the pointee was captured:

1562

#

1563

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1564

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1565

#

1566

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1567

# name: "p",

1568

# type: "T*",

1569

# value: "0x00500500",

1570

# members { name: "m1", value: "3", type: "int" },

1571

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1572

# }

1573

#

1574

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1579

# name: "p",

1580

# type: "T*",

1581

# value: "0x00400400"

1582

# status { is_error: true, description { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1583

# }

1584

#

1585

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1586

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1587

#

1588

# Note that a null pointer should not have members.

1589

#

1590

# 5) An unnamed value:

1591

#

1592

# int* p = new int(7);

1593

#

1594

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1595

# name: "p",

1596

# value: "0x00500500",

1597

# type: "int*",

1598

# members { value: "7", type: "int" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1599

#

1600

# 6) An unnamed pointer where the pointee was not captured:

1601

#

1602

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1603

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1604

#

1605

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1606

# name: "pp",

1607

# value: "0x00500500",

1608

# type: "int**",

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1609

# members {

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1610

# value: "0x00400400",

1611

# type: "int*"

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1612

# status {

1613

# is_error: true,

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1614

# description: { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1620

# repeat in the output multiple times can be stored once in a shared

1621

# variable table and be referenced using the `var_table_index` field. The

1622

# variables stored in the shared table are nameless and are essentially

1623

# a partition of the complete variable. To reconstruct the complete

1624

# variable, merge the referencing variable with the referenced variable.

1625

#

1626

# When using the shared variable table, the following variables:

1627

#

1628

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1629

# T* p = &x;

1630

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1631

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1632

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

1633

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

1634

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1635

#

1636

# { // Shared variable table entry #3:

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1637

# members { name: "m1", value: "3", type: "int" },

1638

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1639

# }

1640

#

1641

# Note that the pointer address is stored with the referencing variable

1642

# and not with the referenced variable. This allows the referenced variable

1643

# to be shared between pointers and references.

1644

#

1645

# The type field is optional. The debugger agent may or may not support it.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1646

"members": [ # Members contained or pointed to by the variable.

1647

# Object with schema name: Variable

1648

],

1649

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1650

# unset. A status of a single variable only applies to that variable or

1651

# expression. The rest of breakpoint data still remains valid. Variables

1652

# might be reported in error state even when breakpoint is not in final

1653

# state.

1654

#

1655

# The message may refer to variable name with `refers_to` set to

1656

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

1657

# In either case variable value and members will be unset.

1658

#

1659

# Example of error message applied to name: `Invalid expression syntax`.

1660

#

1661

# Example of information message applied to value: `Not captured`.

1662

#

1663

# Examples of error message applied to value:

1664

#

1665

# * `Malformed string`,

1666

# * `Field f not found in class C`

1667

# * `Null pointer dereference`

1668

# The message can indicate an error or informational status, and refer to

1669

# specific parts of the containing object.

1670

# For example, the `Breakpoint.status` field can indicate an error referring

1671

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1672

"isError": True or False, # Distinguishes errors from informational messages.

1673

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1674

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1675

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1680

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1681

# is loaded. Again, $0 is very important.`

1682

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

1683

"parameters": [ # Optional parameters to be embedded into the message.

1684

"A String",

1685

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1686

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1687

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1688

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1689

"name": "A String", # Name of the variable, if any.

1690

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1691

# `var_table_index`, `type` goes next to `value`. The interpretation of

1692

# a type is agent specific. It is recommended to include the dynamic type

1693

# rather than a static type of an object.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

1694

"value": "A String", # Simple value of the variable.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1695

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

1696

# one variable can reference the same variable in the table. The

1697

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1698

},

1699

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1700

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

1701

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

1702

# the breakpoint hits. The message may include parameter placeholders `$0`,

1703

# `$1`, etc. These placeholders are replaced with the evaluated value

1704

# of the appropriate expression. Expressions not referenced in

1705

# `log_message_format` are not logged.

1706

#

1707

# Example: `Message received, id = $0, count = $1` with

1708

# `expressions` = `[ message.id, message.count ]`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1709

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1710

# displayed to the user.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1711

"a_key": "A String",

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

1712

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1713

},

1714

],

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

1715

"nextWaitToken": "A String", # A wait token that can be used in the next call to `list` (REST) or

1716

# `ListBreakpoints` (RPC) to block until the list of breakpoints has changes.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

}</pre>

</div>

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1721

<code class="details" id="set">set(debuggeeId, body=None, canaryOption=None, clientVersion=None, x__xgafv=None)</code>

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1722

<pre>Sets the breakpoint to the debuggee.

1723

1724

Args:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1725

debuggeeId: string, Required. ID of the debuggee where the breakpoint is to be set. (required)

1726

body: object, The request body.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1727

The object takes the form of:

1728

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1729

{ # ------------------------------------------------------------------------------

1730

# ## Breakpoint (the resource)

1731

#

1732

# Represents the breakpoint specification, status and results.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

1733

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

1734

# The expressions are composed using expressions in the programming language

1735

# at the source location. If the breakpoint action is `LOG`, the evaluated

1736

# expressions are included in log statements.

1737

"A String",

1738

],

1739

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

1740

# The evaluated expressions appear in exactly the same order they

1741

# are listed in the `expressions` field.

1742

# The `name` field holds the original expression text, the `value` or

1743

# `members` field holds the result of the evaluated expression.

1744

# If the expression cannot be evaluated, the `status` inside the `Variable`

1745

# will indicate an error and contain the error text.

1746

{ # Represents a variable or an argument possibly of a compound object type.

1747

# Note how the following variables are represented:

1748

#

1749

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

1754

#

1755

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1764

# name: "x",

1765

# type: "T",

1766

# members { name: "m1", value: "3", type: "int" },

1767

# members { name: "m2", value: "7", type: "int" }

1768

# }

1769

#

1770

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1776

# name: "p",

1777

# type: "T*",

1778

# value: "0x00500500",

1779

# members { name: "m1", value: "3", type: "int" },

1780

# members { name: "m2", value: "7", type: "int" }

1781

# }

1782

#

1783

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

1788

# name: "p",

1789

# type: "T*",

1790

# value: "0x00400400"

1791

# status { is_error: true, description { format: "unavailable" } }

1792

# }

1793

#

1794

# The status should describe the reason for the missing value,

1795

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

1796

#

1797

# Note that a null pointer should not have members.

1798

#

1799

# 5) An unnamed value:

1800

#

1801

# int* p = new int(7);

1802

#

1803

# { // Captured variable

1804

# name: "p",

1805

# value: "0x00500500",

1806

# type: "int*",

1807

# members { value: "7", type: "int" } }

1808

#

1809

# 6) An unnamed pointer where the pointee was not captured:

1810

#

1811

# int* p = new int(7);

1812

# int** pp = &p;

1813

#

1814

# { // Captured variable

1815

# name: "pp",

1816

# value: "0x00500500",

1817

# type: "int**",

1818

# members {

1819

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1829

# repeat in the output multiple times can be stored once in a shared

1830

# variable table and be referenced using the `var_table_index` field. The

1831

# variables stored in the shared table are nameless and are essentially

1832

# a partition of the complete variable. To reconstruct the complete

1833

# variable, merge the referencing variable with the referenced variable.

1834

#

1835

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

1842

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

1843

# { name: "r", type="T&", var_table_index: 3 }

1844

#

1845

# { // Shared variable table entry #3:

1846

# members { name: "m1", value: "3", type: "int" },

1847

# members { name: "m2", value: "7", type: "int" }

1848

# }

1849

#

1850

# Note that the pointer address is stored with the referencing variable

1851

# and not with the referenced variable. This allows the referenced variable

1852

# to be shared between pointers and references.

1853

#

1854

# The type field is optional. The debugger agent may or may not support it.

1855

"members": [ # Members contained or pointed to by the variable.

1856

# Object with schema name: Variable

1857

],

1858

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

1859

# unset. A status of a single variable only applies to that variable or

1860

# expression. The rest of breakpoint data still remains valid. Variables

1861

# might be reported in error state even when breakpoint is not in final

1862

# state.

1863

#

1864

# The message may refer to variable name with `refers_to` set to

1865

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

1866

# In either case variable value and members will be unset.

1867

#

1868

# Example of error message applied to name: `Invalid expression syntax`.

1869

#

1870

# Example of information message applied to value: `Not captured`.

1871

#

1872

# Examples of error message applied to value:

1873

#

1874

# * `Malformed string`,

1875

# * `Field f not found in class C`

1876

# * `Null pointer dereference`

1877

# The message can indicate an error or informational status, and refer to

1878

# specific parts of the containing object.

1879

# For example, the `Breakpoint.status` field can indicate an error referring

1880

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

1881

"isError": True or False, # Distinguishes errors from informational messages.

1882

"description": { # Represents a message with parameters. # Status message text.

1883

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

1884

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

1890

# is loaded. Again, $0 is very important.`

1891

# * `Please pay $$10 to use $0 instead of $1.`

1892

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

1897

},

1898

"name": "A String", # Name of the variable, if any.

1899

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

1900

# `var_table_index`, `type` goes next to `value`. The interpretation of

1901

# a type is agent specific. It is recommended to include the dynamic type

1902

# rather than a static type of an object.

1903

"value": "A String", # Simple value of the variable.

1904

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

1905

# one variable can reference the same variable in the table. The

1906

# `var_table_index` field is an index into `variable_table` in Breakpoint.

1907

},

1908

],

1909

"isFinalState": True or False, # When true, indicates that this is a final result and the

1910

# breakpoint state will not change from here on.

1911

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

1912

# recently entered function.

1913

{ # Represents a stack frame context.

1914

"locals": [ # Set of local variables at the stack frame location.

1915

# Note that this might not be populated for all stack frames.

1916

{ # Represents a variable or an argument possibly of a compound object type.

1917

# Note how the following variables are represented:

1918

#

1919

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

1924

#

1925

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1934

# name: "x",

1935

# type: "T",

1936

# members { name: "m1", value: "3", type: "int" },

1937

# members { name: "m2", value: "7", type: "int" }

1938

# }

1939

#

1940

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1946

# name: "p",

1947

# type: "T*",

1948

# value: "0x00500500",

1949

# members { name: "m1", value: "3", type: "int" },

1950

# members { name: "m2", value: "7", type: "int" }

1951

# }

1952

#

1953

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

1958

# name: "p",

1959

# type: "T*",

1960

# value: "0x00400400"

1961

# status { is_error: true, description { format: "unavailable" } }

1962

# }

1963

#

1964

# The status should describe the reason for the missing value,

1965

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

1966

#

1967

# Note that a null pointer should not have members.

1968

#

1969

# 5) An unnamed value:

1970

#

1971

# int* p = new int(7);

1972

#

1973

# { // Captured variable

1974

# name: "p",

1975

# value: "0x00500500",

1976

# type: "int*",

1977

# members { value: "7", type: "int" } }

1978

#

1979

# 6) An unnamed pointer where the pointee was not captured:

1980

#

1981

# int* p = new int(7);

1982

# int** pp = &p;

1983

#

1984

# { // Captured variable

1985

# name: "pp",

1986

# value: "0x00500500",

1987

# type: "int**",

1988

# members {

1989

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1999

# repeat in the output multiple times can be stored once in a shared

2000

# variable table and be referenced using the `var_table_index` field. The

2001

# variables stored in the shared table are nameless and are essentially

2002

# a partition of the complete variable. To reconstruct the complete

2003

# variable, merge the referencing variable with the referenced variable.

2004

#

2005

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2012

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2013

# { name: "r", type="T&", var_table_index: 3 }

2014

#

2015

# { // Shared variable table entry #3:

2016

# members { name: "m1", value: "3", type: "int" },

2017

# members { name: "m2", value: "7", type: "int" }

2018

# }

2019

#

2020

# Note that the pointer address is stored with the referencing variable

2021

# and not with the referenced variable. This allows the referenced variable

2022

# to be shared between pointers and references.

2023

#

2024

# The type field is optional. The debugger agent may or may not support it.

2025

"members": [ # Members contained or pointed to by the variable.

2026

# Object with schema name: Variable

2027

],

2028

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2029

# unset. A status of a single variable only applies to that variable or

2030

# expression. The rest of breakpoint data still remains valid. Variables

2031

# might be reported in error state even when breakpoint is not in final

2032

# state.

2033

#

2034

# The message may refer to variable name with `refers_to` set to

2035

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2036

# In either case variable value and members will be unset.

2037

#

2038

# Example of error message applied to name: `Invalid expression syntax`.

2039

#

2040

# Example of information message applied to value: `Not captured`.

2041

#

2042

# Examples of error message applied to value:

2043

#

2044

# * `Malformed string`,

2045

# * `Field f not found in class C`

2046

# * `Null pointer dereference`

2047

# The message can indicate an error or informational status, and refer to

2048

# specific parts of the containing object.

2049

# For example, the `Breakpoint.status` field can indicate an error referring

2050

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2051

"isError": True or False, # Distinguishes errors from informational messages.

2052

"description": { # Represents a message with parameters. # Status message text.

2053

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2054

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2060

# is loaded. Again, $0 is very important.`

2061

# * `Please pay $$10 to use $0 instead of $1.`

2062

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

2067

},

2068

"name": "A String", # Name of the variable, if any.

2069

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2070

# `var_table_index`, `type` goes next to `value`. The interpretation of

2071

# a type is agent specific. It is recommended to include the dynamic type

2072

# rather than a static type of an object.

2073

"value": "A String", # Simple value of the variable.

2074

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2075

# one variable can reference the same variable in the table. The

2076

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2077

},

2078

],

2079

"location": { # Represents a location in the source code. # Source location of the call site.

2080

"path": "A String", # Path to the source file within the source context of the target binary.

2081

"column": 42, # Column within a line. The first column in a line as the value `1`.

2082

# Agents that do not support setting breakpoints on specific columns ignore

2083

# this field.

2084

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2085

},

2086

"function": "A String", # Demangled function name at the call site.

2087

"arguments": [ # Set of arguments passed to this function.

2088

# Note that this might not be populated for all stack frames.

2089

{ # Represents a variable or an argument possibly of a compound object type.

2090

# Note how the following variables are represented:

2091

#

2092

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2097

#

2098

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2107

# name: "x",

2108

# type: "T",

2109

# members { name: "m1", value: "3", type: "int" },

2110

# members { name: "m2", value: "7", type: "int" }

2111

# }

2112

#

2113

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2119

# name: "p",

2120

# type: "T*",

2121

# value: "0x00500500",

2122

# members { name: "m1", value: "3", type: "int" },

2123

# members { name: "m2", value: "7", type: "int" }

2124

# }

2125

#

2126

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2131

# name: "p",

2132

# type: "T*",

2133

# value: "0x00400400"

2134

# status { is_error: true, description { format: "unavailable" } }

2135

# }

2136

#

2137

# The status should describe the reason for the missing value,

2138

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2139

#

2140

# Note that a null pointer should not have members.

2141

#

2142

# 5) An unnamed value:

2143

#

2144

# int* p = new int(7);

2145

#

2146

# { // Captured variable

2147

# name: "p",

2148

# value: "0x00500500",

2149

# type: "int*",

2150

# members { value: "7", type: "int" } }

2151

#

2152

# 6) An unnamed pointer where the pointee was not captured:

2153

#

2154

# int* p = new int(7);

2155

# int** pp = &p;

2156

#

2157

# { // Captured variable

2158

# name: "pp",

2159

# value: "0x00500500",

2160

# type: "int**",

2161

# members {

2162

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2172

# repeat in the output multiple times can be stored once in a shared

2173

# variable table and be referenced using the `var_table_index` field. The

2174

# variables stored in the shared table are nameless and are essentially

2175

# a partition of the complete variable. To reconstruct the complete

2176

# variable, merge the referencing variable with the referenced variable.

2177

#

2178

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2185

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2186

# { name: "r", type="T&", var_table_index: 3 }

2187

#

2188

# { // Shared variable table entry #3:

2189

# members { name: "m1", value: "3", type: "int" },

2190

# members { name: "m2", value: "7", type: "int" }

2191

# }

2192

#

2193

# Note that the pointer address is stored with the referencing variable

2194

# and not with the referenced variable. This allows the referenced variable

2195

# to be shared between pointers and references.

2196

#

2197

# The type field is optional. The debugger agent may or may not support it.

2198

"members": [ # Members contained or pointed to by the variable.

2199

# Object with schema name: Variable

2200

],

2201

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2202

# unset. A status of a single variable only applies to that variable or

2203

# expression. The rest of breakpoint data still remains valid. Variables

2204

# might be reported in error state even when breakpoint is not in final

2205

# state.

2206

#

2207

# The message may refer to variable name with `refers_to` set to

2208

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2209

# In either case variable value and members will be unset.

2210

#

2211

# Example of error message applied to name: `Invalid expression syntax`.

2212

#

2213

# Example of information message applied to value: `Not captured`.

2214

#

2215

# Examples of error message applied to value:

2216

#

2217

# * `Malformed string`,

2218

# * `Field f not found in class C`

2219

# * `Null pointer dereference`

2220

# The message can indicate an error or informational status, and refer to

2221

# specific parts of the containing object.

2222

# For example, the `Breakpoint.status` field can indicate an error referring

2223

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2224

"isError": True or False, # Distinguishes errors from informational messages.

2225

"description": { # Represents a message with parameters. # Status message text.

2226

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2227

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2233

# is loaded. Again, $0 is very important.`

2234

# * `Please pay $$10 to use $0 instead of $1.`

2235

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

2240

},

2241

"name": "A String", # Name of the variable, if any.

2242

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2243

# `var_table_index`, `type` goes next to `value`. The interpretation of

2244

# a type is agent specific. It is recommended to include the dynamic type

2245

# rather than a static type of an object.

2246

"value": "A String", # Simple value of the variable.

2247

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2248

# one variable can reference the same variable in the table. The

2249

# `var_table_index` field is an index into `variable_table` in Breakpoint.

},

],

},

],

"condition": "A String", # Condition that triggers the breakpoint.

2255

# The condition is a compound boolean expression composed using expressions

2256

# in a programming language at the source location.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2257

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

2258

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

2259

"status": { # Represents a contextual status message. # Breakpoint status.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2260

#

2261

# The status includes an error flag and a human readable message.

2262

# This field is usually unset. The message can be either

2263

# informational or an error message. Regardless, clients should always

2264

# display the text message back to the user.

2265

#

2266

# Error status indicates complete failure of the breakpoint.

2267

#

2268

# Example (non-final state): `Still loading symbols...`

2269

#

2270

# Examples (final state):

2271

#

2272

# * `Invalid line number` referring to location

2273

# * `Field f not found in class C` referring to condition

2274

# The message can indicate an error or informational status, and refer to

2275

# specific parts of the containing object.

2276

# For example, the `Breakpoint.status` field can indicate an error referring

2277

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2278

"isError": True or False, # Distinguishes errors from informational messages.

2279

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2280

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2281

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2286

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2287

# is loaded. Again, $0 is very important.`

2288

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

2289

"parameters": [ # Optional parameters to be embedded into the message.

2290

"A String",

2291

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2292

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2293

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2294

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2295

"state": "A String", # The current state of the breakpoint.

2296

"userEmail": "A String", # E-mail address of the user that created this breakpoint

2297

"action": "A String", # Action that the agent should perform when the code at the

2298

# breakpoint location is hit.

2299

"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.

2300

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

2301

"location": { # Represents a location in the source code. # Breakpoint source location.

2302

"path": "A String", # Path to the source file within the source context of the target binary.

2303

"column": 42, # Column within a line. The first column in a line as the value `1`.

2304

# Agents that do not support setting breakpoints on specific columns ignore

2305

# this field.

2306

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2307

},

2308

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

2309

# resolution.

2310

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2311

# traffic optimization. It enables storing a variable once and reference

2312

# it from multiple variables, including variables stored in the

2313

# `variable_table` itself.

2314

# For example, the same `this` object, which may appear at many levels of

2315

# the stack, can have all of its data stored once in this table. The

2316

# stack frame variables then would hold only a reference to it.

2317

#

2318

# The variable `var_table_index` field is an index into this repeated field.

2319

# The stored objects are nameless and get their name from the referencing

2320

# variable. The effective variable is a merge of the referencing variable

2321

# and the referenced variable.

2322

{ # Represents a variable or an argument possibly of a compound object type.

2323

# Note how the following variables are represented:

2324

#

2325

# 1) A simple variable:

2326

#

2327

# int x = 5

2328

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2329

# { name: "x", value: "5", type: "int" } // Captured variable

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2330

#

2331

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2340

# name: "x",

2341

# type: "T",

2342

# members { name: "m1", value: "3", type: "int" },

2343

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2344

# }

2345

#

2346

# 3) A pointer where the pointee was captured:

2347

#

2348

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2349

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2350

#

2351

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2352

# name: "p",

2353

# type: "T*",

2354

# value: "0x00500500",

2355

# members { name: "m1", value: "3", type: "int" },

2356

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2357

# }

2358

#

2359

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2364

# name: "p",

2365

# type: "T*",

2366

# value: "0x00400400"

2367

# status { is_error: true, description { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2368

# }

2369

#

2370

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2371

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2372

#

2373

# Note that a null pointer should not have members.

2374

#

2375

# 5) An unnamed value:

2376

#

2377

# int* p = new int(7);

2378

#

2379

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2380

# name: "p",

2381

# value: "0x00500500",

2382

# type: "int*",

2383

# members { value: "7", type: "int" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2384

#

2385

# 6) An unnamed pointer where the pointee was not captured:

2386

#

2387

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2388

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2389

#

2390

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2391

# name: "pp",

2392

# value: "0x00500500",

2393

# type: "int**",

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2394

# members {

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2395

# value: "0x00400400",

2396

# type: "int*"

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2397

# status {

2398

# is_error: true,

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2399

# description: { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2405

# repeat in the output multiple times can be stored once in a shared

2406

# variable table and be referenced using the `var_table_index` field. The

2407

# variables stored in the shared table are nameless and are essentially

2408

# a partition of the complete variable. To reconstruct the complete

2409

# variable, merge the referencing variable with the referenced variable.

2410

#

2411

# When using the shared variable table, the following variables:

2412

#

2413

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2414

# T* p = &x;

2415

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2416

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2417

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2418

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2419

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2420

#

2421

# { // Shared variable table entry #3:

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2422

# members { name: "m1", value: "3", type: "int" },

2423

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2424

# }

2425

#

2426

# Note that the pointer address is stored with the referencing variable

2427

# and not with the referenced variable. This allows the referenced variable

2428

# to be shared between pointers and references.

2429

#

2430

# The type field is optional. The debugger agent may or may not support it.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2431

"members": [ # Members contained or pointed to by the variable.

2432

# Object with schema name: Variable

2433

],

2434

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2435

# unset. A status of a single variable only applies to that variable or

2436

# expression. The rest of breakpoint data still remains valid. Variables

2437

# might be reported in error state even when breakpoint is not in final

2438

# state.

2439

#

2440

# The message may refer to variable name with `refers_to` set to

2441

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2442

# In either case variable value and members will be unset.

2443

#

2444

# Example of error message applied to name: `Invalid expression syntax`.

2445

#

2446

# Example of information message applied to value: `Not captured`.

2447

#

2448

# Examples of error message applied to value:

2449

#

2450

# * `Malformed string`,

2451

# * `Field f not found in class C`

2452

# * `Null pointer dereference`

2453

# The message can indicate an error or informational status, and refer to

2454

# specific parts of the containing object.

2455

# For example, the `Breakpoint.status` field can indicate an error referring

2456

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2457

"isError": True or False, # Distinguishes errors from informational messages.

2458

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2459

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2460

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2465

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2466

# is loaded. Again, $0 is very important.`

2467

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

2468

"parameters": [ # Optional parameters to be embedded into the message.

2469

"A String",

2470

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2471

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2472

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2473

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2474

"name": "A String", # Name of the variable, if any.

2475

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2476

# `var_table_index`, `type` goes next to `value`. The interpretation of

2477

# a type is agent specific. It is recommended to include the dynamic type

2478

# rather than a static type of an object.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

2479

"value": "A String", # Simple value of the variable.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2480

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2481

# one variable can reference the same variable in the table. The

2482

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2483

},

2484

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2485

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

2486

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

2487

# the breakpoint hits. The message may include parameter placeholders `$0`,

2488

# `$1`, etc. These placeholders are replaced with the evaluated value

2489

# of the appropriate expression. Expressions not referenced in

2490

# `log_message_format` are not logged.

2491

#

2492

# Example: `Message received, id = $0, count = $1` with

2493

# `expressions` = `[ message.id, message.count ]`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2494

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2495

# displayed to the user.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2496

"a_key": "A String",

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

2497

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2498

}

2499

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2500

canaryOption: string, The canary option set by the user upon setting breakpoint.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2501

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

2502

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2503

x__xgafv: string, V1 error format.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2504

Allowed values

2505

1 - v1 error format

2506

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2507

2508

Returns:

2509

An object of the form:

2510

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2511

{ # Response for setting a breakpoint.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

2512

"breakpoint": { # ------------------------------------------------------------------------------ # Breakpoint resource.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2513

# The field `id` is guaranteed to be set (in addition to the echoed fields).

2514

# ## Breakpoint (the resource)

2515

#

2516

# Represents the breakpoint specification, status and results.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

2517

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

2518

# The expressions are composed using expressions in the programming language

2519

# at the source location. If the breakpoint action is `LOG`, the evaluated

2520

# expressions are included in log statements.

2521

"A String",

2522

],

2523

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

2524

# The evaluated expressions appear in exactly the same order they

2525

# are listed in the `expressions` field.

2526

# The `name` field holds the original expression text, the `value` or

2527

# `members` field holds the result of the evaluated expression.

2528

# If the expression cannot be evaluated, the `status` inside the `Variable`

2529

# will indicate an error and contain the error text.

2530

{ # Represents a variable or an argument possibly of a compound object type.

2531

# Note how the following variables are represented:

2532

#

2533

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2538

#

2539

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2548

# name: "x",

2549

# type: "T",

2550

# members { name: "m1", value: "3", type: "int" },

2551

# members { name: "m2", value: "7", type: "int" }

2552

# }

2553

#

2554

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2560

# name: "p",

2561

# type: "T*",

2562

# value: "0x00500500",

2563

# members { name: "m1", value: "3", type: "int" },

2564

# members { name: "m2", value: "7", type: "int" }

2565

# }

2566

#

2567

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2572

# name: "p",

2573

# type: "T*",

2574

# value: "0x00400400"

2575

# status { is_error: true, description { format: "unavailable" } }

2576

# }

2577

#

2578

# The status should describe the reason for the missing value,

2579

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2580

#

2581

# Note that a null pointer should not have members.

2582

#

2583

# 5) An unnamed value:

2584

#

2585

# int* p = new int(7);

2586

#

2587

# { // Captured variable

2588

# name: "p",

2589

# value: "0x00500500",

2590

# type: "int*",

2591

# members { value: "7", type: "int" } }

2592

#

2593

# 6) An unnamed pointer where the pointee was not captured:

2594

#

2595

# int* p = new int(7);

2596

# int** pp = &p;

2597

#

2598

# { // Captured variable

2599

# name: "pp",

2600

# value: "0x00500500",

2601

# type: "int**",

2602

# members {

2603

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2613

# repeat in the output multiple times can be stored once in a shared

2614

# variable table and be referenced using the `var_table_index` field. The

2615

# variables stored in the shared table are nameless and are essentially

2616

# a partition of the complete variable. To reconstruct the complete

2617

# variable, merge the referencing variable with the referenced variable.

2618

#

2619

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2626

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2627

# { name: "r", type="T&", var_table_index: 3 }

2628

#

2629

# { // Shared variable table entry #3:

2630

# members { name: "m1", value: "3", type: "int" },

2631

# members { name: "m2", value: "7", type: "int" }

2632

# }

2633

#

2634

# Note that the pointer address is stored with the referencing variable

2635

# and not with the referenced variable. This allows the referenced variable

2636

# to be shared between pointers and references.

2637

#

2638

# The type field is optional. The debugger agent may or may not support it.

2639

"members": [ # Members contained or pointed to by the variable.

2640

# Object with schema name: Variable

2641

],

2642

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2643

# unset. A status of a single variable only applies to that variable or

2644

# expression. The rest of breakpoint data still remains valid. Variables

2645

# might be reported in error state even when breakpoint is not in final

2646

# state.

2647

#

2648

# The message may refer to variable name with `refers_to` set to

2649

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2650

# In either case variable value and members will be unset.

2651

#

2652

# Example of error message applied to name: `Invalid expression syntax`.

2653

#

2654

# Example of information message applied to value: `Not captured`.

2655

#

2656

# Examples of error message applied to value:

2657

#

2658

# * `Malformed string`,

2659

# * `Field f not found in class C`

2660

# * `Null pointer dereference`

2661

# The message can indicate an error or informational status, and refer to

2662

# specific parts of the containing object.

2663

# For example, the `Breakpoint.status` field can indicate an error referring

2664

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2665

"isError": True or False, # Distinguishes errors from informational messages.

2666

"description": { # Represents a message with parameters. # Status message text.

2667

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2668

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2674

# is loaded. Again, $0 is very important.`

2675

# * `Please pay $$10 to use $0 instead of $1.`

2676

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

2681

},

2682

"name": "A String", # Name of the variable, if any.

2683

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2684

# `var_table_index`, `type` goes next to `value`. The interpretation of

2685

# a type is agent specific. It is recommended to include the dynamic type

2686

# rather than a static type of an object.

2687

"value": "A String", # Simple value of the variable.

2688

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2689

# one variable can reference the same variable in the table. The

2690

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2691

},

2692

],

2693

"isFinalState": True or False, # When true, indicates that this is a final result and the

2694

# breakpoint state will not change from here on.

2695

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

2696

# recently entered function.

2697

{ # Represents a stack frame context.

2698

"locals": [ # Set of local variables at the stack frame location.

2699

# Note that this might not be populated for all stack frames.

2700

{ # Represents a variable or an argument possibly of a compound object type.

2701

# Note how the following variables are represented:

2702

#

2703

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2708

#

2709

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2718

# name: "x",

2719

# type: "T",

2720

# members { name: "m1", value: "3", type: "int" },

2721

# members { name: "m2", value: "7", type: "int" }

2722

# }

2723

#

2724

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2730

# name: "p",

2731

# type: "T*",

2732

# value: "0x00500500",

2733

# members { name: "m1", value: "3", type: "int" },

2734

# members { name: "m2", value: "7", type: "int" }

2735

# }

2736

#

2737

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2742

# name: "p",

2743

# type: "T*",

2744

# value: "0x00400400"

2745

# status { is_error: true, description { format: "unavailable" } }

2746

# }

2747

#

2748

# The status should describe the reason for the missing value,

2749

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2750

#

2751

# Note that a null pointer should not have members.

2752

#

2753

# 5) An unnamed value:

2754

#

2755

# int* p = new int(7);

2756

#

2757

# { // Captured variable

2758

# name: "p",

2759

# value: "0x00500500",

2760

# type: "int*",

2761

# members { value: "7", type: "int" } }

2762

#

2763

# 6) An unnamed pointer where the pointee was not captured:

2764

#

2765

# int* p = new int(7);

2766

# int** pp = &p;

2767

#

2768

# { // Captured variable

2769

# name: "pp",

2770

# value: "0x00500500",

2771

# type: "int**",

2772

# members {

2773

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2783

# repeat in the output multiple times can be stored once in a shared

2784

# variable table and be referenced using the `var_table_index` field. The

2785

# variables stored in the shared table are nameless and are essentially

2786

# a partition of the complete variable. To reconstruct the complete

2787

# variable, merge the referencing variable with the referenced variable.

2788

#

2789

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2796

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2797

# { name: "r", type="T&", var_table_index: 3 }

2798

#

2799

# { // Shared variable table entry #3:

2800

# members { name: "m1", value: "3", type: "int" },

2801

# members { name: "m2", value: "7", type: "int" }

2802

# }

2803

#

2804

# Note that the pointer address is stored with the referencing variable

2805

# and not with the referenced variable. This allows the referenced variable

2806

# to be shared between pointers and references.

2807

#

2808

# The type field is optional. The debugger agent may or may not support it.

2809

"members": [ # Members contained or pointed to by the variable.

2810

# Object with schema name: Variable

2811

],

2812

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2813

# unset. A status of a single variable only applies to that variable or

2814

# expression. The rest of breakpoint data still remains valid. Variables

2815

# might be reported in error state even when breakpoint is not in final

2816

# state.

2817

#

2818

# The message may refer to variable name with `refers_to` set to

2819

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2820

# In either case variable value and members will be unset.

2821

#

2822

# Example of error message applied to name: `Invalid expression syntax`.

2823

#

2824

# Example of information message applied to value: `Not captured`.

2825

#

2826

# Examples of error message applied to value:

2827

#

2828

# * `Malformed string`,

2829

# * `Field f not found in class C`

2830

# * `Null pointer dereference`

2831

# The message can indicate an error or informational status, and refer to

2832

# specific parts of the containing object.

2833

# For example, the `Breakpoint.status` field can indicate an error referring

2834

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2835

"isError": True or False, # Distinguishes errors from informational messages.

2836

"description": { # Represents a message with parameters. # Status message text.

2837

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2838

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2844

# is loaded. Again, $0 is very important.`

2845

# * `Please pay $$10 to use $0 instead of $1.`

2846

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

2851

},

2852

"name": "A String", # Name of the variable, if any.

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

"value": "A String", # Simple value of the variable.

2858

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2859

# one variable can reference the same variable in the table. The

2860

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2861

},

2862

],

2863

"location": { # Represents a location in the source code. # Source location of the call site.

2864

"path": "A String", # Path to the source file within the source context of the target binary.

2865

"column": 42, # Column within a line. The first column in a line as the value `1`.

2866

# Agents that do not support setting breakpoints on specific columns ignore

2867

# this field.

2868

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2869

},

2870

"function": "A String", # Demangled function name at the call site.

2871

"arguments": [ # Set of arguments passed to this function.

2872

# Note that this might not be populated for all stack frames.

2873

{ # Represents a variable or an argument possibly of a compound object type.

2874

# Note how the following variables are represented:

2875

#

2876

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2881

#

2882

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2891

# name: "x",

2892

# type: "T",

2893

# members { name: "m1", value: "3", type: "int" },

2894

# members { name: "m2", value: "7", type: "int" }

2895

# }

2896

#

2897

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2903

# name: "p",

2904

# type: "T*",

2905

# value: "0x00500500",

2906

# members { name: "m1", value: "3", type: "int" },

2907

# members { name: "m2", value: "7", type: "int" }

2908

# }

2909

#

2910

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2915

# name: "p",

2916

# type: "T*",

2917

# value: "0x00400400"

2918

# status { is_error: true, description { format: "unavailable" } }

2919

# }

2920

#

2921

# The status should describe the reason for the missing value,

2922

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2923

#

2924

# Note that a null pointer should not have members.

2925

#

2926

# 5) An unnamed value:

2927

#

2928

# int* p = new int(7);

2929

#

2930

# { // Captured variable

2931

# name: "p",

2932

# value: "0x00500500",

2933

# type: "int*",

2934

# members { value: "7", type: "int" } }

2935

#

2936

# 6) An unnamed pointer where the pointee was not captured:

2937

#

2938

# int* p = new int(7);

2939

# int** pp = &p;

2940

#

2941

# { // Captured variable

2942

# name: "pp",

2943

# value: "0x00500500",

2944

# type: "int**",

2945

# members {

2946

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2956

# repeat in the output multiple times can be stored once in a shared

2957

# variable table and be referenced using the `var_table_index` field. The

2958

# variables stored in the shared table are nameless and are essentially

2959

# a partition of the complete variable. To reconstruct the complete

2960

# variable, merge the referencing variable with the referenced variable.

2961

#

2962

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2969

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2970

# { name: "r", type="T&", var_table_index: 3 }

2971

#

2972

# { // Shared variable table entry #3:

2973

# members { name: "m1", value: "3", type: "int" },

2974

# members { name: "m2", value: "7", type: "int" }

2975

# }

2976

#

2977

# Note that the pointer address is stored with the referencing variable

2978

# and not with the referenced variable. This allows the referenced variable

2979

# to be shared between pointers and references.

2980

#

2981

# The type field is optional. The debugger agent may or may not support it.

2982

"members": [ # Members contained or pointed to by the variable.

2983

# Object with schema name: Variable

2984

],

2985

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2986

# unset. A status of a single variable only applies to that variable or

2987

# expression. The rest of breakpoint data still remains valid. Variables

2988

# might be reported in error state even when breakpoint is not in final

2989

# state.

2990

#

2991

# The message may refer to variable name with `refers_to` set to

2992

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2993

# In either case variable value and members will be unset.

2994

#

2995

# Example of error message applied to name: `Invalid expression syntax`.

2996

#

2997

# Example of information message applied to value: `Not captured`.

2998

#

2999

# Examples of error message applied to value:

3000

#

3001

# * `Malformed string`,

3002

# * `Field f not found in class C`

3003

# * `Null pointer dereference`

3004

# The message can indicate an error or informational status, and refer to

3005

# specific parts of the containing object.

3006

# For example, the `Breakpoint.status` field can indicate an error referring

3007

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

3008

"isError": True or False, # Distinguishes errors from informational messages.

3009

"description": { # Represents a message with parameters. # Status message text.

3010

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3011

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

3017

# is loaded. Again, $0 is very important.`

3018

# * `Please pay $$10 to use $0 instead of $1.`

3019

"parameters": [ # Optional parameters to be embedded into the message.

"A String",

],

},

"refersTo": "A String", # Reference to which the message applies.

3024

},

3025

"name": "A String", # Name of the variable, if any.

3026

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3027

# `var_table_index`, `type` goes next to `value`. The interpretation of

3028

# a type is agent specific. It is recommended to include the dynamic type

3029

# rather than a static type of an object.

3030

"value": "A String", # Simple value of the variable.

3031

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3032

# one variable can reference the same variable in the table. The

3033

# `var_table_index` field is an index into `variable_table` in Breakpoint.

},

],

},

],

"condition": "A String", # Condition that triggers the breakpoint.

3039

# The condition is a compound boolean expression composed using expressions

3040

# in a programming language at the source location.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3041

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

3042

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

3043

"status": { # Represents a contextual status message. # Breakpoint status.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3044

#

3045

# The status includes an error flag and a human readable message.

3046

# This field is usually unset. The message can be either

3047

# informational or an error message. Regardless, clients should always

3048

# display the text message back to the user.

3049

#

3050

# Error status indicates complete failure of the breakpoint.

3051

#

3052

# Example (non-final state): `Still loading symbols...`

3053

#

3054

# Examples (final state):

3055

#

3056

# * `Invalid line number` referring to location

3057

# * `Field f not found in class C` referring to condition

3058

# The message can indicate an error or informational status, and refer to

3059

# specific parts of the containing object.

3060

# For example, the `Breakpoint.status` field can indicate an error referring

3061

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3062

"isError": True or False, # Distinguishes errors from informational messages.

3063

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3064

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3065

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3070

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3071

# is loaded. Again, $0 is very important.`

3072

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

3073

"parameters": [ # Optional parameters to be embedded into the message.

3074

"A String",

3075

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3076

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3077

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3078

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3079

"state": "A String", # The current state of the breakpoint.

3080

"userEmail": "A String", # E-mail address of the user that created this breakpoint

3081

"action": "A String", # Action that the agent should perform when the code at the

3082

# breakpoint location is hit.

3083

"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.

3084

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

3085

"location": { # Represents a location in the source code. # Breakpoint source location.

3086

"path": "A String", # Path to the source file within the source context of the target binary.

3087

"column": 42, # Column within a line. The first column in a line as the value `1`.

3088

# Agents that do not support setting breakpoints on specific columns ignore

3089

# this field.

3090

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3091

},

3092

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

3093

# resolution.

3094

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3095

# traffic optimization. It enables storing a variable once and reference

3096

# it from multiple variables, including variables stored in the

3097

# `variable_table` itself.

3098

# For example, the same `this` object, which may appear at many levels of

3099

# the stack, can have all of its data stored once in this table. The

3100

# stack frame variables then would hold only a reference to it.

3101

#

3102

# The variable `var_table_index` field is an index into this repeated field.

3103

# The stored objects are nameless and get their name from the referencing

3104

# variable. The effective variable is a merge of the referencing variable

3105

# and the referenced variable.

3106

{ # Represents a variable or an argument possibly of a compound object type.

3107

# Note how the following variables are represented:

3108

#

3109

# 1) A simple variable:

3110

#

3111

# int x = 5

3112

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3113

# { name: "x", value: "5", type: "int" } // Captured variable

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3114

#

3115

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3124

# name: "x",

3125

# type: "T",

3126

# members { name: "m1", value: "3", type: "int" },

3127

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3128

# }

3129

#

3130

# 3) A pointer where the pointee was captured:

3131

#

3132

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3133

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3134

#

3135

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3136

# name: "p",

3137

# type: "T*",

3138

# value: "0x00500500",

3139

# members { name: "m1", value: "3", type: "int" },

3140

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3141

# }

3142

#

3143

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3148

# name: "p",

3149

# type: "T*",

3150

# value: "0x00400400"

3151

# status { is_error: true, description { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3152

# }

3153

#

3154

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3155

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3156

#

3157

# Note that a null pointer should not have members.

3158

#

3159

# 5) An unnamed value:

3160

#

3161

# int* p = new int(7);

3162

#

3163

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3164

# name: "p",

3165

# value: "0x00500500",

3166

# type: "int*",

3167

# members { value: "7", type: "int" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3168

#

3169

# 6) An unnamed pointer where the pointee was not captured:

3170

#

3171

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3172

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3173

#

3174

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3175

# name: "pp",

3176

# value: "0x00500500",

3177

# type: "int**",

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3178

# members {

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3179

# value: "0x00400400",

3180

# type: "int*"

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3181

# status {

3182

# is_error: true,

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3183

# description: { format: "unavailable" } }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

3189

# repeat in the output multiple times can be stored once in a shared

3190

# variable table and be referenced using the `var_table_index` field. The

3191

# variables stored in the shared table are nameless and are essentially

3192

# a partition of the complete variable. To reconstruct the complete

3193

# variable, merge the referencing variable with the referenced variable.

3194

#

3195

# When using the shared variable table, the following variables:

3196

#

3197

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3198

# T* p = &x;

3199

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3200

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3201

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

3202

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

3203

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3204

#

3205

# { // Shared variable table entry #3:

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3206

# members { name: "m1", value: "3", type: "int" },

3207

# members { name: "m2", value: "7", type: "int" }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3208

# }

3209

#

3210

# Note that the pointer address is stored with the referencing variable

3211

# and not with the referenced variable. This allows the referenced variable

3212

# to be shared between pointers and references.

3213

#

3214

# The type field is optional. The debugger agent may or may not support it.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3215

"members": [ # Members contained or pointed to by the variable.

3216

# Object with schema name: Variable

3217

],

3218

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3219

# unset. A status of a single variable only applies to that variable or

3220

# expression. The rest of breakpoint data still remains valid. Variables

3221

# might be reported in error state even when breakpoint is not in final

3222

# state.

3223

#

3224

# The message may refer to variable name with `refers_to` set to

3225

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

3226

# In either case variable value and members will be unset.

3227

#

3228

# Example of error message applied to name: `Invalid expression syntax`.

3229

#

3230

# Example of information message applied to value: `Not captured`.

3231

#

3232

# Examples of error message applied to value:

3233

#

3234

# * `Malformed string`,

3235

# * `Field f not found in class C`

3236

# * `Null pointer dereference`

3237

# The message can indicate an error or informational status, and refer to

3238

# specific parts of the containing object.

3239

# For example, the `Breakpoint.status` field can indicate an error referring

3240

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3241

"isError": True or False, # Distinguishes errors from informational messages.

3242

"description": { # Represents a message with parameters. # Status message text.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3243

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3244

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3249

# * `Failed to load '$0' which helps debug $1 the first time it

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3250

# is loaded. Again, $0 is very important.`

3251

# * `Please pay $$10 to use $0 instead of $1.`

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

3252

"parameters": [ # Optional parameters to be embedded into the message.

3253

"A String",

3254

],

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3255

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3256

"refersTo": "A String", # Reference to which the message applies.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3257

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3258

"name": "A String", # Name of the variable, if any.

3259

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3260

# `var_table_index`, `type` goes next to `value`. The interpretation of

3261

# a type is agent specific. It is recommended to include the dynamic type

3262

# rather than a static type of an object.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame^]

3263

"value": "A String", # Simple value of the variable.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3264

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3265

# one variable can reference the same variable in the table. The

3266

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3267

},

3268

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3269

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

3270

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

3271

# the breakpoint hits. The message may include parameter placeholders `$0`,

3272

# `$1`, etc. These placeholders are replaced with the evaluated value

3273

# of the appropriate expression. Expressions not referenced in

3274

# `log_message_format` are not logged.

3275

#

3276

# Example: `Message received, id = $0, count = $1` with

3277

# `expressions` = `[ message.id, message.count ]`.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3278

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3279

# displayed to the user.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

3280

"a_key": "A String",

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

3281

},

Takashi Matsuo