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.

Bu Sun Kim

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

[diff] [blame^]

98

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

Takashi Matsuo

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

[diff] [blame]

99

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

100

Allowed values

101

1 - v1 error format

102

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

103

104

Returns:

105

An object of the form:

106

Sai Cheemalapati

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

[diff] [blame]

107

{ # A generic empty message that you can re-use to avoid defining duplicated

108

# empty messages in your APIs. A typical example is to use it as the request

109

# or the response type of an API method. For instance:

110

#

111

# service Foo {

112

# rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);

113

# }

114

#

115

# The JSON representation for `Empty` is empty JSON object `{}`.

Takashi Matsuo

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

[diff] [blame]

}</pre>

</div>

Jon Wayne Parrott

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

[diff] [blame]

120

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

Takashi Matsuo

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

[diff] [blame]

121

<pre>Gets breakpoint information.

122

123

Args:

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.

Bu Sun Kim

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

[diff] [blame^]

127

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

Takashi Matsuo

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

[diff] [blame]

128

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

129

Allowed values

130

1 - v1 error format

131

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

132

133

Returns:

134

An object of the form:

135

Jon Wayne Parrott

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

[diff] [blame]

136

{ # Response for getting breakpoint information.

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

Bu Sun Kim

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

[diff] [blame^]

351

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

352

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

353

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

354

# of the appropriate expression. Expressions not referenced in

355

# `log_message_format` are not logged.

356

#

357

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

358

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

Jon Wayne Parrott

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

[diff] [blame]

359

"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]

360

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

361

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

362

"a_key": "A String",

363

},

Bu Sun Kim

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

[diff] [blame^]

364

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

365

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

366

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

367

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

Thomas Coffee

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

[diff] [blame]

368

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

369

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

370

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

371

# Note how the following variables are represented:

372

#

373

# 1) A simple variable:

#

# int x = 5

#

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

378

#

379

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

388

# name: "x",

389

# type: "T",

390

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

391

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

392

# }

393

#

394

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

400

# name: "p",

401

# type: "T*",

402

# value: "0x00500500",

403

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

404

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

405

# }

406

#

407

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

#

# T* p = new T;

#

# { // Captured variable

412

# name: "p",

413

# type: "T*",

414

# value: "0x00400400"

415

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

416

# }

417

#

418

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

419

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

420

#

421

# Note that a null pointer should not have members.

422

#

423

# 5) An unnamed value:

424

#

425

# int* p = new int(7);

426

#

427

# { // Captured variable

428

# name: "p",

429

# value: "0x00500500",

430

# type: "int*",

431

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

432

#

433

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

434

#

435

# int* p = new int(7);

436

# int** pp = &p;

437

#

438

# { // Captured variable

439

# name: "pp",

440

# value: "0x00500500",

441

# type: "int**",

442

# members {

443

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

453

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

454

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

455

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

456

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

457

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

458

#

459

# 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

466

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

467

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

468

#

469

# { // Shared variable table entry #3:

470

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

471

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

472

# }

473

#

474

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

475

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

476

# to be shared between pointers and references.

477

#

478

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

479

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

480

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

481

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

482

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

483

# state.

484

#

485

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

486

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

487

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

488

#

489

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

490

#

491

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

492

#

493

# Examples of error message applied to value:

494

#

495

# * `Malformed string`,

496

# * `Field f not found in class C`

497

# * `Null pointer dereference`

498

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

499

# specific parts of the containing object.

500

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

501

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

502

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

503

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

504

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

505

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

506

"A String",

507

],

508

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

509

# `$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

515

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

516

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

517

},

518

},

519

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

520

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

521

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

522

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

523

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

524

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

525

# Object with schema name: Variable

526

],

527

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

528

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

529

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

530

# rather than a static type of an object.

531

},

532

],

Sai Cheemalapati

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

[diff] [blame]

533

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

534

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

535

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

536

# Note how the following variables are represented:

537

#

538

# 1) A simple variable:

#

# int x = 5

#

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

543

#

544

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

553

# name: "x",

554

# type: "T",

555

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

556

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

557

# }

558

#

559

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

565

# name: "p",

566

# type: "T*",

567

# value: "0x00500500",

568

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

569

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

570

# }

571

#

572

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

#

# T* p = new T;

#

# { // Captured variable

577

# name: "p",

578

# type: "T*",

579

# value: "0x00400400"

580

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

581

# }

582

#

583

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

584

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

585

#

586

# Note that a null pointer should not have members.

587

#

588

# 5) An unnamed value:

589

#

590

# int* p = new int(7);

591

#

592

# { // Captured variable

593

# name: "p",

594

# value: "0x00500500",

595

# type: "int*",

596

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

597

#

598

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

599

#

600

# int* p = new int(7);

601

# int** pp = &p;

602

#

603

# { // Captured variable

604

# name: "pp",

605

# value: "0x00500500",

606

# type: "int**",

607

# members {

608

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

618

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

619

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

620

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

621

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

622

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

623

#

624

# 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

631

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

632

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

633

#

634

# { // Shared variable table entry #3:

635

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

636

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

637

# }

638

#

639

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

640

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

641

# to be shared between pointers and references.

642

#

643

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

644

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

645

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

646

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

647

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

648

# state.

649

#

650

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

651

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

652

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

653

#

654

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

655

#

656

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

657

#

658

# Examples of error message applied to value:

659

#

660

# * `Malformed string`,

661

# * `Field f not found in class C`

662

# * `Null pointer dereference`

663

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

664

# specific parts of the containing object.

665

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

666

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

667

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

668

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

669

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

670

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

671

"A String",

672

],

673

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

674

# `$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

680

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

681

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

682

},

683

},

684

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

685

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

686

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

687

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

688

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

689

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

690

# Object with schema name: Variable

691

],

692

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

693

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

694

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

695

# rather than a static type of an object.

696

},

697

],

698

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

Bu Sun Kim

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

[diff] [blame^]

699

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

700

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

701

# this field.

Sai Cheemalapati

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

[diff] [blame]

702

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

703

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

704

},

Takashi Matsuo

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

[diff] [blame]

705

},

706

],

Sai Cheemalapati

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

[diff] [blame]

707

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

Sai Cheemalapati

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

[diff] [blame]

708

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

Bu Sun Kim

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

[diff] [blame^]

709

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

710

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

711

# this field.

Sai Cheemalapati

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

[diff] [blame]

712

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

713

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

714

},

715

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

716

# resolution.

717

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

718

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame^]

719

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

720

# The expressions are composed using expressions in the programming language

721

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

722

# expressions are included in log statements.

723

"A String",

724

],

Sai Cheemalapati

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

[diff] [blame]

725

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

726

# breakpoint state will not change from here on.

727

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

728

# The evaluated expressions appear in exactly the same order they

729

# are listed in the `expressions` field.

730

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

731

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

732

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

733

# will indicate an error and contain the error text.

734

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

735

# Note how the following variables are represented:

736

#

737

# 1) A simple variable:

#

# int x = 5

#

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

742

#

743

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

752

# name: "x",

753

# type: "T",

754

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

755

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

756

# }

757

#

758

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

764

# name: "p",

765

# type: "T*",

766

# value: "0x00500500",

767

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

768

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

769

# }

770

#

771

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

#

# T* p = new T;

#

# { // Captured variable

776

# name: "p",

777

# type: "T*",

778

# value: "0x00400400"

779

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

780

# }

781

#

782

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

783

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

784

#

785

