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

Jon Wayne Parrott

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

[diff] [blame]

84

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

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

Jon Wayne Parrott

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

[diff] [blame]

87

<code><a href="#set">set(debuggeeId, body, 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:

Jon Wayne Parrott

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

[diff] [blame]

95

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

96

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

Sai Cheemalapati

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

[diff] [blame]

97

clientVersion: string, The client version making the call.

98

Following: `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:

Jon Wayne Parrott

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

[diff] [blame]

124

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

125

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

Sai Cheemalapati

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

[diff] [blame]

126

clientVersion: string, The client version making the call.

127

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

Sai Cheemalapati

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

[diff] [blame]

137

"breakpoint": { # Represents the breakpoint specification, status and results. # Complete breakpoint state.

138

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

139

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

140

#

141

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

142

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

143

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

144

# display the text message back to the user.

145

#

146

# Error status indicates complete failure of the breakpoint.

147

#

148

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

149

#

150

# Examples (final state):

151

#

152

# * `Invalid line number` referring to location

153

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

154

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

155

# specific parts of the containing object.

156

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

157

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

Takashi Matsuo

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

[diff] [blame]

158

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

159

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

160

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

161

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

162

"A String",

163

],

Sai Cheemalapati

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

[diff] [blame]

164

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

165

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

# character.

#

# Examples:

#

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

171

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

172

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

Takashi Matsuo

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

[diff] [blame]

173

},

174

},

Sai Cheemalapati

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

[diff] [blame]

175

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

176

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

177

# it from multiple variables, including variables stored in the

178

# `variable_table` itself.

179

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

180

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

181

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

182

#

183

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

184

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

185

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

186

# and the referenced variable.

187

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

188

# Note how the following variables are represented:

189

#

190

# 1) A simple variable:

#

# int x = 5

#

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

195

#

196

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

205

# name: "x",

206

# type: "T",

207

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

208

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

209

# }

210

#

211

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

217

# name: "p",

218

# type: "T*",

219

# value: "0x00500500",

220

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

221

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

222

# }

223

#

224

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

#

# T* p = new T;

#

# { // Captured variable

229

# name: "p",

230

# type: "T*",

231

# value: "0x00400400"

232

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

233

# }

234

#

235

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

236

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

237

#

238

# Note that a null pointer should not have members.

239

#

240

# 5) An unnamed value:

241

#

242

# int* p = new int(7);

243

#

244

# { // Captured variable

245

# name: "p",

246

# value: "0x00500500",

247

# type: "int*",

248

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

249

#

250

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

251

#

252

# int* p = new int(7);

253

# int** pp = &p;

254

#

255

# { // Captured variable

256

# name: "pp",

257

# value: "0x00500500",

258

# type: "int**",

259

# members {

260

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

270

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

271

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

272

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

273

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

274

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

275

#

276

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

283

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

284

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

285

#

286

# { // Shared variable table entry #3:

287

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

288

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

289

# }

290

#

291

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

292

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

293

# to be shared between pointers and references.

294

#

295

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

296

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

297

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

298

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

299

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

300

# state.

301

#

302

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

303

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

304

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

305

#

306

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

307

#

308

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

309

#

310

# Examples of error message applied to value:

311

#

312

# * `Malformed string`,

313

# * `Field f not found in class C`

314

# * `Null pointer dereference`

315

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

316

# specific parts of the containing object.

317

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

318

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

Takashi Matsuo

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

[diff] [blame]

319

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

320

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

321

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

322

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

323

"A String",

324

],

Sai Cheemalapati

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

[diff] [blame]

325

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

326

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

# character.

#

# Examples:

#

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

332

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

333

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

Takashi Matsuo

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

[diff] [blame]

334

},

335

},

Jon Wayne Parrott

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

[diff] [blame]

336

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

Sai Cheemalapati

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

[diff] [blame]

337

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

338

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

339

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

Jon Wayne Parrott

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

[diff] [blame]

340

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

341

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

342

# Object with schema name: Variable

343

],

Sai Cheemalapati

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

[diff] [blame]

344

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

345

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

346

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

347

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

348

},

349

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

350

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

Jon Wayne Parrott

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

[diff] [blame]

351

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

Sai Cheemalapati

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

[diff] [blame]

352

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

353

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

354

"a_key": "A String",

355

},

Takashi Matsuo

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

[diff] [blame]

356

"stackFrames": [ # The stack at breakpoint time.

357

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

358

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

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

359

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

360

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

361

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

362

# Note how the following variables are represented:

363

#

364

# 1) A simple variable:

#

# int x = 5

#

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

369

#

370

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

379

# name: "x",

380

# type: "T",

381

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

382

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

383

# }

384

#

385

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

391

# name: "p",

392

# type: "T*",

393

# value: "0x00500500",

394

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

395

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

396

# }

397

#

398

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

#

# T* p = new T;

#

# { // Captured variable

403

# name: "p",

404

# type: "T*",

405

# value: "0x00400400"

406

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

407

# }

408

#

409

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

410

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

411

#

412

# Note that a null pointer should not have members.

413

#

414

# 5) An unnamed value:

415

#

416

# int* p = new int(7);

417

#

418

# { // Captured variable

419

# name: "p",

420

# value: "0x00500500",

421

# type: "int*",

422

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

423

#

424

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

425

#

426

# int* p = new int(7);

427

# int** pp = &p;

428

#

429

# { // Captured variable

430

# name: "pp",

431

# value: "0x00500500",

432

# type: "int**",

433

# members {

434

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

444

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

445

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

446

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

447

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

448

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

449

#

450

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

457

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

458

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

459

#

460

# { // Shared variable table entry #3:

461

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

462

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

463

# }

464

#

465

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

466

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

467

# to be shared between pointers and references.

468

#

469

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

470

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

471

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

472

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

473

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

474

# state.

475

#

476

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

477

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

478

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

479

#

480

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

481

#

482

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

483

#

484

# Examples of error message applied to value:

485

#

486

# * `Malformed string`,

487

# * `Field f not found in class C`

488

# * `Null pointer dereference`

489

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

490

# specific parts of the containing object.

491

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

492

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

493

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

494

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

495

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

496

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

497

"A String",

498

],

499

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

500

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

# character.

#

# Examples:

#

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

506

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

507

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

508

},

509

},

510

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

511

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

512

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

513

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

514

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

515

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

516

# Object with schema name: Variable

517

],

518

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

519

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

520

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

521

# rather than a static type of an object.

522

},

523

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

524

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

525

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

526

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

527

# Note how the following variables are represented:

528

#

529

# 1) A simple variable:

#

# int x = 5

#

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

534

#

535

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

544

# name: "x",

545

# type: "T",

546

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

547

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

548

# }

549

#

550

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

556

# name: "p",

557

# type: "T*",

558

# value: "0x00500500",

559

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

560

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

561

# }

562

#

563

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

#

# T* p = new T;

#

# { // Captured variable

568

# name: "p",

569

# type: "T*",

570

# value: "0x00400400"

571

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

572

# }

573

#

574

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

575

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

576

#

577

# Note that a null pointer should not have members.

578

#

579

# 5) An unnamed value:

580

#

581

# int* p = new int(7);

582

#

583

# { // Captured variable

584

# name: "p",

585

# value: "0x00500500",

586

# type: "int*",

587

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

588

#

589

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

590

#

591

# int* p = new int(7);

592

# int** pp = &p;

593

#

594

# { // Captured variable

595

# name: "pp",

596

# value: "0x00500500",

597

# type: "int**",

598

# members {

599

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

609

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

610

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

611

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

612

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

613

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

614

#

615

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

622

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

623

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

624

#

625

# { // Shared variable table entry #3:

626

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

627

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

628

# }

629

#

630

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

631

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

632

# to be shared between pointers and references.

633

#

634

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

635

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

636

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

637

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

638

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

639

# state.

640

#

641

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

642

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

643

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

644

#

645

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

646

#

647

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

648

#

649

# Examples of error message applied to value:

650

#

651

# * `Malformed string`,

652

# * `Field f not found in class C`

653

# * `Null pointer dereference`

654

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

655

# specific parts of the containing object.

656

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

657

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

658

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

659

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

660

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

661

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

662

"A String",

663

],

664

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

665

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

# character.

#

# Examples:

#

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

671

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

672

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

673

},

674

},

675

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

676

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

677

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

678

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

679

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

680

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

681

# Object with schema name: Variable

682

],

683

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

684

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

685

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

686

# rather than a static type of an object.

687

},

688

],

689

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

690

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

691

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

692

},

Takashi Matsuo

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

[diff] [blame]

693

},

694

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

695

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

Sai Cheemalapati

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

[diff] [blame]

696

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

697

# The expressions are composed using expressions in the programming language

698

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

699

# expressions are included in log statements.

Takashi Matsuo

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

[diff] [blame]

700

"A String",

701

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

702

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

703

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

704

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

705

},

706

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

707

# resolution.

708

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

709

# breakpoint location is hit.

710

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

711

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

712

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

713

# of the appropriate expression. Expressions not referenced in

714

# `log_message_format` are not logged.

715

#

716

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

717

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

Sai Cheemalapati

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

[diff] [blame]

718

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

719

# breakpoint state will not change from here on.

720

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

721

# The evaluated expressions appear in exactly the same order they

722

# are listed in the `expressions` field.

723

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

724

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

725

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

726

# will indicate an error and contain the error text.

727

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

728

# Note how the following variables are represented:

729

#

730

# 1) A simple variable:

#

# int x = 5

#

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

735

#

736

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

745

# name: "x",

746

# type: "T",

747

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

748

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

749

# }

750

#

751

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

757

# name: "p",

758

# type: "T*",

759

# value: "0x00500500",

760

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

761

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

762

# }

763

#

764

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

#

# T* p = new T;

#

# { // Captured variable

769

# name: "p",

770

# type: "T*",

771

# value: "0x00400400"

772

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

773

# }

774

#

775

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

776

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

777

#

778

# Note that a null pointer should not have members.

779

#

780

# 5) An unnamed value:

781

#

782

# int* p = new int(7);

783

#

784

# { // Captured variable

785

# name: "p",

786

# value: "0x00500500",

787

# type: "int*",

788

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

789

#

790

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

791

#

792

# int* p = new int(7);

793

# int** pp = &p;

794

#

795

# { // Captured variable

796

# name: "pp",

797

# value: "0x00500500",

798

# type: "int**",

799

# members {

800

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

810

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

811

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

812

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

813

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

814

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

815

#

816

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

823

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

824

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

825

#

826

# { // Shared variable table entry #3:

827

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

828

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

829

# }

830

#

831

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

832

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

833

# to be shared between pointers and references.

834

#

835

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

836

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

837

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

838

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

839

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

840

# state.

841

#

842

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

843

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

844

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

845

#

846

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

847

#

848

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

849

#

850

# Examples of error message applied to value:

851

#

852

# * `Malformed string`,

853

# * `Field f not found in class C`

854

# * `Null pointer dereference`

855

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

856

# specific parts of the containing object.

857

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

858

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

Takashi Matsuo

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

[diff] [blame]

859

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

860

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

861

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

862

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

863

"A String",

864

],

Sai Cheemalapati

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

[diff] [blame]

865

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

866

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

# character.

#

# Examples:

#

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

872

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

873

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

Takashi Matsuo

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

[diff] [blame]

874

},

875

},

Jon Wayne Parrott

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

[diff] [blame]

876

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

Sai Cheemalapati

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

[diff] [blame]

877

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

878

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

879

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

Jon Wayne Parrott

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

[diff] [blame]

880

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

881

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

882

# Object with schema name: Variable

883

],

Sai Cheemalapati

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

[diff] [blame]

884

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

885

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

886

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

887

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

888

},

889

],

890

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

Sai Cheemalapati

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

[diff] [blame]

891

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

892

# The condition is a compound boolean expression composed using expressions

893

# in a programming language at the source location.

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]

899

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

Jon Wayne Parrott

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

[diff] [blame]

900

<pre>Lists all breakpoints for the debuggee.

Takashi Matsuo

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

[diff] [blame]

901

902

Args:

Jon Wayne Parrott

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

[diff] [blame]

903

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

Sai Cheemalapati

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

[diff] [blame]

904

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

905

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

906

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

907

breakpoints. Otherwise, it includes only active breakpoints.

Takashi Matsuo

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

[diff] [blame]

908

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

Allowed values

1 - v1 error format

2 - v2 error format

clientVersion: string, The client version making the call.

913

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

914

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

915

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

Takashi Matsuo

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

[diff] [blame]

916

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

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

Takashi Matsuo

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

[diff] [blame]

922

923

Returns:

924

An object of the form:

925

Jon Wayne Parrott

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

[diff] [blame]

926

{ # Response for listing breakpoints.

Sai Cheemalapati

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

[diff] [blame]

927

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

928

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

929

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

930

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

931

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

932

# are cleared on each breakpoint regardless of it's status.

Takashi Matsuo

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

[diff] [blame]

933

{ # Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

934

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

935

#

936

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

937

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

938

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

939

# display the text message back to the user.

940

#

941

# Error status indicates complete failure of the breakpoint.

942

#

943

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

944

#

945

# Examples (final state):

946

#

947

# * `Invalid line number` referring to location

948

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

949

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

950

# specific parts of the containing object.

951

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

952

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

Takashi Matsuo

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

[diff] [blame]

953

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

954

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

955

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

956

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

957

"A String",

958

],

Sai Cheemalapati

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

[diff] [blame]

959

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

960

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

# character.

#

# Examples:

#

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

966

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

967

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

Takashi Matsuo

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

[diff] [blame]

968

},

969

},

Sai Cheemalapati

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

[diff] [blame]

970

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

971

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

972

# it from multiple variables, including variables stored in the

973

# `variable_table` itself.

974

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

975

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

976

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

977

#

978

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

979

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

980

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

981

# and the referenced variable.

982

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

983

# Note how the following variables are represented:

984

#

985

# 1) A simple variable:

#

# int x = 5

#

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

990

#

991

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1000

# name: "x",

1001

# type: "T",

1002

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

1003

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

1004

# }

1005

#

1006

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1012

# name: "p",

1013

# type: "T*",

1014

# value: "0x00500500",

1015

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

1016

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

1017

# }

1018

#

1019

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

#

# T* p = new T;

#

# { // Captured variable

1024

# name: "p",

1025

# type: "T*",

1026

# value: "0x00400400"

1027

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

1028

# }

1029

#

1030

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

1031

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

1032

#

1033

# Note that a null pointer should not have members.

1034

#

1035

# 5) An unnamed value:

1036

#

1037

# int* p = new int(7);

1038

#

1039

# { // Captured variable

1040

# name: "p",

1041

# value: "0x00500500",

1042

# type: "int*",

1043

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

1044

#

1045

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

1046

#

1047

# int* p = new int(7);

1048

# int** pp = &p;

1049

#

1050

# { // Captured variable

1051

# name: "pp",

1052

# value: "0x00500500",

1053

# type: "int**",

1054

# members {

1055

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1065

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

1066

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

1067

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

1068

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

1069

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

1070

#

1071

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

1078

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

1079

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

1080

#

1081

# { // Shared variable table entry #3:

1082

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

1083

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

1084

# }

1085

#

1086

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

1087

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

1088

# to be shared between pointers and references.

1089

#

1090

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

1091

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

1092

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

1093

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

1094

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

1095

# state.

1096

#

1097

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

1098

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

1099

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

1100

#

1101

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

1102

#

1103

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

1104

#

1105

# Examples of error message applied to value:

1106

#

1107

# * `Malformed string`,

1108

# * `Field f not found in class C`

1109

# * `Null pointer dereference`

1110

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

1111

# specific parts of the containing object.

1112

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

1113

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

Takashi Matsuo

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

[diff] [blame]

1114

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

1115

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

1116

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

1117

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

1118

"A String",

1119

],

Sai Cheemalapati

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

[diff] [blame]

1120

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

1121

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

# character.

#

# Examples:

#

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

1127

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

1128

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

Takashi Matsuo

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

[diff] [blame]

1129

},

1130

},

Jon Wayne Parrott

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

[diff] [blame]

1131

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

Sai Cheemalapati

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

[diff] [blame]

1132

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

1133

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

1134

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

Jon Wayne Parrott

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

[diff] [blame]

1135

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

1136

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

1137

# Object with schema name: Variable

1138

],

Sai Cheemalapati

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

[diff] [blame]

1139

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

1140

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

1141

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

1142

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1143

},

1144

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

1145

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

Jon Wayne Parrott

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

[diff] [blame]

1146

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

Sai Cheemalapati

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

[diff] [blame]

1147

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

1148

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

1149

"a_key": "A String",

1150

},

Takashi Matsuo

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

[diff] [blame]

1151

"stackFrames": [ # The stack at breakpoint time.

1152

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1153

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

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

1154

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

1155

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

1156

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

1157

# Note how the following variables are represented:

1158

#

1159

# 1) A simple variable:

#

# int x = 5

#

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

1164

#

1165

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1174

# name: "x",

1175

# type: "T",

1176

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

1177

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

1178

# }

1179

#

1180

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1186

# name: "p",

1187

# type: "T*",

1188

# value: "0x00500500",

1189

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

1190

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

1191

# }

1192

#

1193

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

#

# T* p = new T;

#

# { // Captured variable

1198

# name: "p",

1199

# type: "T*",

1200

# value: "0x00400400"

1201

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

1202

# }

1203

#

1204

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

1205

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

1206

#

1207

# Note that a null pointer should not have members.

1208

#

1209

# 5) An unnamed value:

1210

#

1211

# int* p = new int(7);

1212

#

1213

# { // Captured variable

1214

# name: "p",

1215

# value: "0x00500500",

1216

# type: "int*",

1217

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

1218

#

1219

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

1220

#

1221

# int* p = new int(7);

1222

# int** pp = &p;

1223

#

1224

# { // Captured variable

1225

# name: "pp",

1226

# value: "0x00500500",

1227

# type: "int**",

1228

# members {

1229

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1239

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

1240

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

1241

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

1242

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

1243

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

1244

#

1245

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

1252

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

1253

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

1254

#

1255

# { // Shared variable table entry #3:

1256

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

1257

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

1258

# }

1259

#

1260

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

1261

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

1262

# to be shared between pointers and references.

1263

#

1264

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

1265

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

1266

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

1267

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

1268

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

1269

# state.

1270

#

1271

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

1272

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

1273

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

1274

#

1275

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

1276

#

1277

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

1278

#

1279

# Examples of error message applied to value:

1280

#

1281

# * `Malformed string`,

1282

# * `Field f not found in class C`

1283

# * `Null pointer dereference`

1284

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

1285

# specific parts of the containing object.

1286

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

1287

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

1288

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

1289

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

1290

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

1291

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

1292

"A String",

1293

],

1294

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

1295

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

# character.

#

# Examples:

#

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

1301

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

1302

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

1303

},

1304

},

1305

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

1306

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

1307

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

1308

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

1309

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

1310

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

1311

# Object with schema name: Variable

1312

],

1313

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

1314

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

1315

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

1316

# rather than a static type of an object.

1317

},

1318

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

1319

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

1320

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

1321

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

1322

# Note how the following variables are represented:

1323

#

1324

# 1) A simple variable:

#

# int x = 5

#

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

1329

#

1330

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1339

# name: "x",

1340

# type: "T",

1341

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

1342

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

1343

# }

1344

#

1345

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1351

# name: "p",

1352

# type: "T*",

1353

# value: "0x00500500",

1354

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

1355

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

1356

# }

1357

#

1358

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

#

# T* p = new T;

#

# { // Captured variable

1363

# name: "p",

1364

# type: "T*",

1365

# value: "0x00400400"

1366

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

1367

# }

1368

#

1369

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

1370

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

1371

#

1372

# Note that a null pointer should not have members.

1373

#

1374

# 5) An unnamed value:

1375

#

1376

# int* p = new int(7);

1377

#

1378

# { // Captured variable

1379

# name: "p",

1380

# value: "0x00500500",

1381

# type: "int*",

1382

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

1383

#

1384

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

1385

#

1386

# int* p = new int(7);

1387

# int** pp = &p;

1388

#

1389

# { // Captured variable

1390

# name: "pp",

1391

# value: "0x00500500",

1392

# type: "int**",

1393

# members {

1394

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1404

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

1405

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

1406

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

1407

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

1408

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

1409

#

1410

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

1417

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

1418

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

1419

#

1420

# { // Shared variable table entry #3:

1421

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

1422

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

1423

# }

1424

#

1425

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

1426

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

1427

# to be shared between pointers and references.

1428

#

1429

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

1430

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

1431

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

1432

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

1433

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

1434

# state.

1435

#

1436

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

1437

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

1438

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

1439

#

1440

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

1441

#

1442

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

1443

#

1444

# Examples of error message applied to value:

1445

#

1446

# * `Malformed string`,

1447

# * `Field f not found in class C`

1448

# * `Null pointer dereference`

1449

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

1450

# specific parts of the containing object.

1451

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

1452

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

1453

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

1454

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

1455

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

1456

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

1457

"A String",

1458

],

1459

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

1460

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

# character.

#

# Examples:

#

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

1466

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

1467

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

1468

},

1469

},

1470

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

1471

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

1472

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

1473

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

1474

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

1475

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

1476

# Object with schema name: Variable

1477

],

1478

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

1479

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

1480

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

1481

# rather than a static type of an object.

1482

},

1483

],

1484

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

1485

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

1486

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

1487

},

Takashi Matsuo

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

[diff] [blame]

1488

},

1489

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

1490

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

Sai Cheemalapati

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

[diff] [blame]

1491

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

1492

# The expressions are composed using expressions in the programming language

1493

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

1494

# expressions are included in log statements.

Takashi Matsuo

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

[diff] [blame]

1495

"A String",

1496

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

1497

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

1498

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

1499

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

1500

},

1501

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

1502

# resolution.

1503

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

1504

# breakpoint location is hit.

1505

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

1506

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

1507

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

1508

# of the appropriate expression. Expressions not referenced in

1509

# `log_message_format` are not logged.

1510

#

1511

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

1512

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

Sai Cheemalapati

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

[diff] [blame]

1513

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

1514

# breakpoint state will not change from here on.

1515

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

1516

# The evaluated expressions appear in exactly the same order they

1517

# are listed in the `expressions` field.

1518

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

1519

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

1520

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

1521

# will indicate an error and contain the error text.

1522

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

1523

# Note how the following variables are represented:

1524

#

1525

# 1) A simple variable:

#

# int x = 5

#

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

1530

#

1531

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1540

# name: "x",

1541

# type: "T",

1542

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

1543

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

1544

# }

1545

#

1546

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1552

# name: "p",

1553

# type: "T*",

1554

# value: "0x00500500",

1555

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

1556

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

1557

# }

1558

#

1559

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

#

# T* p = new T;

#

# { // Captured variable

1564

# name: "p",

1565

# type: "T*",

1566

# value: "0x00400400"

1567

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

1568

# }

1569

#

1570

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

1571

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

1572

#

1573

# Note that a null pointer should not have members.

1574

#

1575

# 5) An unnamed value:

1576

#

1577

# int* p = new int(7);

1578

#

1579

# { // Captured variable

1580

# name: "p",

1581

# value: "0x00500500",

1582

# type: "int*",

1583

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

1584

#

1585

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

1586

#

1587

# int* p = new int(7);

1588

# int** pp = &p;

1589

#

1590

# { // Captured variable

1591

# name: "pp",

1592

# value: "0x00500500",

1593

# type: "int**",

1594

# members {

1595

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1605

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

1606

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

1607

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

1608

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

1609

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

1610

#

1611

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

1618

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

1619

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

1620

#

1621

# { // Shared variable table entry #3:

1622

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

1623

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

1624

# }

1625

#

1626

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

1627

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

1628

# to be shared between pointers and references.

1629

#

1630

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

1631

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

1632

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

1633

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

1634

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

1635

# state.

1636

#

1637

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

1638

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

1639

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

1640

#

1641

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

1642

#

1643

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

1644

#

1645

# Examples of error message applied to value:

1646

#

1647

# * `Malformed string`,

1648

# * `Field f not found in class C`

1649

# * `Null pointer dereference`

1650

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

1651

# specific parts of the containing object.

1652

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

1653

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

Takashi Matsuo

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

[diff] [blame]

1654

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

1655

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

1656

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

1657

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

1658

"A String",

1659

],

Sai Cheemalapati

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

[diff] [blame]

1660

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

1661

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

# character.

#

# Examples:

#

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

1667

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

1668

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

Takashi Matsuo

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

[diff] [blame]

1669

},

1670

},

Jon Wayne Parrott

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

[diff] [blame]

1671

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

Sai Cheemalapati

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

[diff] [blame]

1672

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

1673

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

1674

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

Jon Wayne Parrott

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

[diff] [blame]

1675

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

1676

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

1677

# Object with schema name: Variable

1678

],

Sai Cheemalapati

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

[diff] [blame]

1679

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

1680

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

1681

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

1682

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1683

},

1684

],

1685

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

Sai Cheemalapati

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

[diff] [blame]

1686

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

1687

# The condition is a compound boolean expression composed using expressions

1688

# in a programming language at the source location.

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]

1695

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

Takashi Matsuo

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

[diff] [blame]

1696

<pre>Sets the breakpoint to the debuggee.

1697

1698

Args:

Jon Wayne Parrott

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

[diff] [blame]

1699

debuggeeId: string, ID of the debuggee where the breakpoint is to be set. (required)

Takashi Matsuo

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

[diff] [blame]

1700

body: object, The request body. (required)

1701

The object takes the form of:

1702

1703

{ # Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

1704

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

1705

#

1706

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

1707

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

1708

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

1709

# display the text message back to the user.

1710

#

1711

# Error status indicates complete failure of the breakpoint.

1712

#

1713

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

1714

#

1715

# Examples (final state):

1716

#

1717

# * `Invalid line number` referring to location

1718

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

1719

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

1720

# specific parts of the containing object.

1721

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

1722

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

Takashi Matsuo

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

[diff] [blame]

1723

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

1724

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

1725

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

1726

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

1727

"A String",

1728

],

Sai Cheemalapati

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

[diff] [blame]

1729

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

1730

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

# character.

#

# Examples:

#

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

1736

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

1737

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

Takashi Matsuo

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

[diff] [blame]

1738

},

1739

},

Sai Cheemalapati

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

[diff] [blame]

1740

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

1741

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

1742

# it from multiple variables, including variables stored in the

1743

# `variable_table` itself.

1744

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

1745

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

1746

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

1747

#

1748

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

1749

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

1750

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

1751

# and the referenced variable.

1752

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

1753

# Note how the following variables are represented:

1754

#

1755

# 1) A simple variable:

#

# int x = 5

#

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

1760

#

1761

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1770

# name: "x",

1771

# type: "T",

1772

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

1773

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

1774

# }

1775

#

1776

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1782

# name: "p",

1783

# type: "T*",

1784

# value: "0x00500500",

1785

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

1786

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

1787

# }

1788

#

1789

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

#

# T* p = new T;

#

# { // Captured variable

1794

# name: "p",

1795

# type: "T*",

1796

# value: "0x00400400"

1797

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

1798

# }

1799

#

1800

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

1801

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

1802

#

1803

# Note that a null pointer should not have members.

1804

#

1805

# 5) An unnamed value:

1806

#

1807

# int* p = new int(7);

1808

#

1809

# { // Captured variable

1810

# name: "p",

1811

# value: "0x00500500",

1812

# type: "int*",

1813

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

1814

#

1815

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

1816

#

1817

# int* p = new int(7);

1818

# int** pp = &p;

1819

#

1820

# { // Captured variable

1821

# name: "pp",

1822

# value: "0x00500500",

1823

# type: "int**",

1824

# members {

1825

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1835

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

1836

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

1837

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

1838

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

1839

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

1840

#

1841

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

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

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

1848

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

1849

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

1850

#

1851

# { // Shared variable table entry #3:

1852

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

1853

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

1854

# }

1855

#

1856

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

1857

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

1858

# to be shared between pointers and references.

1859

#

1860

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

1861

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

1862

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

1863

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

1864

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

1865

# state.

1866

#

1867

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

1868

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

1869

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

1870

#

1871

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

1872

#

1873

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

1874

#

1875

# Examples of error message applied to value:

1876

#

1877

# * `Malformed string`,

1878

# * `Field f not found in class C`

1879

# * `Null pointer dereference`

1880

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

1881

# specific parts of the containing object.

1882

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

1883

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

Takashi Matsuo

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

[diff] [blame]

1884

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

1885

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

1886

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

1887

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

1888

"A String",

1889

],

Sai Cheemalapati

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

[diff] [blame]

1890

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

1891

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

# character.

#

# Examples:

#

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

1897

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

1898

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

Takashi Matsuo

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

[diff] [blame]

1899

},

1900

},

Jon Wayne Parrott

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

[diff] [blame]

1901

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

Sai Cheemalapati

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

[diff] [blame]

1902

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

1903

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

1904

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

Jon Wayne Parrott

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

[diff] [blame]

1905

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

1906

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

1907

# Object with schema name: Variable

1908

],

Sai Cheemalapati

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

[diff] [blame]

1909

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

1910

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

1911

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

1912

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1913

},

1914

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

1915

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

Jon Wayne Parrott

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

[diff] [blame]

1916

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

Sai Cheemalapati

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

[diff] [blame]

1917

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

1918

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

1919

"a_key": "A String",

1920

},

Takashi Matsuo

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

[diff] [blame]

1921

"stackFrames": [ # The stack at breakpoint time.

1922

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1923

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

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

1924

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

1925

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

1926

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

1927

# Note how the following variables are represented:

1928

#

1929

# 1) A simple variable:

#

# int x = 5

#

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

1934

#

1935

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1944

# name: "x",

1945

# type: "T",

1946

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

1947

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

1948

# }

1949

#

1950

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1956

# name: "p",

1957

# type: "T*",

1958

# value: "0x00500500",

1959

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

1960

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

1961

# }

1962

#

1963

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

#

# T* p = new T;

#

# { // Captured variable

1968

# name: "p",

1969

# type: "T*",

1970

# value: "0x00400400"

1971

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

1972

# }

1973

#

1974

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

1975

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

1976

#

1977

# Note that a null pointer should not have members.

1978

#

1979

# 5) An unnamed value:

1980

#

1981

# int* p = new int(7);

1982

#

1983

# { // Captured variable

1984

# name: "p",

1985

# value: "0x00500500",

1986

# type: "int*",

1987

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

1988

#

1989

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

1990

#

1991

# int* p = new int(7);

1992

# int** pp = &p;

1993

#

1994

# { // Captured variable

1995

# name: "pp",

1996

# value: "0x00500500",

1997

# type: "int**",

1998

# members {

1999

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

2009

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

2010

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

2011

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

2012

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

2013

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

2014

#

2015

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2022

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2023

# { name: "r", type="T&", var_table_index: 3 }

2024

#

2025

# { // Shared variable table entry #3:

2026

# members { name: "m1", value: "3", type: "int" },

2027

# members { name: "m2", value: "7", type: "int" }

2028

# }

2029

#

2030

# Note that the pointer address is stored with the referencing variable

2031

# and not with the referenced variable. This allows the referenced variable

2032

# to be shared between pointers and references.

2033

#

2034

# The type field is optional. The debugger agent may or may not support it.

2035

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2036

# unset. A status of a single variable only applies to that variable or

2037

# expression. The rest of breakpoint data still remains valid. Variables

2038

# might be reported in error state even when breakpoint is not in final

2039

# state.

2040

#

2041

# The message may refer to variable name with `refers_to` set to

2042

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2043

# In either case variable value and members will be unset.

2044

#

2045

# Example of error message applied to name: `Invalid expression syntax`.

2046

#

2047

# Example of information message applied to value: `Not captured`.

2048

#

2049

# Examples of error message applied to value:

2050

#

2051

# * `Malformed string`,

2052

# * `Field f not found in class C`

2053

# * `Null pointer dereference`

2054

# The message can indicate an error or informational status, and refer to

2055

# specific parts of the containing object.

2056

# For example, the `Breakpoint.status` field can indicate an error referring

2057

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2058

"isError": True or False, # Distinguishes errors from informational messages.

2059

"refersTo": "A String", # Reference to which the message applies.

2060

"description": { # Represents a message with parameters. # Status message text.

2061

"parameters": [ # Optional parameters to be embedded into the message.

2062

"A String",

2063

],

2064

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2065

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2071

# is loaded. Again, $0 is very important.`

2072

# * `Please pay $$10 to use $0 instead of $1.`

2073

},