# Note that a null pointer should not have members.

786

#

787

# 5) An unnamed value:

788

#

789

# int* p = new int(7);

790

#

791

# { // Captured variable

792

# name: "p",

793

# value: "0x00500500",

794

# type: "int*",

795

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

796

#

797

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

798

#

799

# int* p = new int(7);

800

# int** pp = &p;

801

#

802

# { // Captured variable

803

# name: "pp",

804

# value: "0x00500500",

805

# type: "int**",

806

# members {

807

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

817

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

818

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

819

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

820

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

821

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

822

#

823

# 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

830

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

831

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

832

#

833

# { // Shared variable table entry #3:

834

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

835

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

836

# }

837

#

838

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

839

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

840

# to be shared between pointers and references.

841

#

842

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

843

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

844

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

845

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

846

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

847

# state.

848

#

849

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

850

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

851

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

852

#

853

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

854

#

855

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

856

#

857

# Examples of error message applied to value:

858

#

859

# * `Malformed string`,

860

# * `Field f not found in class C`

861

# * `Null pointer dereference`

862

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

863

# specific parts of the containing object.

864

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

865

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

Takashi Matsuo

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

[diff] [blame]

866

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

867

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

868

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

869

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

870

"A String",

871

],

Sai Cheemalapati

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

[diff] [blame]

872

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

873

# `$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

879

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

880

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

Takashi Matsuo

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

[diff] [blame]

881

},

882

},

Jon Wayne Parrott

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

[diff] [blame]

883

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

Sai Cheemalapati

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

[diff] [blame]

884

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

885

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

886

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

Jon Wayne Parrott

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

[diff] [blame]

887

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

888

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

889

# Object with schema name: Variable

890

],

Sai Cheemalapati

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

[diff] [blame]

891

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

892

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

893

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

894

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

895

},

896

],

897

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

Sai Cheemalapati

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

[diff] [blame]

898

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

899

# The condition is a compound boolean expression composed using expressions

900

# 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]

906

<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]

907

<pre>Lists all breakpoints for the debuggee.

Takashi Matsuo

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

[diff] [blame]

908

909

Args:

Jon Wayne Parrott

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

[diff] [blame]

910

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

Sai Cheemalapati

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

[diff] [blame]

911

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

912

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

913

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

914

breakpoints. Otherwise, it includes only active breakpoints.

Takashi Matsuo

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

[diff] [blame]

915

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.

Bu Sun Kim

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

[diff] [blame^]

920

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

Sai Cheemalapati

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

[diff] [blame]

921

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

922

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

Takashi Matsuo

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

[diff] [blame]

923

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

Sai Cheemalapati

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

[diff] [blame]

924

waitToken: string, A wait token that, if specified, blocks the call until the breakpoints

925

list has changed, or a server selected timeout has expired. The value

926

should be set from the last response. The error code

927

`google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which

928

should be called again with the same `wait_token`.

Takashi Matsuo

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

[diff] [blame]

929

930

Returns:

931

An object of the form:

932

Jon Wayne Parrott

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

[diff] [blame]

933

{ # Response for listing breakpoints.

Sai Cheemalapati

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

[diff] [blame]

934

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

935

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

936

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

937

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

938

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

Bu Sun Kim

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

[diff] [blame^]

939

# are cleared on each breakpoint regardless of its status.

Takashi Matsuo

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

[diff] [blame]

940

{ # Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

941

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

942

#

943

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

944

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

945

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

946

# display the text message back to the user.

947

#

948

# Error status indicates complete failure of the breakpoint.

949

#

950

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

951

#

952

# Examples (final state):

953

#

954

# * `Invalid line number` referring to location

955

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

956

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

957

# specific parts of the containing object.

958

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

959

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

Takashi Matsuo

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

[diff] [blame]

960

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

961

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

962

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

963

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

964

"A String",

965

],

Sai Cheemalapati

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

[diff] [blame]

966

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

967

# `$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

973

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

974

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

Takashi Matsuo

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

[diff] [blame]

975

},

976

},

Sai Cheemalapati

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

[diff] [blame]

977

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

978

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

979

# it from multiple variables, including variables stored in the

980

# `variable_table` itself.

981

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

982

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

983

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

984

#

985

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

986

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

987

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

988

# and the referenced variable.

989

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

990

# Note how the following variables are represented:

991

#

992

# 1) A simple variable:

#

# int x = 5

#

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

997

#

998

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1007

# name: "x",

1008

# type: "T",

1009

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

1010

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

1011

# }

1012

#

1013

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1019

# name: "p",

1020

# type: "T*",

1021

# value: "0x00500500",

1022

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

1023

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

1024

# }

1025

#

1026

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

#

# T* p = new T;

#

# { // Captured variable

1031

# name: "p",

1032

# type: "T*",

1033

# value: "0x00400400"

1034

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

1035

# }

1036

#

1037

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

1038

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

1039

#

1040

# Note that a null pointer should not have members.

1041

#

1042

# 5) An unnamed value:

1043

#

1044

# int* p = new int(7);

1045

#

1046

# { // Captured variable

1047

# name: "p",

1048

# value: "0x00500500",

1049

# type: "int*",

1050

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

1051

#

1052

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

1053

#

1054

# int* p = new int(7);

1055

# int** pp = &p;

1056

#

1057

# { // Captured variable

1058

# name: "pp",

1059

# value: "0x00500500",

1060

# type: "int**",

1061

# members {

1062

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1072

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

1073

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

1074

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

1075

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

1076

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

1077

#

1078

# 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

1085

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

1086

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

1087

#

1088

# { // Shared variable table entry #3:

1089

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

1090

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

1091

# }

1092

#

1093

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

1094

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

1095

# to be shared between pointers and references.

1096

#

1097

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

1098

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

1099

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

1100

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

1101

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

1102

# state.

1103

#

1104

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

1105

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

1106

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

1107

#

1108

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

1109

#

1110

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

1111

#

1112

# Examples of error message applied to value:

1113

#

1114

# * `Malformed string`,

1115

# * `Field f not found in class C`

1116

# * `Null pointer dereference`

1117

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

1118

# specific parts of the containing object.

1119

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

1120

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

Takashi Matsuo

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

[diff] [blame]

1121

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

1122

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

1123

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

1124

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

1125

"A String",

1126

],

Sai Cheemalapati

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

[diff] [blame]

1127

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

1128

# `$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

1134

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

1135

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

Takashi Matsuo

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

[diff] [blame]

1136

},

1137

},

Jon Wayne Parrott

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

[diff] [blame]

1138

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

Sai Cheemalapati

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

[diff] [blame]

1139

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

1140

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

1141

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

Jon Wayne Parrott

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

[diff] [blame]

1142

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

1143

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

1144

# Object with schema name: Variable

1145

],

Sai Cheemalapati

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

[diff] [blame]

1146

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

1147

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

1148

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

1149

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1150

},

1151

],

Sai Cheemalapati

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

[diff] [blame]

1152

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

Bu Sun Kim

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

[diff] [blame^]

1153

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

1154

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

1155

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

1156

# of the appropriate expression. Expressions not referenced in

1157

# `log_message_format` are not logged.

1158

#

1159

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

1160

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

Jon Wayne Parrott

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

[diff] [blame]

1161

"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]

1162

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

1163

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

1164

"a_key": "A String",

1165

},

Bu Sun Kim

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

[diff] [blame^]

1166

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

1167

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

1168

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1169

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

Thomas Coffee

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

[diff] [blame]

1170

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

1171

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

1172

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

1173

# Note how the following variables are represented:

1174

#

1175

# 1) A simple variable:

#

# int x = 5

#

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

1180

#

1181

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1190

# name: "x",

1191

# type: "T",

1192

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

1193

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

1194

# }

1195

#

1196

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1202

# name: "p",

1203

# type: "T*",

1204

# value: "0x00500500",

1205

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

1206

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

1207

# }

1208

#

1209

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

#

# T* p = new T;

#

# { // Captured variable

1214

# name: "p",

1215

# type: "T*",

1216

# value: "0x00400400"

1217

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

1218

# }

1219

#

1220

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

1221

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

1222

#

1223

# Note that a null pointer should not have members.

1224

#

1225

# 5) An unnamed value:

1226

#

1227

# int* p = new int(7);

1228

#

1229

# { // Captured variable

1230

# name: "p",

1231

# value: "0x00500500",

1232

# type: "int*",

1233

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

1234

#

1235

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

1236

#

1237

# int* p = new int(7);

1238

# int** pp = &p;

1239

#

1240

# { // Captured variable

1241

# name: "pp",

1242

# value: "0x00500500",

1243

# type: "int**",

1244

# members {

1245

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1255

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

1256

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

1257

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

1258

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

1259

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

1260

#

1261

# 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

1268

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

1269

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

1270

#

1271

# { // Shared variable table entry #3:

1272

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

1273

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

1274

# }

1275

#

1276

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

1277

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

1278

# to be shared between pointers and references.

1279

#

1280

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

1281

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

1282

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

1283

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

1284

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

1285

# state.

1286

#

1287

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

1288

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

1289

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

1290

#

1291

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

1292

#

1293

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

1294

#

1295

# Examples of error message applied to value:

1296

#

1297

# * `Malformed string`,

1298

# * `Field f not found in class C`

1299

# * `Null pointer dereference`

1300

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

1301

# specific parts of the containing object.

1302

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

1303

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

1304

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

1305

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

1306

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

1307

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

1308

"A String",

1309

],

1310

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

1311

# `$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

1317

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

1318

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

1319

},

1320

},

1321

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

1322

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

1323

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

1324

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

1325

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

1326

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

1327

# Object with schema name: Variable

1328

],

1329

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

1330

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

1331

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

1332

# rather than a static type of an object.

1333

},

1334

],

Sai Cheemalapati

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

[diff] [blame]

1335

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

1336

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

1337

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

1338

# Note how the following variables are represented:

1339

#

1340

# 1) A simple variable:

#

# int x = 5

#

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

1345

#

1346

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1355

# name: "x",

1356

# type: "T",

1357

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

1358

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

1359

# }

1360

#

1361

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1367

# name: "p",

1368

# type: "T*",

1369

# value: "0x00500500",

1370

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

1371

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

1372

# }

1373

#

1374

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

#

# T* p = new T;

#

# { // Captured variable

1379

# name: "p",

1380

# type: "T*",

1381

# value: "0x00400400"

1382

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

1383

# }

1384

#

1385

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

1386

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

1387

#

1388

# Note that a null pointer should not have members.

1389

#

1390

# 5) An unnamed value:

1391

#

1392

# int* p = new int(7);

1393

#

1394

# { // Captured variable

1395

# name: "p",

1396

# value: "0x00500500",

1397

# type: "int*",

1398

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

1399

#

1400

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

1401

#

1402

# int* p = new int(7);

1403

# int** pp = &p;

1404

#

1405

# { // Captured variable

1406

# name: "pp",

1407

# value: "0x00500500",

1408

# type: "int**",

1409

# members {

1410

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1420

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

1421

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

1422

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

1423

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

1424

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

1425

#

1426

# 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

1433

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

1434

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

1435

#

1436

# { // Shared variable table entry #3:

1437

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

1438

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

1439

# }

1440

#

1441

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

1442

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

1443

# to be shared between pointers and references.

1444

#

1445

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

1446

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

1447

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

1448

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

1449

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

1450

# state.

1451

#

1452

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

1453

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

1454

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

1455

#

1456

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

1457

#

1458

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

1459

#

1460

# Examples of error message applied to value:

1461

#

1462

# * `Malformed string`,

1463

# * `Field f not found in class C`

1464

# * `Null pointer dereference`

1465

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

1466

# specific parts of the containing object.

1467

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

1468

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

1469

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

1470

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

1471

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

1472

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

1473

"A String",

1474

],

1475

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

1476

# `$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

1482

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

1483

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

1484

},

1485

},

1486

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

1487

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

1488

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

1489

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

1490

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

1491

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

1492

# Object with schema name: Variable

1493

],

1494

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

1495

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

1496

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

1497

# rather than a static type of an object.

1498

},

1499

],

1500

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

Bu Sun Kim

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

[diff] [blame^]

1501

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

1502

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

1503

# this field.

Sai Cheemalapati

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

[diff] [blame]

1504

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

1505

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

1506

},

Takashi Matsuo

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

[diff] [blame]

1507

},

1508

],

Sai Cheemalapati

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

[diff] [blame]

1509

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

Sai Cheemalapati

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

[diff] [blame]

1510

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

Bu Sun Kim

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

[diff] [blame^]

1511

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

1512

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

1513

# this field.

Sai Cheemalapati

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

[diff] [blame]

1514

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

1515

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

1516

},

1517

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

1518

# resolution.

1519

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

1520

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame^]

1521

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

1522

# The expressions are composed using expressions in the programming language

1523

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

1524

# expressions are included in log statements.

1525

"A String",

1526

],

Sai Cheemalapati

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

[diff] [blame]

1527

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

1528

# breakpoint state will not change from here on.

1529

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

1530

# The evaluated expressions appear in exactly the same order they

1531

# are listed in the `expressions` field.

1532

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

1533

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

1534

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

1535

# will indicate an error and contain the error text.

1536

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

1537

# Note how the following variables are represented:

1538

#

1539

# 1) A simple variable:

#

# int x = 5

#

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

1544

#

1545

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1554

# name: "x",

1555

# type: "T",

1556

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

1557

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

1558

# }

1559

#

1560

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1566

# name: "p",

1567

# type: "T*",

1568

# value: "0x00500500",

1569

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

1570

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

1571

# }

1572

#

1573

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

#

# T* p = new T;

#

# { // Captured variable

1578

# name: "p",

1579

# type: "T*",

1580

# value: "0x00400400"

1581

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

1582

# }

1583

#

1584

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

1585

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

1586

#

1587

# Note that a null pointer should not have members.

1588

#

1589

# 5) An unnamed value:

1590

#

1591

# int* p = new int(7);

1592

#

1593

# { // Captured variable

1594

# name: "p",

1595

# value: "0x00500500",

1596

# type: "int*",

1597

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

1598

#

1599

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

1600

#

1601

# int* p = new int(7);

1602

# int** pp = &p;

1603

#

1604

# { // Captured variable

1605

# name: "pp",

1606

# value: "0x00500500",

1607

# type: "int**",

1608

# members {

1609

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1619

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

1620

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

1621

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

1622

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

1623

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

1624

#

1625

# 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

1632

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

1633

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

1634

#

1635

# { // Shared variable table entry #3:

1636

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

1637

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

1638

# }

1639

#

1640

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

1641

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

1642

# to be shared between pointers and references.

1643

#

1644

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

1645

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

1646

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

1647

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

1648

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

1649

# state.

1650

#

1651

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

1652

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