2074

},

2075

"name": "A String", # Name of the variable, if any.

2076

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2077

# one variable can reference the same variable in the table. The

2078

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2079

"value": "A String", # Simple value of the variable.

2080

"members": [ # Members contained or pointed to by the variable.

2081

# Object with schema name: Variable

2082

],

2083

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2084

# `var_table_index`, `type` goes next to `value`. The interpretation of

2085

# a type is agent specific. It is recommended to include the dynamic type

2086

# rather than a static type of an object.

2087

},

2088

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2089

"locals": [ # Set of local variables at the stack frame location.

2090

# Note that this might not be populated for all stack frames.

2091

{ # Represents a variable or an argument possibly of a compound object type.

2092

# Note how the following variables are represented:

2093

#

2094

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2099

#

2100

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2109

# name: "x",

2110

# type: "T",

2111

# members { name: "m1", value: "3", type: "int" },

2112

# members { name: "m2", value: "7", type: "int" }

2113

# }

2114

#

2115

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2121

# name: "p",

2122

# type: "T*",

2123

# value: "0x00500500",

2124

# members { name: "m1", value: "3", type: "int" },

2125

# members { name: "m2", value: "7", type: "int" }

2126

# }

2127

#

2128

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2133

# name: "p",

2134

# type: "T*",

2135

# value: "0x00400400"

2136

# status { is_error: true, description { format: "unavailable" } }

2137

# }

2138

#

2139

# The status should describe the reason for the missing value,

2140

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2141

#

2142

# Note that a null pointer should not have members.

2143

#

2144

# 5) An unnamed value:

2145

#

2146

# int* p = new int(7);

2147

#

2148

# { // Captured variable

2149

# name: "p",

2150

# value: "0x00500500",

2151

# type: "int*",

2152

# members { value: "7", type: "int" } }

2153

#

2154

# 6) An unnamed pointer where the pointee was not captured:

2155

#

2156

# int* p = new int(7);

2157

# int** pp = &p;

2158

#

2159

# { // Captured variable

2160

# name: "pp",

2161

# value: "0x00500500",

2162

# type: "int**",

2163

# members {

2164

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2174

# repeat in the output multiple times can be stored once in a shared

2175

# variable table and be referenced using the `var_table_index` field. The

2176

# variables stored in the shared table are nameless and are essentially

2177

# a partition of the complete variable. To reconstruct the complete

2178

# variable, merge the referencing variable with the referenced variable.

2179

#

2180

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2187

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2188

# { name: "r", type="T&", var_table_index: 3 }

2189

#

2190

# { // Shared variable table entry #3:

2191

# members { name: "m1", value: "3", type: "int" },

2192

# members { name: "m2", value: "7", type: "int" }

2193

# }

2194

#

2195

# Note that the pointer address is stored with the referencing variable

2196

# and not with the referenced variable. This allows the referenced variable

2197

# to be shared between pointers and references.

2198

#

2199

# The type field is optional. The debugger agent may or may not support it.

2200

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2201

# unset. A status of a single variable only applies to that variable or

2202

# expression. The rest of breakpoint data still remains valid. Variables

2203

# might be reported in error state even when breakpoint is not in final

2204

# state.

2205

#

2206

# The message may refer to variable name with `refers_to` set to

2207

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2208

# In either case variable value and members will be unset.

2209

#

2210

# Example of error message applied to name: `Invalid expression syntax`.

2211

#

2212

# Example of information message applied to value: `Not captured`.

2213

#

2214

# Examples of error message applied to value:

2215

#

2216

# * `Malformed string`,

2217

# * `Field f not found in class C`

2218

# * `Null pointer dereference`

2219

# The message can indicate an error or informational status, and refer to

2220

# specific parts of the containing object.

2221

# For example, the `Breakpoint.status` field can indicate an error referring

2222

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2223

"isError": True or False, # Distinguishes errors from informational messages.

2224

"refersTo": "A String", # Reference to which the message applies.

2225

"description": { # Represents a message with parameters. # Status message text.

2226

"parameters": [ # Optional parameters to be embedded into the message.

2227

"A String",

2228

],

2229

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2230

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2236

# is loaded. Again, $0 is very important.`

2237

# * `Please pay $$10 to use $0 instead of $1.`

2238

},

2239

},

2240

"name": "A String", # Name of the variable, if any.

2241

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2242

# one variable can reference the same variable in the table. The

2243

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2244

"value": "A String", # Simple value of the variable.

2245

"members": [ # Members contained or pointed to by the variable.

2246

# Object with schema name: Variable

2247

],

2248

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2249

# `var_table_index`, `type` goes next to `value`. The interpretation of

2250

# a type is agent specific. It is recommended to include the dynamic type

2251

# rather than a static type of an object.

2252

},