1653

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

1654

#

1655

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

1656

#

1657

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

1658

#

1659

# Examples of error message applied to value:

1660

#

1661

# * `Malformed string`,

1662

# * `Field f not found in class C`

1663

# * `Null pointer dereference`

1664

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

1665

# specific parts of the containing object.

1666

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

1667

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

Takashi Matsuo

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

[diff] [blame]

1668

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

1669

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

1670

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

1671

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

1672

"A String",

1673

],

Sai Cheemalapati

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

[diff] [blame]

1674

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

1675

# `$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

1681

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

1682

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

Takashi Matsuo

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

[diff] [blame]

1683

},

1684

},

Jon Wayne Parrott

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

[diff] [blame]

1685

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

Sai Cheemalapati

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

[diff] [blame]

1686

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

1687

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

1688

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

Jon Wayne Parrott

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

[diff] [blame]

1689

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

1690

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

1691

# Object with schema name: Variable

1692

],

Sai Cheemalapati

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

[diff] [blame]

1693

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

1694

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

1695

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

1696

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1697

},

1698

],

1699

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

Sai Cheemalapati

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

[diff] [blame]

1700

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

1701

# The condition is a compound boolean expression composed using expressions

1702

# 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]

1709

<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]

1710

<pre>Sets the breakpoint to the debuggee.

1711

1712

Args:

Jon Wayne Parrott

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

[diff] [blame]

1713

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]

1714

body: object, The request body. (required)

1715

The object takes the form of:

1716

1717

{ # Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

1718

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

1719

#

1720

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

1721

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

1722

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

1723

# display the text message back to the user.

1724

#

1725

# Error status indicates complete failure of the breakpoint.

1726

#

1727

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

1728

#

1729

# Examples (final state):

1730

#

1731

# * `Invalid line number` referring to location

1732

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

1733

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

1734

# specific parts of the containing object.

1735

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

1736

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

Takashi Matsuo

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

[diff] [blame]

1737

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

1738

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

1739

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

1740

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

1741

"A String",

1742

],

Sai Cheemalapati

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

[diff] [blame]

1743

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

1744

# `$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

1750

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

1751

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

Takashi Matsuo

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

[diff] [blame]

1752

},

1753

},

Sai Cheemalapati

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

[diff] [blame]

1754

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

1755

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

1756

# it from multiple variables, including variables stored in the

1757

# `variable_table` itself.

1758

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

1759

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

1760

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

1761

#

1762

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

1763

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

1764

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

1765

# and the referenced variable.

1766

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

1767

# Note how the following variables are represented:

1768

#

1769

# 1) A simple variable:

#

# int x = 5

#

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

1774

#

1775

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1784

# name: "x",

1785

# type: "T",

1786

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

1787

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

1788

# }

1789

#

1790

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1796

# name: "p",

1797

# type: "T*",

1798

# value: "0x00500500",

1799

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

1800

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

1801

# }

1802

#

1803

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

#

# T* p = new T;

#

# { // Captured variable

1808

# name: "p",

1809

# type: "T*",

1810

# value: "0x00400400"

1811

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

1812

# }

1813

#

1814

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

1815

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

1816

#

1817

# Note that a null pointer should not have members.

1818

#

1819

# 5) An unnamed value:

1820

#

1821

# int* p = new int(7);

1822

#

1823

# { // Captured variable

1824

# name: "p",

1825

# value: "0x00500500",

1826

# type: "int*",

1827

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

1828

#

1829

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

1830

#

1831

# int* p = new int(7);

1832

# int** pp = &p;

1833

#

1834

# { // Captured variable

1835

# name: "pp",

1836

# value: "0x00500500",

1837

# type: "int**",

1838

# members {

1839

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1849

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

1850

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

1851

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

1852

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

1853

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

1854

#

1855

# 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

1862

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

1863

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

1864

#

1865

# { // Shared variable table entry #3:

1866

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

1867

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

1868

# }

1869

#

1870

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

1871

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

1872

# to be shared between pointers and references.

1873

#

1874

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

1875

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

1876

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

1877

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

1878

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

1879

# state.

1880

#

1881

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

1882

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

1883

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

1884

#

1885

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

1886

#

1887

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

1888

#

1889

# Examples of error message applied to value:

1890

#

1891

# * `Malformed string`,

1892

# * `Field f not found in class C`

1893

# * `Null pointer dereference`

1894

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

1895

# specific parts of the containing object.

1896

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

1897

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

Takashi Matsuo

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

[diff] [blame]

1898

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

1899

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

1900

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

1901

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

1902

"A String",

1903

],

Sai Cheemalapati

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

[diff] [blame]

1904

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

1905

# `$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

1911

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

1912

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

Takashi Matsuo

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

[diff] [blame]

1913

},

1914

},

Jon Wayne Parrott

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

[diff] [blame]

1915

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

Sai Cheemalapati

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

[diff] [blame]

1916

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

1917

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

1918

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

Jon Wayne Parrott

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

[diff] [blame]

1919

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

1920

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

1921

# Object with schema name: Variable

1922

],

Sai Cheemalapati

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

[diff] [blame]

1923

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

1924

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

1925

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

1926

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1927

},

1928

],

Sai Cheemalapati

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

[diff] [blame]

1929

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

Bu Sun Kim

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

[diff] [blame^]

1930

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

1931

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

1932

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

1933

# of the appropriate expression. Expressions not referenced in

1934

# `log_message_format` are not logged.

1935

#

1936

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

1937

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

Jon Wayne Parrott

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

[diff] [blame]

1938

"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]

1939

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

1940

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

1941

"a_key": "A String",

1942

},

Bu Sun Kim

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

[diff] [blame^]

1943

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

1944

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

1945

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1946

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

Thomas Coffee

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

[diff] [blame]

1947

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

1948

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

1949

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

1950

# Note how the following variables are represented:

1951

#

1952

# 1) A simple variable:

#

# int x = 5

#

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

1957

#

1958

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1967

# name: "x",

1968

# type: "T",

1969

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

1970

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

1971

# }

1972

#

1973

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1979

# name: "p",

1980

# type: "T*",

1981

# value: "0x00500500",

1982

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

1983

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

1984

# }

1985

#

1986

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

#

# T* p = new T;

#

# { // Captured variable

1991

# name: "p",

1992

# type: "T*",

1993

# value: "0x00400400"

1994

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

1995

# }

1996

#

1997

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

1998

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

1999

#

2000

# Note that a null pointer should not have members.

2001

#

2002

# 5) An unnamed value:

2003

#

2004

# int* p = new int(7);

2005

#

2006

# { // Captured variable

2007

# name: "p",

2008

# value: "0x00500500",

2009

# type: "int*",

2010

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

2011

#

2012

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

2013

#

2014

# int* p = new int(7);

2015

# int** pp = &p;

2016

#

2017

# { // Captured variable

2018

# name: "pp",

2019

# value: "0x00500500",

2020

# type: "int**",

2021

# members {

2022

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

2032

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

2033

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

2034

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

2035

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

2036

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

2037

#

2038

# 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

2045

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

2046

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

2047

#

2048

# { // Shared variable table entry #3:

2049

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

2050

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

2051

# }

2052

#

2053

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

2054

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

2055

# to be shared between pointers and references.

2056

#

2057

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

2058

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

2059

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

2060

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

2061

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

2062

# state.

2063

#

2064

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

2065

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

2066

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

2067

#

2068

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

2069

#

2070

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

2071

#

2072

# Examples of error message applied to value:

2073

#

2074

# * `Malformed string`,

2075

# * `Field f not found in class C`

2076

# * `Null pointer dereference`

2077

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

2078

# specific parts of the containing object.

2079

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

2080

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

2081

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

2082

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

2083

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

2084

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

2085

"A String",

2086

],

2087

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

2088

# `$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

2094

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

2095

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

2096

},

2097

},

2098

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

2099

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

2100

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

2101

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

2102

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

2103

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

2104

# Object with schema name: Variable

2105

],

2106

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

2107

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

2108

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

2109

# rather than a static type of an object.

2110

},

2111

],

Sai Cheemalapati

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

[diff] [blame]

2112

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

2113

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

2114

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

2115

# Note how the following variables are represented:

2116

#

2117

# 1) A simple variable:

#

# int x = 5

#

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

2122

#

2123

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2132

# name: "x",

2133

# type: "T",

2134

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

2135

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

2136

# }

2137

#

2138

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2144

# name: "p",

2145

# type: "T*",

2146

# value: "0x00500500",

2147

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

2148

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

2149

# }

2150

#

2151

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

#

# T* p = new T;

#

# { // Captured variable

2156

# name: "p",

2157

# type: "T*",

2158

# value: "0x00400400"

2159

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

2160

# }

2161

#

2162

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

2163

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

2164

#

2165

# Note that a null pointer should not have members.

2166

#

2167

# 5) An unnamed value:

2168

#

2169

# int* p = new int(7);

2170

#

2171

# { // Captured variable

2172

# name: "p",

2173

# value: "0x00500500",

2174

# type: "int*",

2175

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

2176

#

2177

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

2178

#

2179

# int* p = new int(7);

2180

# int** pp = &p;

2181

#

2182

# { // Captured variable

2183

# name: "pp",

2184

# value: "0x00500500",

2185

# type: "int**",

2186

# members {

2187

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

2197

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

2198

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

2199

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

2200

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

2201

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

2202

#

2203

# 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

2210

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

2211

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

2212

#

2213

# { // Shared variable table entry #3:

2214

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

2215

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

2216

# }

2217

#

2218

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

2219

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

2220

# to be shared between pointers and references.

2221

#

2222

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

2223

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

2224

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

2225

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

2226

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

2227

# state.

2228

#

2229

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

2230

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

2231

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

2232

#

2233

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

2234

#

2235

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

2236

#

2237

# Examples of error message applied to value:

2238

#

2239

# * `Malformed string`,

2240

# * `Field f not found in class C`

2241

# * `Null pointer dereference`

2242

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

2243

# specific parts of the containing object.

2244

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

2245

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

2246

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

2247

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

2248

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

2249

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

2250

"A String",

2251

],

2252

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

2253

# `$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

2259

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

2260

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

2261

},

2262

},

2263

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

2264

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

2265

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

2266

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

2267

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

2268

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

2269

# Object with schema name: Variable

2270

],

2271

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

2272

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

2273

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

2274

# rather than a static type of an object.

2275

},

2276

],

2277

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

Bu Sun Kim

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

[diff] [blame^]

2278

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

2279

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

2280

# this field.

Sai Cheemalapati

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

[diff] [blame]

2281

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

2282

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

2283

},

Takashi Matsuo

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

[diff] [blame]

2284

},

2285

],

Sai Cheemalapati

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

[diff] [blame]

2286

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2287

"location": { # Represents a location in the source code. # Breakpoint source location.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

2288

"column": 42, # Column within a line. The first column in a line as the value `1`.

2289

# Agents that do not support setting breakpoints on specific columns ignore

2290

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2291

"path": "A String", # Path to the source file within the source context of the target binary.

2292

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2293

},

2294

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

2295

# resolution.

2296

"action": "A String", # Action that the agent should perform when the code at the

2297

# breakpoint location is hit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

2298

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

2299

# The expressions are composed using expressions in the programming language

2300

# at the source location. If the breakpoint action is `LOG`, the evaluated

2301

# expressions are included in log statements.

2302

"A String",

2303

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2304

"isFinalState": True or False, # When true, indicates that this is a final result and the

2305

# breakpoint state will not change from here on.

2306

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

2307

# The evaluated expressions appear in exactly the same order they

2308

# are listed in the `expressions` field.

2309

# The `name` field holds the original expression text, the `value` or

2310

# `members` field holds the result of the evaluated expression.

2311

# If the expression cannot be evaluated, the `status` inside the `Variable`

2312

# will indicate an error and contain the error text.

2313

{ # Represents a variable or an argument possibly of a compound object type.

2314

# Note how the following variables are represented:

2315

#

2316

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2321

#

2322

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2331

# name: "x",

2332

# type: "T",

2333

# members { name: "m1", value: "3", type: "int" },

2334

# members { name: "m2", value: "7", type: "int" }

2335

# }

2336

#

2337

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2343

# name: "p",

2344

# type: "T*",

2345

# value: "0x00500500",

2346

# members { name: "m1", value: "3", type: "int" },

2347

# members { name: "m2", value: "7", type: "int" }

2348

# }

2349

#

2350

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2355

# name: "p",

2356

# type: "T*",

2357

# value: "0x00400400"

2358

# status { is_error: true, description { format: "unavailable" } }

2359

# }

2360

#

2361

# The status should describe the reason for the missing value,

2362

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2363

#

2364

# Note that a null pointer should not have members.

2365

#

2366

# 5) An unnamed value:

2367

#

2368

# int* p = new int(7);

2369

#

2370

# { // Captured variable

2371

# name: "p",

2372

# value: "0x00500500",

2373

# type: "int*",

2374

# members { value: "7", type: "int" } }

2375

#

2376

# 6) An unnamed pointer where the pointee was not captured:

2377

#

2378

# int* p = new int(7);

2379

# int** pp = &p;

2380

#

2381

# { // Captured variable

2382

# name: "pp",

2383

# value: "0x00500500",

2384

# type: "int**",

2385

# members {

2386

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2396

# repeat in the output multiple times can be stored once in a shared

2397

# variable table and be referenced using the `var_table_index` field. The

2398

# variables stored in the shared table are nameless and are essentially

2399

# a partition of the complete variable. To reconstruct the complete

2400

# variable, merge the referencing variable with the referenced variable.

2401

#

2402

# 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

2409

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2410

# { name: "r", type="T&", var_table_index: 3 }

2411

#

2412

# { // Shared variable table entry #3:

2413

# members { name: "m1", value: "3", type: "int" },

2414

# members { name: "m2", value: "7", type: "int" }

2415

# }

2416

#

2417

# Note that the pointer address is stored with the referencing variable

2418

# and not with the referenced variable. This allows the referenced variable

2419

# to be shared between pointers and references.

2420

#

2421

# The type field is optional. The debugger agent may or may not support it.

2422

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2423

# unset. A status of a single variable only applies to that variable or

2424

# expression. The rest of breakpoint data still remains valid. Variables

2425

# might be reported in error state even when breakpoint is not in final

2426

# state.

2427

#

2428

# The message may refer to variable name with `refers_to` set to

2429

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2430

# In either case variable value and members will be unset.

2431

#

2432

# Example of error message applied to name: `Invalid expression syntax`.

2433

#

2434

# Example of information message applied to value: `Not captured`.

2435

#

2436

# Examples of error message applied to value:

2437

#

2438

# * `Malformed string`,

2439

# * `Field f not found in class C`

2440

# * `Null pointer dereference`

2441

# The message can indicate an error or informational status, and refer to

2442

# specific parts of the containing object.

2443

# For example, the `Breakpoint.status` field can indicate an error referring

2444

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2445

"isError": True or False, # Distinguishes errors from informational messages.

2446

"refersTo": "A String", # Reference to which the message applies.

2447

"description": { # Represents a message with parameters. # Status message text.

2448

"parameters": [ # Optional parameters to be embedded into the message.

2449

"A String",

2450

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2451

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2452

# `$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

2458

# is loaded. Again, $0 is very important.`

2459

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2460

},

2461

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2462

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2463

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2464

# one variable can reference the same variable in the table. The

2465

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2466

"value": "A String", # Simple value of the variable.

2467

"members": [ # Members contained or pointed to by the variable.

2468

# Object with schema name: Variable

2469

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2470

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2471

# `var_table_index`, `type` goes next to `value`. The interpretation of

2472

# a type is agent specific. It is recommended to include the dynamic type

2473

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2474

},

2475

],

2476

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2477

"condition": "A String", # Condition that triggers the breakpoint.

2478

# The condition is a compound boolean expression composed using expressions

2479

# in a programming language at the source location.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2480

}