2253

],

2254

"location": { # Represents a location in the source code. # Source location of the call site.

2255

"path": "A String", # Path to the source file within the source context of the target binary.

2256

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2257

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2258

},

2259

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2260

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2261

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

2262

# The expressions are composed using expressions in the programming language

2263

# at the source location. If the breakpoint action is `LOG`, the evaluated

2264

# expressions are included in log statements.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2265

"A String",

2266

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2267

"location": { # Represents a location in the source code. # Breakpoint source location.

2268

"path": "A String", # Path to the source file within the source context of the target binary.

2269

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2270

},

2271

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

2272

# resolution.

2273

"action": "A String", # Action that the agent should perform when the code at the

2274

# breakpoint location is hit.

2275

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

2276

# the breakpoint hits. The message may include parameter placeholders `$0`,

2277

# `$1`, etc. These placeholders are replaced with the evaluated value

2278

# of the appropriate expression. Expressions not referenced in

2279

# `log_message_format` are not logged.

2280

#

2281

# Example: `Message received, id = $0, count = $1` with

2282

# `expressions` = `[ message.id, message.count ]`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2283

"isFinalState": True or False, # When true, indicates that this is a final result and the

2284

# breakpoint state will not change from here on.

2285

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

2286

# The evaluated expressions appear in exactly the same order they