2481

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2482

clientVersion: string, The client version making the call.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

2483

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2484

x__xgafv: string, V1 error format.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2485

Allowed values

2486

1 - v1 error format

2487

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2488

2489

Returns:

2490

An object of the form:

2491

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2492

{ # Response for setting a breakpoint.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2493

"breakpoint": { # Represents the breakpoint specification, status and results. # Breakpoint resource.

2494

# The field `id` is guaranteed to be set (in addition to the echoed fileds).

2495

"status": { # Represents a contextual status message. # Breakpoint status.

2496

#

2497

# The status includes an error flag and a human readable message.

2498

# This field is usually unset. The message can be either

2499

# informational or an error message. Regardless, clients should always

2500

# display the text message back to the user.

2501

#

2502

# Error status indicates complete failure of the breakpoint.

2503

#

2504

# Example (non-final state): `Still loading symbols...`

2505

#

2506

# Examples (final state):

2507

#

2508

# * `Invalid line number` referring to location

2509

# * `Field f not found in class C` referring to condition

2510

# The message can indicate an error or informational status, and refer to

2511

# specific parts of the containing object.

2512

# For example, the `Breakpoint.status` field can indicate an error referring

2513

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2514

"isError": True or False, # Distinguishes errors from informational messages.

2515

"refersTo": "A String", # Reference to which the message applies.

2516

"description": { # Represents a message with parameters. # Status message text.

2517

"parameters": [ # Optional parameters to be embedded into the message.

2518

"A String",

2519

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2520

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2521

# `$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

2527

# is loaded. Again, $0 is very important.`

2528

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2529

},

2530

},

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2531

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

2532

# traffic optimization. It enables storing a variable once and reference

2533

# it from multiple variables, including variables stored in the

2534

# `variable_table` itself.

2535

# For example, the same `this` object, which may appear at many levels of

2536

# the stack, can have all of its data stored once in this table. The

2537

# stack frame variables then would hold only a reference to it.

2538

#

2539

# The variable `var_table_index` field is an index into this repeated field.

2540

# The stored objects are nameless and get their name from the referencing

2541

# variable. The effective variable is a merge of the referencing variable

2542

# and the referenced variable.

2543

{ # Represents a variable or an argument possibly of a compound object type.

2544

# Note how the following variables are represented:

2545

#

2546

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2551

#

2552

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2561

# name: "x",

2562

# type: "T",

2563

# members { name: "m1", value: "3", type: "int" },

2564

# members { name: "m2", value: "7", type: "int" }

2565

# }

2566

#

2567

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2573

# name: "p",

2574

# type: "T*",

2575

# value: "0x00500500",

2576

# members { name: "m1", value: "3", type: "int" },

2577

# members { name: "m2", value: "7", type: "int" }

2578

# }

2579

#

2580

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2585

# name: "p",

2586

# type: "T*",

2587

# value: "0x00400400"

2588

# status { is_error: true, description { format: "unavailable" } }

2589

# }

2590

#

2591

# The status should describe the reason for the missing value,

2592

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2593

#

2594

# Note that a null pointer should not have members.

2595

#

2596

# 5) An unnamed value:

2597

#

2598

# int* p = new int(7);

2599

#

2600

# { // Captured variable

2601

# name: "p",

2602

# value: "0x00500500",

2603

# type: "int*",

2604

# members { value: "7", type: "int" } }

2605

#

2606

# 6) An unnamed pointer where the pointee was not captured:

2607

#

2608

# int* p = new int(7);

2609

# int** pp = &p;

2610

#

2611

# { // Captured variable

2612

# name: "pp",

2613

# value: "0x00500500",

2614

# type: "int**",

2615

# members {

2616

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2626

# repeat in the output multiple times can be stored once in a shared

2627

# variable table and be referenced using the `var_table_index` field. The

2628

# variables stored in the shared table are nameless and are essentially

2629

# a partition of the complete variable. To reconstruct the complete

2630

# variable, merge the referencing variable with the referenced variable.

2631

#

2632

# 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

2639

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2640

# { name: "r", type="T&", var_table_index: 3 }

2641

#

2642

# { // Shared variable table entry #3:

2643

# members { name: "m1", value: "3", type: "int" },

2644

# members { name: "m2", value: "7", type: "int" }

2645

# }

2646

#

2647

# Note that the pointer address is stored with the referencing variable

2648

# and not with the referenced variable. This allows the referenced variable

2649

# to be shared between pointers and references.

2650

#

2651

# The type field is optional. The debugger agent may or may not support it.

2652

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2653

# unset. A status of a single variable only applies to that variable or

2654

# expression. The rest of breakpoint data still remains valid. Variables

2655

# might be reported in error state even when breakpoint is not in final

2656

# state.

2657

#

2658

# The message may refer to variable name with `refers_to` set to

2659

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2660

# In either case variable value and members will be unset.

2661

#

2662

# Example of error message applied to name: `Invalid expression syntax`.

2663

#

2664

# Example of information message applied to value: `Not captured`.

2665

#

2666

# Examples of error message applied to value:

2667

#

2668

# * `Malformed string`,

2669

# * `Field f not found in class C`

2670

# * `Null pointer dereference`

2671

# The message can indicate an error or informational status, and refer to

2672

# specific parts of the containing object.

2673

# For example, the `Breakpoint.status` field can indicate an error referring

2674

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2675

"isError": True or False, # Distinguishes errors from informational messages.

2676

"refersTo": "A String", # Reference to which the message applies.

2677

"description": { # Represents a message with parameters. # Status message text.

2678

"parameters": [ # Optional parameters to be embedded into the message.

2679

"A String",

2680

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2681

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2682

# `$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

2688

# is loaded. Again, $0 is very important.`

2689

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2690

},

2691

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2692

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2693

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2694

# one variable can reference the same variable in the table. The

2695

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2696

"value": "A String", # Simple value of the variable.

2697

"members": [ # Members contained or pointed to by the variable.

2698

# Object with schema name: Variable

2699

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2700

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2701

# `var_table_index`, `type` goes next to `value`. The interpretation of

2702

# a type is agent specific. It is recommended to include the dynamic type

2703

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2704

},

2705

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2706

"userEmail": "A String", # E-mail address of the user that created this breakpoint

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

2707

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

2708

# the breakpoint hits. The message may include parameter placeholders `$0`,

2709

# `$1`, etc. These placeholders are replaced with the evaluated value

2710

# of the appropriate expression. Expressions not referenced in

2711

# `log_message_format` are not logged.

2712

#

2713

# Example: `Message received, id = $0, count = $1` with

2714

# `expressions` = `[ message.id, message.count ]`.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2715

"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]

2716

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

2717

# displayed to the user.

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

2718

"a_key": "A String",

2719

},

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

2720

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

2721

# recently entered function.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2722

{ # Represents a stack frame context.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2723

"function": "A String", # Demangled function name at the call site.

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2724

"arguments": [ # Set of arguments passed to this function.

2725

# Note that this might not be populated for all stack frames.

2726

{ # Represents a variable or an argument possibly of a compound object type.

2727

# Note how the following variables are represented:

2728

#

2729

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2734

#

2735

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2744

# name: "x",

2745

# type: "T",

2746

# members { name: "m1", value: "3", type: "int" },

2747

# members { name: "m2", value: "7", type: "int" }

2748

# }

2749

#

2750

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2756

# name: "p",

2757

# type: "T*",

2758

# value: "0x00500500",

2759

# members { name: "m1", value: "3", type: "int" },

2760

# members { name: "m2", value: "7", type: "int" }

2761

# }

2762

#

2763

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2768

# name: "p",

2769

# type: "T*",

2770

# value: "0x00400400"

2771

# status { is_error: true, description { format: "unavailable" } }

2772

# }

2773

#

2774

# The status should describe the reason for the missing value,

2775

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2776

#

2777

# Note that a null pointer should not have members.

2778

#

2779

# 5) An unnamed value:

2780

#

2781

# int* p = new int(7);

2782

#

2783

# { // Captured variable

2784

# name: "p",

2785

# value: "0x00500500",

2786

# type: "int*",

2787

# members { value: "7", type: "int" } }

2788

#

2789

# 6) An unnamed pointer where the pointee was not captured:

2790

#

2791

# int* p = new int(7);

2792

# int** pp = &p;

2793

#

2794

# { // Captured variable

2795

# name: "pp",

2796

# value: "0x00500500",

2797

# type: "int**",

2798

# members {

2799

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2809

# repeat in the output multiple times can be stored once in a shared

2810

# variable table and be referenced using the `var_table_index` field. The

2811

# variables stored in the shared table are nameless and are essentially

2812

# a partition of the complete variable. To reconstruct the complete

2813

# variable, merge the referencing variable with the referenced variable.

2814

#

2815

# 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

2822

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2823

# { name: "r", type="T&", var_table_index: 3 }

2824

#

2825

# { // Shared variable table entry #3:

2826

# members { name: "m1", value: "3", type: "int" },

2827

# members { name: "m2", value: "7", type: "int" }

2828

# }

2829

#

2830

# Note that the pointer address is stored with the referencing variable

2831

# and not with the referenced variable. This allows the referenced variable

2832

# to be shared between pointers and references.

2833

#

2834

# The type field is optional. The debugger agent may or may not support it.

2835

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2836

# unset. A status of a single variable only applies to that variable or

2837

# expression. The rest of breakpoint data still remains valid. Variables

2838

# might be reported in error state even when breakpoint is not in final

2839

# state.

2840

#

2841

# The message may refer to variable name with `refers_to` set to

2842

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2843

# In either case variable value and members will be unset.

2844

#

2845

# Example of error message applied to name: `Invalid expression syntax`.

2846

#

2847

# Example of information message applied to value: `Not captured`.

2848

#

2849

# Examples of error message applied to value:

2850

#

2851

# * `Malformed string`,

2852

# * `Field f not found in class C`

2853

# * `Null pointer dereference`

2854

# The message can indicate an error or informational status, and refer to

2855

# specific parts of the containing object.

2856

# For example, the `Breakpoint.status` field can indicate an error referring

2857

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2858

"isError": True or False, # Distinguishes errors from informational messages.

2859

"refersTo": "A String", # Reference to which the message applies.

2860

"description": { # Represents a message with parameters. # Status message text.

2861

"parameters": [ # Optional parameters to be embedded into the message.

2862

"A String",

2863

],

2864

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2865

# `$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

2871

# is loaded. Again, $0 is very important.`

2872

# * `Please pay $$10 to use $0 instead of $1.`

2873

},

2874

},

2875

"name": "A String", # Name of the variable, if any.

2876

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2877

# one variable can reference the same variable in the table. The

2878

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2879

"value": "A String", # Simple value of the variable.

2880

"members": [ # Members contained or pointed to by the variable.

2881

# Object with schema name: Variable

2882

],

2883

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2884

# `var_table_index`, `type` goes next to `value`. The interpretation of

2885

# a type is agent specific. It is recommended to include the dynamic type

2886

# rather than a static type of an object.

2887

},

2888

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2889

"locals": [ # Set of local variables at the stack frame location.

2890

# Note that this might not be populated for all stack frames.

2891

{ # Represents a variable or an argument possibly of a compound object type.

2892

# Note how the following variables are represented:

2893

#

2894

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2899

#

2900

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2909

# name: "x",

2910

# type: "T",

2911

# members { name: "m1", value: "3", type: "int" },

2912

# members { name: "m2", value: "7", type: "int" }

2913

# }

2914

#

2915

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

2921

# name: "p",

2922

# type: "T*",

2923

# value: "0x00500500",

2924

# members { name: "m1", value: "3", type: "int" },

2925

# members { name: "m2", value: "7", type: "int" }

2926

# }

2927

#

2928

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2933

# name: "p",

2934

# type: "T*",

2935

# value: "0x00400400"

2936

# status { is_error: true, description { format: "unavailable" } }

2937

# }

2938

#

2939

# The status should describe the reason for the missing value,

2940

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

2941

#

2942

# Note that a null pointer should not have members.

2943

#

2944

# 5) An unnamed value:

2945

#

2946

# int* p = new int(7);

2947

#

2948

# { // Captured variable

2949

# name: "p",

2950

# value: "0x00500500",

2951

# type: "int*",

2952

# members { value: "7", type: "int" } }

2953

#

2954

# 6) An unnamed pointer where the pointee was not captured:

2955

#

2956

# int* p = new int(7);

2957

# int** pp = &p;

2958

#

2959

# { // Captured variable

2960

# name: "pp",

2961

# value: "0x00500500",

2962

# type: "int**",

2963

# members {

2964

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2974

# repeat in the output multiple times can be stored once in a shared

2975

# variable table and be referenced using the `var_table_index` field. The

2976

# variables stored in the shared table are nameless and are essentially

2977

# a partition of the complete variable. To reconstruct the complete

2978

# variable, merge the referencing variable with the referenced variable.

2979

#

2980

# 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

2987

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

2988

# { name: "r", type="T&", var_table_index: 3 }

2989

#

2990

# { // Shared variable table entry #3:

2991

# members { name: "m1", value: "3", type: "int" },

2992

# members { name: "m2", value: "7", type: "int" }

2993

# }

2994

#

2995

# Note that the pointer address is stored with the referencing variable

2996

# and not with the referenced variable. This allows the referenced variable

2997

# to be shared between pointers and references.

2998

#

2999

# The type field is optional. The debugger agent may or may not support it.

3000

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

3001

# unset. A status of a single variable only applies to that variable or

3002

# expression. The rest of breakpoint data still remains valid. Variables

3003

# might be reported in error state even when breakpoint is not in final

3004

# state.

3005

#

3006

# The message may refer to variable name with `refers_to` set to

3007

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

3008

# In either case variable value and members will be unset.

3009

#

3010

# Example of error message applied to name: `Invalid expression syntax`.

3011

#

3012

# Example of information message applied to value: `Not captured`.

3013

#

3014

# Examples of error message applied to value:

3015

#

3016

# * `Malformed string`,

3017

# * `Field f not found in class C`

3018

# * `Null pointer dereference`

3019

# The message can indicate an error or informational status, and refer to

3020

# specific parts of the containing object.

3021

# For example, the `Breakpoint.status` field can indicate an error referring

3022

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

3023

"isError": True or False, # Distinguishes errors from informational messages.

3024

"refersTo": "A String", # Reference to which the message applies.

3025

"description": { # Represents a message with parameters. # Status message text.

3026

"parameters": [ # Optional parameters to be embedded into the message.

3027

"A String",

3028

],

3029

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3030

# `$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

3036

# is loaded. Again, $0 is very important.`

3037

# * `Please pay $$10 to use $0 instead of $1.`

3038

},

3039

},

3040

"name": "A String", # Name of the variable, if any.

3041

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3042

# one variable can reference the same variable in the table. The

3043

# `var_table_index` field is an index into `variable_table` in Breakpoint.

3044

"value": "A String", # Simple value of the variable.

3045

"members": [ # Members contained or pointed to by the variable.

3046

# Object with schema name: Variable

3047

],

3048

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3049

# `var_table_index`, `type` goes next to `value`. The interpretation of

3050

# a type is agent specific. It is recommended to include the dynamic type

3051

# rather than a static type of an object.

3052

},

3053

],

3054

"location": { # Represents a location in the source code. # Source location of the call site.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

3055

"column": 42, # Column within a line. The first column in a line as the value `1`.

3056

# Agents that do not support setting breakpoints on specific columns ignore

3057

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3058

"path": "A String", # Path to the source file within the source context of the target binary.

3059

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3060

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3061

},

3062

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3063

"createTime": "A String", # Time this breakpoint was created by the server in seconds resolution.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3064

"location": { # Represents a location in the source code. # Breakpoint source location.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

3065

"column": 42, # Column within a line. The first column in a line as the value `1`.

3066

# Agents that do not support setting breakpoints on specific columns ignore

3067

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3068

"path": "A String", # Path to the source file within the source context of the target binary.

3069

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3070

},

3071

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

3072

# resolution.

3073

"action": "A String", # Action that the agent should perform when the code at the

3074

# breakpoint location is hit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame^]

3075

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

3076

# The expressions are composed using expressions in the programming language

3077

# at the source location. If the breakpoint action is `LOG`, the evaluated

3078

# expressions are included in log statements.

3079

"A String",

3080

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3081

"isFinalState": True or False, # When true, indicates that this is a final result and the

3082

# breakpoint state will not change from here on.

3083

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

3084

# The evaluated expressions appear in exactly the same order they

3085

# are listed in the `expressions` field.

3086

# The `name` field holds the original expression text, the `value` or

3087

# `members` field holds the result of the evaluated expression.

3088

# If the expression cannot be evaluated, the `status` inside the `Variable`

3089

# will indicate an error and contain the error text.

3090

{ # Represents a variable or an argument possibly of a compound object type.

3091

# Note how the following variables are represented:

3092

#

3093

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

3098

#

3099

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

3108

# name: "x",

3109

# type: "T",

3110

# members { name: "m1", value: "3", type: "int" },

3111

# members { name: "m2", value: "7", type: "int" }

3112

# }

3113

#

3114

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

3120

# name: "p",

3121

# type: "T*",

3122

# value: "0x00500500",

3123

# members { name: "m1", value: "3", type: "int" },

3124

# members { name: "m2", value: "7", type: "int" }

3125

# }

3126

#

3127

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

3132

# name: "p",

3133

# type: "T*",

3134

# value: "0x00400400"

3135

# status { is_error: true, description { format: "unavailable" } }

3136

# }

3137

#

3138

# The status should describe the reason for the missing value,

3139

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

3140

#

3141

# Note that a null pointer should not have members.

3142

#

3143

# 5) An unnamed value:

3144

#

3145

# int* p = new int(7);

3146

#

3147

# { // Captured variable

3148

# name: "p",

3149

# value: "0x00500500",

3150

# type: "int*",

3151

# members { value: "7", type: "int" } }

3152

#

3153

# 6) An unnamed pointer where the pointee was not captured:

3154

#

3155

# int* p = new int(7);

3156

# int** pp = &p;

3157

#

3158

# { // Captured variable

3159

# name: "pp",

3160

# value: "0x00500500",

3161

# type: "int**",

3162

# members {

3163

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

3173

# repeat in the output multiple times can be stored once in a shared

3174

# variable table and be referenced using the `var_table_index` field. The

3175

# variables stored in the shared table are nameless and are essentially

3176

# a partition of the complete variable. To reconstruct the complete

3177

# variable, merge the referencing variable with the referenced variable.

3178

#

3179

# 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

3186

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

3187

# { name: "r", type="T&", var_table_index: 3 }

3188

#

3189

# { // Shared variable table entry #3:

3190

# members { name: "m1", value: "3", type: "int" },

3191

# members { name: "m2", value: "7", type: "int" }

3192

# }

3193

#

3194

# Note that the pointer address is stored with the referencing variable

3195

# and not with the referenced variable. This allows the referenced variable

3196

# to be shared between pointers and references.

3197

#

3198

# The type field is optional. The debugger agent may or may not support it.

3199

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

3200

# unset. A status of a single variable only applies to that variable or

3201

# expression. The rest of breakpoint data still remains valid. Variables

3202

# might be reported in error state even when breakpoint is not in final

3203

# state.

3204

#

3205

# The message may refer to variable name with `refers_to` set to

3206

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

3207

# In either case variable value and members will be unset.

3208

#

3209

# Example of error message applied to name: `Invalid expression syntax`.

3210

#

3211

# Example of information message applied to value: `Not captured`.

3212

#

3213

# Examples of error message applied to value:

3214

#

3215

# * `Malformed string`,

3216

# * `Field f not found in class C`

3217

# * `Null pointer dereference`

3218

# The message can indicate an error or informational status, and refer to

3219

# specific parts of the containing object.

3220

# For example, the `Breakpoint.status` field can indicate an error referring

3221

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3222

"isError": True or False, # Distinguishes errors from informational messages.

3223

"refersTo": "A String", # Reference to which the message applies.

3224

"description": { # Represents a message with parameters. # Status message text.

3225

"parameters": [ # Optional parameters to be embedded into the message.

3226

"A String",

3227

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3228

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3229

# `$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

3235

# is loaded. Again, $0 is very important.`

3236

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3237

},

3238

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

3239

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3240

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3241

# one variable can reference the same variable in the table. The

3242

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

3243

"value": "A String", # Simple value of the variable.

3244

"members": [ # Members contained or pointed to by the variable.

3245

# Object with schema name: Variable

3246

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3247

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3248

# `var_table_index`, `type` goes next to `value`. The interpretation of

3249

# a type is agent specific. It is recommended to include the dynamic type

3250

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3251

},

3252

],

3253

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3254

"condition": "A String", # Condition that triggers the breakpoint.

3255

# The condition is a compound boolean expression composed using expressions

3256

# in a programming language at the source location.

Takashi Matsuo