2287

# are listed in the `expressions` field.

2288

# The `name` field holds the original expression text, the `value` or

2289

# `members` field holds the result of the evaluated expression.

2290

# If the expression cannot be evaluated, the `status` inside the `Variable`

2291

# will indicate an error and contain the error text.

2292

{ # Represents a variable or an argument possibly of a compound object type.

2293

# Note how the following variables are represented:

2294

#

2295

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2300

#

2301

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2310

# name: "x",

2311

# type: "T",

2312

# members { name: "m1", value: "3", type: "int" },

2313

# members { name: "m2", value: "7", type: "int" }

2314

# }

2315

#

2316

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2322

# name: "p",

2323

# type: "T*",

2324

# value: "0x00500500",

2325

# members { name: "m1", value: "3", type: "int" },

2326

# members { name: "m2", value: "7", type: "int" }

2327

# }

2328

#

2329

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2334

# name: "p",

2335

# type: "T*",

2336

# value: "0x00400400"

2337

# status { is_error: true, description { format: "unavailable" } }

2338

# }

2339

#

2340

# The status should describe the reason for the missing value,

2341

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2342

#

2343

# Note that a null pointer should not have members.

2344

#

2345

# 5) An unnamed value:

2346

#

2347

# int* p = new int(7);

2348

#

2349

# { // Captured variable

2350

# name: "p",

2351

# value: "0x00500500",

2352

# type: "int*",

2353

# members { value: "7", type: "int" } }

2354

#

2355

# 6) An unnamed pointer where the pointee was not captured:

2356

#

2357

# int* p = new int(7);

2358

# int** pp = &p;

2359

#

2360

# { // Captured variable

2361

# name: "pp",

2362

# value: "0x00500500",

2363

# type: "int**",

2364

# members {

2365

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2375

# repeat in the output multiple times can be stored once in a shared

2376

# variable table and be referenced using the `var_table_index` field. The

2377

# variables stored in the shared table are nameless and are essentially

2378

# a partition of the complete variable. To reconstruct the complete

2379

# variable, merge the referencing variable with the referenced variable.

2380

#

2381

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2388

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2389

# { name: "r", type="T&", var_table_index: 3 }

2390

#

2391

# { // Shared variable table entry #3:

2392

# members { name: "m1", value: "3", type: "int" },

2393

# members { name: "m2", value: "7", type: "int" }

2394

# }

2395

#

2396

# Note that the pointer address is stored with the referencing variable

2397

# and not with the referenced variable. This allows the referenced variable

2398

# to be shared between pointers and references.

2399

#

2400

# The type field is optional. The debugger agent may or may not support it.

2401

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2402

# unset. A status of a single variable only applies to that variable or

2403

# expression. The rest of breakpoint data still remains valid. Variables

2404

# might be reported in error state even when breakpoint is not in final

2405

# state.

2406

#

2407

# The message may refer to variable name with `refers_to` set to

2408

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2409

# In either case variable value and members will be unset.

2410

#

2411

# Example of error message applied to name: `Invalid expression syntax`.

2412

#

2413

# Example of information message applied to value: `Not captured`.

2414

#

2415

# Examples of error message applied to value:

2416

#

2417

# * `Malformed string`,

2418

# * `Field f not found in class C`

2419

# * `Null pointer dereference`

2420

# The message can indicate an error or informational status, and refer to

2421

# specific parts of the containing object.

2422

# For example, the `Breakpoint.status` field can indicate an error referring

2423

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2424

"isError": True or False, # Distinguishes errors from informational messages.

2425

"refersTo": "A String", # Reference to which the message applies.

2426

"description": { # Represents a message with parameters. # Status message text.

2427

"parameters": [ # Optional parameters to be embedded into the message.

2428

"A String",

2429

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2430

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2431

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2437

# is loaded. Again, $0 is very important.`

2438

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2439

},

2440

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2441

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2442

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2443

# one variable can reference the same variable in the table. The

2444

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2445

"value": "A String", # Simple value of the variable.

2446

"members": [ # Members contained or pointed to by the variable.

2447

# Object with schema name: Variable

2448

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2449

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2450

# `var_table_index`, `type` goes next to `value`. The interpretation of

2451

# a type is agent specific. It is recommended to include the dynamic type

2452

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2453

},

2454

],

2455

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2456

"condition": "A String", # Condition that triggers the breakpoint.

2457

# The condition is a compound boolean expression composed using expressions

2458

# in a programming language at the source location.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2459

}

2460

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2461

clientVersion: string, The client version making the call.

2462

Following: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2463

x__xgafv: string, V1 error format.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2464

Allowed values

2465

1 - v1 error format

2466

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2467

2468

Returns:

2469

An object of the form:

2470

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2471

{ # Response for setting a breakpoint.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2472

"breakpoint": { # Represents the breakpoint specification, status and results. # Breakpoint resource.

2473

# The field `id` is guaranteed to be set (in addition to the echoed fileds).

2474

"status": { # Represents a contextual status message. # Breakpoint status.

2475

#

2476

# The status includes an error flag and a human readable message.

2477

# This field is usually unset. The message can be either

2478

# informational or an error message. Regardless, clients should always

2479

# display the text message back to the user.

2480

#

2481

# Error status indicates complete failure of the breakpoint.

2482

#

2483

# Example (non-final state): `Still loading symbols...`

2484

#

2485

# Examples (final state):

2486

#

2487

# * `Invalid line number` referring to location

2488

# * `Field f not found in class C` referring to condition

2489

# The message can indicate an error or informational status, and refer to

2490

# specific parts of the containing object.

2491

# For example, the `Breakpoint.status` field can indicate an error referring

2492

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2493

"isError": True or False, # Distinguishes errors from informational messages.

2494

"refersTo": "A String", # Reference to which the message applies.

2495

"description": { # Represents a message with parameters. # Status message text.

2496

"parameters": [ # Optional parameters to be embedded into the message.

2497

"A String",

2498

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2499

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2500

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2506

# is loaded. Again, $0 is very important.`

2507

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2508

},

2509

},

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2510

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

2511

# traffic optimization. It enables storing a variable once and reference

2512

# it from multiple variables, including variables stored in the

2513

# `variable_table` itself.

2514

# For example, the same `this` object, which may appear at many levels of

2515

# the stack, can have all of its data stored once in this table. The

2516

# stack frame variables then would hold only a reference to it.

2517

#

2518

# The variable `var_table_index` field is an index into this repeated field.

2519

# The stored objects are nameless and get their name from the referencing

2520

# variable. The effective variable is a merge of the referencing variable

2521

# and the referenced variable.

2522

{ # Represents a variable or an argument possibly of a compound object type.

2523

# Note how the following variables are represented:

2524

#

2525

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2530

#

2531

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2540

# name: "x",

2541

# type: "T",

2542

# members { name: "m1", value: "3", type: "int" },

2543

# members { name: "m2", value: "7", type: "int" }

2544

# }

2545

#

2546

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2552

# name: "p",

2553

# type: "T*",

2554

# value: "0x00500500",

2555

# members { name: "m1", value: "3", type: "int" },

2556

# members { name: "m2", value: "7", type: "int" }

2557

# }

2558

#

2559

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2564

# name: "p",

2565

# type: "T*",

2566

# value: "0x00400400"

2567

# status { is_error: true, description { format: "unavailable" } }

2568

# }

2569

#

2570

# The status should describe the reason for the missing value,

2571

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2572

#

2573

# Note that a null pointer should not have members.

2574

#

2575

# 5) An unnamed value:

2576

#

2577

# int* p = new int(7);

2578

#

2579

# { // Captured variable

2580

# name: "p",

2581

# value: "0x00500500",

2582

# type: "int*",

2583

# members { value: "7", type: "int" } }

2584

#

2585

# 6) An unnamed pointer where the pointee was not captured:

2586

#

2587

# int* p = new int(7);

2588

# int** pp = &p;

2589

#

2590

# { // Captured variable

2591

# name: "pp",

2592

# value: "0x00500500",

2593

# type: "int**",

2594

# members {

2595

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2605

# repeat in the output multiple times can be stored once in a shared

2606

# variable table and be referenced using the `var_table_index` field. The

2607

# variables stored in the shared table are nameless and are essentially

2608

# a partition of the complete variable. To reconstruct the complete

2609

# variable, merge the referencing variable with the referenced variable.

2610

#

2611

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2618

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2619

# { name: "r", type="T&", var_table_index: 3 }

2620

#

2621

# { // Shared variable table entry #3:

2622

# members { name: "m1", value: "3", type: "int" },

2623

# members { name: "m2", value: "7", type: "int" }

2624

# }

2625

#

2626

# Note that the pointer address is stored with the referencing variable

2627

# and not with the referenced variable. This allows the referenced variable

2628

# to be shared between pointers and references.

2629

#

2630

# The type field is optional. The debugger agent may or may not support it.

2631

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2632

# unset. A status of a single variable only applies to that variable or

2633

# expression. The rest of breakpoint data still remains valid. Variables

2634

# might be reported in error state even when breakpoint is not in final

2635

# state.

2636

#

2637

# The message may refer to variable name with `refers_to` set to

2638

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2639

# In either case variable value and members will be unset.

2640

#

2641

# Example of error message applied to name: `Invalid expression syntax`.

2642

#

2643

# Example of information message applied to value: `Not captured`.

2644

#

2645

# Examples of error message applied to value:

2646

#

2647

# * `Malformed string`,

2648

# * `Field f not found in class C`

2649

# * `Null pointer dereference`

2650

# The message can indicate an error or informational status, and refer to

2651

# specific parts of the containing object.

2652

# For example, the `Breakpoint.status` field can indicate an error referring

2653

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2654

"isError": True or False, # Distinguishes errors from informational messages.

2655

"refersTo": "A String", # Reference to which the message applies.

2656

"description": { # Represents a message with parameters. # Status message text.

2657

"parameters": [ # Optional parameters to be embedded into the message.

2658

"A String",

2659

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2660

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2661

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2667

# is loaded. Again, $0 is very important.`

2668

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2669

},

2670

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2671

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2672

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2673

# one variable can reference the same variable in the table. The

2674

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2675

"value": "A String", # Simple value of the variable.

2676

"members": [ # Members contained or pointed to by the variable.

2677

# Object with schema name: Variable

2678

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2679

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2680

# `var_table_index`, `type` goes next to `value`. The interpretation of

2681

# a type is agent specific. It is recommended to include the dynamic type

2682

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2683

},

2684

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2685

"userEmail": "A String", # E-mail address of the user that created this breakpoint

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2686

"logLevel": "A String", # Indicates the severity of the log. Only relevant when action is `LOG`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2687

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

2688

# displayed to the user.

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

2689

"a_key": "A String",

2690

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2691

"stackFrames": [ # The stack at breakpoint time.

2692

{ # Represents a stack frame context.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2693

"function": "A String", # Demangled function name at the call site.

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2694

"arguments": [ # Set of arguments passed to this function.

2695

# Note that this might not be populated for all stack frames.

2696

{ # Represents a variable or an argument possibly of a compound object type.

2697

# Note how the following variables are represented:

2698

#

2699

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2704

#

2705

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2714

# name: "x",

2715

# type: "T",

2716

# members { name: "m1", value: "3", type: "int" },

2717

# members { name: "m2", value: "7", type: "int" }

2718

# }

2719

#

2720

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2726

# name: "p",

2727

# type: "T*",

2728

# value: "0x00500500",

2729

# members { name: "m1", value: "3", type: "int" },

2730

# members { name: "m2", value: "7", type: "int" }

2731

# }

2732

#

2733

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2738

# name: "p",

2739

# type: "T*",

2740

# value: "0x00400400"

2741

# status { is_error: true, description { format: "unavailable" } }

2742

# }

2743

#

2744

# The status should describe the reason for the missing value,

2745

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2746

#

2747

# Note that a null pointer should not have members.

2748

#

2749

# 5) An unnamed value:

2750

#

2751

# int* p = new int(7);

2752

#

2753

# { // Captured variable

2754

# name: "p",

2755

# value: "0x00500500",

2756

# type: "int*",

2757

# members { value: "7", type: "int" } }

2758

#

2759

# 6) An unnamed pointer where the pointee was not captured:

2760

#

2761

# int* p = new int(7);

2762

# int** pp = &p;

2763

#

2764

# { // Captured variable

2765

# name: "pp",

2766

# value: "0x00500500",

2767

# type: "int**",

2768

# members {

2769

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2779

# repeat in the output multiple times can be stored once in a shared

2780

# variable table and be referenced using the `var_table_index` field. The

2781

# variables stored in the shared table are nameless and are essentially

2782

# a partition of the complete variable. To reconstruct the complete

2783

# variable, merge the referencing variable with the referenced variable.

2784

#

2785

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2792

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2793

# { name: "r", type="T&", var_table_index: 3 }

2794

#

2795

# { // Shared variable table entry #3:

2796

# members { name: "m1", value: "3", type: "int" },

2797

# members { name: "m2", value: "7", type: "int" }

2798

# }

2799

#

2800

# Note that the pointer address is stored with the referencing variable

2801

# and not with the referenced variable. This allows the referenced variable

2802

# to be shared between pointers and references.

2803

#

2804

# The type field is optional. The debugger agent may or may not support it.

2805

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2806

# unset. A status of a single variable only applies to that variable or

2807

# expression. The rest of breakpoint data still remains valid. Variables

2808

# might be reported in error state even when breakpoint is not in final

2809

# state.

2810

#

2811

# The message may refer to variable name with `refers_to` set to

2812

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2813

# In either case variable value and members will be unset.

2814

#

2815

# Example of error message applied to name: `Invalid expression syntax`.

2816

#

2817

# Example of information message applied to value: `Not captured`.

2818

#

2819

# Examples of error message applied to value:

2820

#

2821

# * `Malformed string`,

2822

# * `Field f not found in class C`

2823

# * `Null pointer dereference`

2824

# The message can indicate an error or informational status, and refer to

2825

# specific parts of the containing object.

2826

# For example, the `Breakpoint.status` field can indicate an error referring

2827

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2828

"isError": True or False, # Distinguishes errors from informational messages.

2829

"refersTo": "A String", # Reference to which the message applies.

2830

"description": { # Represents a message with parameters. # Status message text.

2831

"parameters": [ # Optional parameters to be embedded into the message.

2832

"A String",

2833

],

2834

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2835

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

2841

# is loaded. Again, $0 is very important.`

2842

# * `Please pay $$10 to use $0 instead of $1.`

2843

},

2844

},

2845

"name": "A String", # Name of the variable, if any.

2846

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2847

# one variable can reference the same variable in the table. The

2848

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2849

"value": "A String", # Simple value of the variable.

2850

"members": [ # Members contained or pointed to by the variable.

2851

# Object with schema name: Variable

2852

],

2853

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2854

# `var_table_index`, `type` goes next to `value`. The interpretation of

2855

# a type is agent specific. It is recommended to include the dynamic type

2856

# rather than a static type of an object.

2857

},

2858

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2859

"locals": [ # Set of local variables at the stack frame location.

2860

# Note that this might not be populated for all stack frames.

2861

{ # Represents a variable or an argument possibly of a compound object type.

2862

# Note how the following variables are represented:

2863

#

2864

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2869

#

2870

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2879

# name: "x",

2880

# type: "T",

2881

# members { name: "m1", value: "3", type: "int" },

2882

# members { name: "m2", value: "7", type: "int" }

2883

# }

2884

#

2885

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2891

# name: "p",

2892

# type: "T*",

2893

# value: "0x00500500",

2894

# members { name: "m1", value: "3", type: "int" },

2895

# members { name: "m2", value: "7", type: "int" }

2896

# }

2897

#

2898

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2903

# name: "p",

2904

# type: "T*",

2905

# value: "0x00400400"

2906

# status { is_error: true, description { format: "unavailable" } }

2907

# }

2908

#

2909

# The status should describe the reason for the missing value,

2910

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2911

#

2912

# Note that a null pointer should not have members.

2913

#

2914

# 5) An unnamed value:

2915

#

2916

# int* p = new int(7);

2917

#

2918

# { // Captured variable

2919

# name: "p",

2920

# value: "0x00500500",

2921

# type: "int*",

2922

# members { value: "7", type: "int" } }

2923

#

2924

# 6) An unnamed pointer where the pointee was not captured:

2925

#

2926

# int* p = new int(7);

2927

# int** pp = &p;

2928

#

2929

# { // Captured variable

2930

# name: "pp",

2931

# value: "0x00500500",

2932

# type: "int**",

2933

# members {

2934

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2944

# repeat in the output multiple times can be stored once in a shared

2945

# variable table and be referenced using the `var_table_index` field. The

2946

# variables stored in the shared table are nameless and are essentially

2947

# a partition of the complete variable. To reconstruct the complete

2948

# variable, merge the referencing variable with the referenced variable.

2949

#

2950

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2957

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2958

# { name: "r", type="T&", var_table_index: 3 }

2959

#

2960

# { // Shared variable table entry #3:

2961

# members { name: "m1", value: "3", type: "int" },

2962

# members { name: "m2", value: "7", type: "int" }

2963

# }

2964

#

2965

# Note that the pointer address is stored with the referencing variable

2966

# and not with the referenced variable. This allows the referenced variable

2967

# to be shared between pointers and references.

2968

#

2969

# The type field is optional. The debugger agent may or may not support it.

2970

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2971

# unset. A status of a single variable only applies to that variable or

2972

# expression. The rest of breakpoint data still remains valid. Variables

2973

# might be reported in error state even when breakpoint is not in final

2974

# state.

2975

#

2976

# The message may refer to variable name with `refers_to` set to

2977

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2978

# In either case variable value and members will be unset.

2979

#

2980

# Example of error message applied to name: `Invalid expression syntax`.

2981

#

2982

# Example of information message applied to value: `Not captured`.

2983

#

2984

# Examples of error message applied to value:

2985

#

2986

# * `Malformed string`,

2987

# * `Field f not found in class C`

2988

# * `Null pointer dereference`

2989

# The message can indicate an error or informational status, and refer to

2990

# specific parts of the containing object.

2991

# For example, the `Breakpoint.status` field can indicate an error referring

2992

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2993

"isError": True or False, # Distinguishes errors from informational messages.

2994

"refersTo": "A String", # Reference to which the message applies.

2995

"description": { # Represents a message with parameters. # Status message text.

2996

"parameters": [ # Optional parameters to be embedded into the message.

2997

"A String",

2998

],

2999

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3000

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

3006

# is loaded. Again, $0 is very important.`

3007

# * `Please pay $$10 to use $0 instead of $1.`

3008

},

3009

},

3010

"name": "A String", # Name of the variable, if any.

3011

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3012

# one variable can reference the same variable in the table. The

3013

# `var_table_index` field is an index into `variable_table` in Breakpoint.

3014

"value": "A String", # Simple value of the variable.

3015

"members": [ # Members contained or pointed to by the variable.

3016

# Object with schema name: Variable

3017

],

3018

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3019

# `var_table_index`, `type` goes next to `value`. The interpretation of

3020

# a type is agent specific. It is recommended to include the dynamic type

3021

# rather than a static type of an object.

3022

},

3023

],

3024

"location": { # Represents a location in the source code. # Source location of the call site.

3025

"path": "A String", # Path to the source file within the source context of the target binary.

3026

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3027

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3028

},

3029

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3030

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3031

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

3032

# The expressions are composed using expressions in the programming language

3033

# at the source location. If the breakpoint action is `LOG`, the evaluated

3034

# expressions are included in log statements.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3035

"A String",

3036

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3037

"location": { # Represents a location in the source code. # Breakpoint source location.

3038

"path": "A String", # Path to the source file within the source context of the target binary.

3039

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3040

},

3041

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

3042

# resolution.

3043

"action": "A String", # Action that the agent should perform when the code at the

3044

# breakpoint location is hit.

3045

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

3046

# the breakpoint hits. The message may include parameter placeholders `$0`,

3047

# `$1`, etc. These placeholders are replaced with the evaluated value

3048

# of the appropriate expression. Expressions not referenced in

3049

# `log_message_format` are not logged.

3050

#

3051

# Example: `Message received, id = $0, count = $1` with

3052

# `expressions` = `[ message.id, message.count ]`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3053

"isFinalState": True or False, # When true, indicates that this is a final result and the

3054

# breakpoint state will not change from here on.

3055

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

3056

# The evaluated expressions appear in exactly the same order they

3057

# are listed in the `expressions` field.

3058

# The `name` field holds the original expression text, the `value` or

3059

# `members` field holds the result of the evaluated expression.

3060

# If the expression cannot be evaluated, the `status` inside the `Variable`

3061

# will indicate an error and contain the error text.

3062

{ # Represents a variable or an argument possibly of a compound object type.

3063

# Note how the following variables are represented:

3064

#

3065

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

3070

#

3071

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

3080

# name: "x",

3081

# type: "T",

3082

# members { name: "m1", value: "3", type: "int" },

3083

# members { name: "m2", value: "7", type: "int" }

3084

# }

3085

#

3086

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

3092

# name: "p",

3093

# type: "T*",

3094

# value: "0x00500500",

3095

# members { name: "m1", value: "3", type: "int" },

3096

# members { name: "m2", value: "7", type: "int" }

3097

# }

3098

#

3099

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

3104

# name: "p",

3105

# type: "T*",

3106

# value: "0x00400400"

3107

# status { is_error: true, description { format: "unavailable" } }

3108

# }

3109

#

3110

# The status should describe the reason for the missing value,

3111

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

3112

#

3113

# Note that a null pointer should not have members.

3114

#

3115

# 5) An unnamed value:

3116

#

3117

# int* p = new int(7);

3118

#

3119

# { // Captured variable

3120

# name: "p",

3121

# value: "0x00500500",

3122

# type: "int*",

3123

# members { value: "7", type: "int" } }

3124

#

3125

# 6) An unnamed pointer where the pointee was not captured:

3126

#

3127

# int* p = new int(7);

3128

# int** pp = &p;

3129

#

3130

# { // Captured variable

3131

# name: "pp",

3132

# value: "0x00500500",

3133

# type: "int**",

3134

# members {

3135

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

3145

# repeat in the output multiple times can be stored once in a shared

3146

# variable table and be referenced using the `var_table_index` field. The

3147

# variables stored in the shared table are nameless and are essentially

3148

# a partition of the complete variable. To reconstruct the complete

3149

# variable, merge the referencing variable with the referenced variable.

3150

#

3151

# When using the shared variable table, the following variables:

#

# T x = { 3, 7 };

# T* p = &x;

# T& r = x;

#

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

3158

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

3159

# { name: "r", type="T&", var_table_index: 3 }

3160

#

3161

# { // Shared variable table entry #3:

3162

# members { name: "m1", value: "3", type: "int" },

3163

# members { name: "m2", value: "7", type: "int" }

3164

# }

3165

#

3166

# Note that the pointer address is stored with the referencing variable

3167

# and not with the referenced variable. This allows the referenced variable

3168

# to be shared between pointers and references.

3169

#

3170

# The type field is optional. The debugger agent may or may not support it.

3171

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

3172

# unset. A status of a single variable only applies to that variable or

3173

# expression. The rest of breakpoint data still remains valid. Variables

3174

# might be reported in error state even when breakpoint is not in final

3175

# state.

3176

#

3177

# The message may refer to variable name with `refers_to` set to

3178

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

3179

# In either case variable value and members will be unset.

3180

#

3181

# Example of error message applied to name: `Invalid expression syntax`.

3182

#

3183

# Example of information message applied to value: `Not captured`.

3184

#

3185

# Examples of error message applied to value:

3186

#

3187

# * `Malformed string`,

3188

# * `Field f not found in class C`

3189

# * `Null pointer dereference`

3190

# The message can indicate an error or informational status, and refer to

3191

# specific parts of the containing object.

3192

# For example, the `Breakpoint.status` field can indicate an error referring

3193

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3194

"isError": True or False, # Distinguishes errors from informational messages.

3195

"refersTo": "A String", # Reference to which the message applies.

3196

"description": { # Represents a message with parameters. # Status message text.

3197

"parameters": [ # Optional parameters to be embedded into the message.

3198

"A String",

3199

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3200

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3201

# `$1`, etc. to reference parameters. `$$` can be used to denote the `$`

# character.

#

# Examples:

#

# * `Failed to load '$0' which helps debug $1 the first time it

3207

# is loaded. Again, $0 is very important.`

3208

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3209

},

3210

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

3211

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3212

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3213

# one variable can reference the same variable in the table. The

3214

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

3215

"value": "A String", # Simple value of the variable.

3216

"members": [ # Members contained or pointed to by the variable.

3217

# Object with schema name: Variable

3218

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3219

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3220

# `var_table_index`, `type` goes next to `value`. The interpretation of

3221

# a type is agent specific. It is recommended to include the dynamic type

3222

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3223

},

3224

],

3225

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3226

"condition": "A String", # Condition that triggers the breakpoint.

3227

# The condition is a compound boolean expression composed using expressions

3228

# in a programming language at the source location.

Takashi Matsuo