Blame - docs/dyn/clouddebugger_v2.controller.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

Bu Sun Kim

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

[diff] [blame]

78

<code><a href="#list">list(debuggeeId, waitToken=None, successOnTimeout=None, x__xgafv=None)</a></code></p>

Sai Cheemalapati

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

[diff] [blame]

79

<p class="firstline">Returns the list of all active breakpoints for the debuggee.</p>

Takashi Matsuo

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

[diff] [blame]

80

81

<code><a href="#update">update(debuggeeId, id, body, x__xgafv=None)</a></code></p>

Sai Cheemalapati

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

[diff] [blame]

82

<p class="firstline">Updates the breakpoint state or mutable fields.</p>

Takashi Matsuo

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

[diff] [blame]

83

<h3>Method Details</h3>

84

Bu Sun Kim

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

[diff] [blame]

85

<code class="details" id="list">list(debuggeeId, waitToken=None, successOnTimeout=None, x__xgafv=None)</code>

Sai Cheemalapati

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

[diff] [blame]

86

<pre>Returns the list of all active breakpoints for the debuggee.

87

Bu Sun Kim

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

[diff] [blame]

88

The breakpoint specification (`location`, `condition`, and `expressions`

Sai Cheemalapati

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

[diff] [blame]

89

fields) is semantically immutable, although the field values may

90

change. For example, an agent may update the location line number

91

to reflect the actual line where the breakpoint was set, but this

92

doesn't change the breakpoint semantics.

93

94

This means that an agent does not need to check if a breakpoint has changed

95

when it encounters the same breakpoint on a successive call.

96

Moreover, an agent should remember the breakpoints that are completed

97

until the controller removes them from the active list to avoid

98

setting those breakpoints again.

Takashi Matsuo

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

[diff] [blame]

99

100

Args:

101

debuggeeId: string, Identifies the debuggee. (required)

Bu Sun Kim

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

[diff] [blame]

102

waitToken: string, A token that, if specified, blocks the method call until the list

103

of active breakpoints has changed, or a server-selected timeout has

104

expired. The value should be set from the `next_wait_token` field in

105

the last response. The initial value should be set to `"init"`.

106

successOnTimeout: boolean, If set to `true` (recommended), returns `google.rpc.Code.OK` status and

107

sets the `wait_expired` response field to `true` when the server-selected

108

timeout has expired.

Sai Cheemalapati

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

[diff] [blame]

109

Bu Sun Kim

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

[diff] [blame]

110

If set to `false` (deprecated), returns `google.rpc.Code.ABORTED` status

111

when the server-selected timeout has expired.

Takashi Matsuo

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

[diff] [blame]

112

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

113

Allowed values

114

1 - v1 error format

115

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

116

117

Returns:

118

An object of the form:

119

Jon Wayne Parrott

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

[diff] [blame]

120

{ # Response for listing active breakpoints.

Bu Sun Kim

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

[diff] [blame]

121

"waitExpired": True or False, # If set to `true`, indicates that there is no change to the

122

# list of active breakpoints and the server-selected timeout has expired.

123

# The `breakpoints` field would be empty and should be ignored.

124

"nextWaitToken": "A String", # A token that can be used in the next method call to block until

Sai Cheemalapati

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

[diff] [blame]

125

# the list of breakpoints changes.

126

"breakpoints": [ # List of all active breakpoints.

127

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

Takashi Matsuo

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

[diff] [blame]

128

{ # Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

129

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

130

#

131

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

132

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

133

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

134

# display the text message back to the user.

135

#

136

# Error status indicates complete failure of the breakpoint.

137

#

138

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

139

#

140

# Examples (final state):

141

#

142

# * `Invalid line number` referring to location

143

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

144

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

145

# specific parts of the containing object.

146

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

147

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

Takashi Matsuo

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

[diff] [blame]

148

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

149

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

150

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

151

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

152

"A String",

153

],

Sai Cheemalapati

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

[diff] [blame]

154

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

155

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

161

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

162

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

Takashi Matsuo

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

[diff] [blame]

163

},

164

},

Sai Cheemalapati

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

[diff] [blame]

165

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

166

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

167

# it from multiple variables, including variables stored in the

168

# `variable_table` itself.

169

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

170

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

171

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

172

#

173

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

174

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

175

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

176

# and the referenced variable.

177

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

178

# Note how the following variables are represented:

179

#

180

# 1) A simple variable:

#

# int x = 5

#

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

185

#

186

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

195

# name: "x",

196

# type: "T",

197

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

198

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

199

# }

200

#

201

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

207

# name: "p",

208

# type: "T*",

209

# value: "0x00500500",

210

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

211

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

212

# }

213

#

214

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

#

# T* p = new T;

#

# { // Captured variable

219

# name: "p",

220

# type: "T*",

221

# value: "0x00400400"

222

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

223

# }

224

#

225

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

226

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

227

#

228

# Note that a null pointer should not have members.

229

#

230

# 5) An unnamed value:

231

#

232

# int* p = new int(7);

233

#

234

# { // Captured variable

235

# name: "p",

236

# value: "0x00500500",

237

# type: "int*",

238

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

239

#

240

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

241

#

242

# int* p = new int(7);

243

# int** pp = &p;

244

#

245

# { // Captured variable

246

# name: "pp",

247

# value: "0x00500500",

248

# type: "int**",

249

# members {

250

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

260

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

261

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

262

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

263

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

264

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

265

#

266

# 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

273

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

274

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

275

#

276

# { // Shared variable table entry #3:

277

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

278

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

279

# }

280

#

281

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

282

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

283

# to be shared between pointers and references.

284

#

285

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

286

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

287

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

288

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

289

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

290

# state.

291

#

292

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

293

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

294

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

295

#

296

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

297

#

298

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

299

#

300

# Examples of error message applied to value:

301

#

302

# * `Malformed string`,

303

# * `Field f not found in class C`

304

# * `Null pointer dereference`

305

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

306

# specific parts of the containing object.

307

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

308

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

Takashi Matsuo

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

[diff] [blame]

309

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

310

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

311

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

312

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

313

"A String",

314

],

Sai Cheemalapati

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

[diff] [blame]

315

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

316

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

322

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

323

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

Takashi Matsuo

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

[diff] [blame]

324

},

325

},

Jon Wayne Parrott

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

[diff] [blame]

326

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

Sai Cheemalapati

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

[diff] [blame]

327

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

328

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

329

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

Jon Wayne Parrott

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

[diff] [blame]

330

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

331

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

332

# Object with schema name: Variable

333

],

Sai Cheemalapati

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

[diff] [blame]

334

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

335

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

336

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

337

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

338

},

339

],

Sai Cheemalapati

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

[diff] [blame]

340

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

341

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

342

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

343

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

344

# of the appropriate expression. Expressions not referenced in

345

# `log_message_format` are not logged.

346

#

347

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

348

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

Jon Wayne Parrott

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

[diff] [blame]

349

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

350

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

351

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

352

"a_key": "A String",

353

},

Bu Sun Kim

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

[diff] [blame]

354

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

355

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

356

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

357

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

Thomas Coffee

2f24537

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

[diff] [blame]

358

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

359

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

360

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

361

# Note how the following variables are represented:

362

#

363

# 1) A simple variable:

#

# int x = 5

#

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

368

#

369

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

378

# name: "x",

379

# type: "T",

380

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

381

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

382

# }

383

#

384

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

390

# name: "p",

391

# type: "T*",

392

# value: "0x00500500",

393

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

394

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

395

# }

396

#

397

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

#

# T* p = new T;

#

# { // Captured variable

402

# name: "p",

403

# type: "T*",

404

# value: "0x00400400"

405

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

406

# }

407

#

408

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

409

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

410

#

411

# Note that a null pointer should not have members.

412

#

413

# 5) An unnamed value:

414

#

415

# int* p = new int(7);

416

#

417

# { // Captured variable

418

# name: "p",

419

# value: "0x00500500",

420

# type: "int*",

421

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

422

#

423

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

424

#

425

# int* p = new int(7);

426

# int** pp = &p;

427

#

428

# { // Captured variable

429

# name: "pp",

430

# value: "0x00500500",

431

# type: "int**",

432

# members {

433

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

443

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

444

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

445

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

446

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

447

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

448

#

449

# 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

456

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

457

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

458

#

459

# { // Shared variable table entry #3:

460

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

461

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

462

# }

463

#

464

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

465

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

466

# to be shared between pointers and references.

467

#

468

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

469

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

470

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

471

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

472

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

473

# state.

474

#

475

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

476

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

477

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

478

#

479

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

480

#

481

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

482

#

483

# Examples of error message applied to value:

484

#

485

# * `Malformed string`,

486

# * `Field f not found in class C`

487

# * `Null pointer dereference`

488

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

489

# specific parts of the containing object.

490

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

491

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

492

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

493

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

494

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

495

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

496

"A String",

497

],

498

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

499

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

505

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

506

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

507

},

508

},

509

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

510

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

511

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

512

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

513

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

514

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

515

# Object with schema name: Variable

516

],

517

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

518

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

519

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

520

# rather than a static type of an object.

521

},

522

],

Sai Cheemalapati

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

[diff] [blame]

523

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

524

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

525

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

526

# Note how the following variables are represented:

527

#

528

# 1) A simple variable:

#

# int x = 5

#

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

533

#

534

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

543

# name: "x",

544

# type: "T",

545

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

546

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

547

# }

548

#

549

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

555

# name: "p",

556

# type: "T*",

557

# value: "0x00500500",

558

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

559

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

560

# }

561

#

562

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

#

# T* p = new T;

#

# { // Captured variable

567

# name: "p",

568

# type: "T*",

569

# value: "0x00400400"

570

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

571

# }

572

#

573

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

574

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

575

#

576

# Note that a null pointer should not have members.

577

#

578

# 5) An unnamed value:

579

#

580

# int* p = new int(7);

581

#

582

# { // Captured variable

583

# name: "p",

584

# value: "0x00500500",

585

# type: "int*",

586

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

587

#

588

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

589

#

590

# int* p = new int(7);

591

# int** pp = &p;

592

#

593

# { // Captured variable

594

# name: "pp",

595

# value: "0x00500500",

596

# type: "int**",

597

# members {

598

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

608

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

609

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

610

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

611

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

612

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

613

#

614

# 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

621

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

622

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

623

#

624

# { // Shared variable table entry #3:

625

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

626

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

627

# }

628

#

629

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

630

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

631

# to be shared between pointers and references.

632

#

633

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

634

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

635

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

636

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

637

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

638

# state.

639

#

640

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

641

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

642

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

643

#

644

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

645

#

646

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

647

#

648

# Examples of error message applied to value:

649

#

650

# * `Malformed string`,

651

# * `Field f not found in class C`

652

# * `Null pointer dereference`

653

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

654

# specific parts of the containing object.

655

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

656

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

657

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

658

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

659

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

660

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

661

"A String",

662

],

663

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

664

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

670

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

671

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

672

},

673

},

674

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

675

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

676

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

677

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

678

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

679

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

680

# Object with schema name: Variable

681

],

682

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

683

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

684

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

685

# rather than a static type of an object.

686

},

687

],

688

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

689

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

690

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

691

# this field.

Sai Cheemalapati

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

[diff] [blame]

692

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

693

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

694

},

Takashi Matsuo

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

[diff] [blame]

695

},

696

],

Sai Cheemalapati

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

[diff] [blame]

697

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

698

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

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

},

705

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

706

# resolution.

707

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

708

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame]

709

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

710

# The expressions are composed using expressions in the programming language

711

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

712

# expressions are included in log statements.

713

"A String",

714

],

Sai Cheemalapati

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

[diff] [blame]

715

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

716

# breakpoint state will not change from here on.

717

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

718

# The evaluated expressions appear in exactly the same order they

719

# are listed in the `expressions` field.

720

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

721

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

722

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

723

# will indicate an error and contain the error text.

724

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

725

# Note how the following variables are represented:

726

#

727

# 1) A simple variable:

#

# int x = 5

#

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

732

#

733

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

742

# name: "x",

743

# type: "T",

744

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

745

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

746

# }

747

#

748

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

754

# name: "p",

755

# type: "T*",

756

# value: "0x00500500",

757

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

758

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

759

# }

760

#

761

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

#

# T* p = new T;

#

# { // Captured variable

766

# name: "p",

767

# type: "T*",

768

# value: "0x00400400"

769

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

770

# }

771

#

772

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

773

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

774

#

775

# Note that a null pointer should not have members.

776

#

777

# 5) An unnamed value:

778

#

779

# int* p = new int(7);

780

#

781

# { // Captured variable

782

# name: "p",

783

# value: "0x00500500",

784

# type: "int*",

785

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

786

#

787

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

788

#

789

# int* p = new int(7);

790

# int** pp = &p;

791

#

792

# { // Captured variable

793

# name: "pp",

794

# value: "0x00500500",

795

# type: "int**",

796

# members {

797

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

807

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

808

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

809

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

810

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

811

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

812

#

813

# 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

820

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

821

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

822

#

823

# { // Shared variable table entry #3:

824

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

825

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

826

# }

827

#

828

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

829

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

830

# to be shared between pointers and references.

831

#

832

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

833

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

834

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

835

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

836

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

837

# state.

838

#

839

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

840

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

841

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

842

#

843

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

844

#

845

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

846

#

847

# Examples of error message applied to value:

848

#

849

# * `Malformed string`,

850

# * `Field f not found in class C`

851

# * `Null pointer dereference`

852

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

853

# specific parts of the containing object.

854

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

855

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

Takashi Matsuo

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

[diff] [blame]

856

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

857

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

858

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

859

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

860

"A String",

861

],

Sai Cheemalapati

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

[diff] [blame]

862

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

863

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

869

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

870

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

Takashi Matsuo

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

[diff] [blame]

871

},

872

},

Jon Wayne Parrott

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

[diff] [blame]

873

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

Sai Cheemalapati

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

[diff] [blame]

874

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

875

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

876

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

Jon Wayne Parrott

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

[diff] [blame]

877

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

878

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

879

# Object with schema name: Variable

880

],

Sai Cheemalapati

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

[diff] [blame]

881

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

882

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

883

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

884

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

885

},

886

],

887

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

Sai Cheemalapati

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

[diff] [blame]

888

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

889

# The condition is a compound boolean expression composed using expressions

890

# in a programming language at the source location.

Takashi Matsuo

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

[diff] [blame]

},

],

}</pre>

</div>

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

Sai Cheemalapati

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

[diff] [blame]

898

<pre>Updates the breakpoint state or mutable fields.

Bu Sun Kim

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

[diff] [blame]

899

The entire Breakpoint message must be sent back to the controller service.

Sai Cheemalapati

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

[diff] [blame]

900

901

Updates to active breakpoint fields are only allowed if the new value

902

does not change the breakpoint specification. Updates to the `location`,

Bu Sun Kim

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

[diff] [blame]

903

`condition` and `expressions` fields should not alter the breakpoint

Sai Cheemalapati

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

[diff] [blame]

904

semantics. These may only make changes such as canonicalizing a value

905

or snapping the location to the correct line of code.

Takashi Matsuo

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

[diff] [blame]

906

907

Args:

908

debuggeeId: string, Identifies the debuggee being debugged. (required)

909

id: string, Breakpoint identifier, unique in the scope of the debuggee. (required)

910

body: object, The request body. (required)

911

The object takes the form of:

912

Jon Wayne Parrott

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

[diff] [blame]

913

{ # Request to update an active breakpoint.

Sai Cheemalapati

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

[diff] [blame]

914

"breakpoint": { # Represents the breakpoint specification, status and results. # Updated breakpoint information.

Bu Sun Kim

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

[diff] [blame]

915

# The field `id` must be set.

916

# The agent must echo all Breakpoint specification fields in the update.

Sai Cheemalapati

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

[diff] [blame]

917

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

918

#

919

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

920

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

921

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

922

# display the text message back to the user.

923

#

924

# Error status indicates complete failure of the breakpoint.

925

#

926

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

927

#

928

# Examples (final state):

929

#

930

# * `Invalid line number` referring to location

931

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

932

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

933

# specific parts of the containing object.

934

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

935

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

Takashi Matsuo

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

[diff] [blame]

936

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

937

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

938

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

939

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

940

"A String",

941

],

Sai Cheemalapati

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

[diff] [blame]

942

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

943

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

949

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

950

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

Takashi Matsuo

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

[diff] [blame]

951

},

952

},

Sai Cheemalapati

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

[diff] [blame]

953

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

954

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

955

# it from multiple variables, including variables stored in the

956

# `variable_table` itself.

957

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

958

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

959

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

960

#

961

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

962

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

963

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

964

# and the referenced variable.

965

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

966

# Note how the following variables are represented:

967

#

968

# 1) A simple variable:

#

# int x = 5

#

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

973

#

974

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

983

# name: "x",

984

# type: "T",

985

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

986

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

987

# }

988

#

989

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

995

# name: "p",

996

# type: "T*",

997

# value: "0x00500500",

998

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

999

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

1000

# }

1001

#

1002

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

#

# T* p = new T;

#

# { // Captured variable

1007

# name: "p",

1008

# type: "T*",

1009

# value: "0x00400400"

1010

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

1011

# }

1012

#

1013

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

1014

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

1015

#

1016

# Note that a null pointer should not have members.

1017

#

1018

# 5) An unnamed value:

1019

#

1020

# int* p = new int(7);

1021

#

1022

# { // Captured variable

1023

# name: "p",

1024

# value: "0x00500500",

1025

# type: "int*",

1026

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

1027

#

1028

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

1029

#

1030

# int* p = new int(7);

1031

# int** pp = &p;

1032

#

1033

# { // Captured variable

1034

# name: "pp",

1035

# value: "0x00500500",

1036

# type: "int**",

1037

# members {

1038

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1048

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

1049

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

1050

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

1051

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

1052

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

1053

#

1054

# 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

1061

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

1062

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

1063

#

1064

# { // Shared variable table entry #3:

1065

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

1066

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

1067

# }

1068

#

1069

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

1070

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

1071

# to be shared between pointers and references.

1072

#

1073

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

1074

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

1075

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

1076

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

1077

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

1078

# state.

1079

#

1080

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

1081

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

1082

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

1083

#

1084

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

1085

#

1086

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

1087

#

1088

# Examples of error message applied to value:

1089

#

1090

# * `Malformed string`,

1091

# * `Field f not found in class C`

1092

# * `Null pointer dereference`

1093

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

1094

# specific parts of the containing object.

1095

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

1096

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

Takashi Matsuo

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

[diff] [blame]

1097

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

1098

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

1099

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

1100

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

1101

"A String",

1102

],

Sai Cheemalapati

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

[diff] [blame]

1103

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

1104

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

1110

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

1111

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

Takashi Matsuo

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

[diff] [blame]

1112

},

1113

},

Jon Wayne Parrott

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

[diff] [blame]

1114

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

Sai Cheemalapati

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

[diff] [blame]

1115

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

1116

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

1117

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

Jon Wayne Parrott

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

[diff] [blame]

1118

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

1119

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

1120

# Object with schema name: Variable

1121

],

Sai Cheemalapati

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

[diff] [blame]

1122

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

1123

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

1124

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

1125

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1126

},

1127

],

Sai Cheemalapati

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

[diff] [blame]

1128

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

1129

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

1130

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

1131

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

1132

# of the appropriate expression. Expressions not referenced in

1133

# `log_message_format` are not logged.

1134

#

1135

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

1136

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

Jon Wayne Parrott

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

[diff] [blame]

1137

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

1138

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

1139

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

1140

"a_key": "A String",

1141

},

Bu Sun Kim

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

[diff] [blame]

1142

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

1143

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

1144

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1145

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

Thomas Coffee

2f24537

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

[diff] [blame]

1146

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

1147

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

1148

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

1149

# Note how the following variables are represented:

1150

#

1151

# 1) A simple variable:

#

# int x = 5

#

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

1156

#

1157

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1166

# name: "x",

1167

# type: "T",

1168

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

1169

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

1170

# }

1171

#

1172

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1178

# name: "p",

1179

# type: "T*",

1180

# value: "0x00500500",

1181

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

1182

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

1183

# }

1184

#

1185

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

#

# T* p = new T;

#

# { // Captured variable

1190

# name: "p",

1191

# type: "T*",

1192

# value: "0x00400400"

1193

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

1194

# }

1195

#

1196

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

1197

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

1198

#

1199

# Note that a null pointer should not have members.

1200

#

1201

# 5) An unnamed value:

1202

#

1203

# int* p = new int(7);

1204

#

1205

# { // Captured variable

1206

# name: "p",

1207

# value: "0x00500500",

1208

# type: "int*",

1209

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

1210

#

1211

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

1212

#

1213

# int* p = new int(7);

1214

# int** pp = &p;

1215

#

1216

# { // Captured variable

1217

# name: "pp",

1218

# value: "0x00500500",

1219

# type: "int**",

1220

# members {

1221

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1231

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

1232

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

1233

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

1234

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

1235

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

1236

#

1237

# 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

1244

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

1245

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

1246

#

1247

# { // Shared variable table entry #3:

1248

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

1249

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

1250

# }

1251

#

1252

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

1253

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

1254

# to be shared between pointers and references.

1255

#

1256

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

1257

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

1258

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

1259

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

1260

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

1261

# state.

1262

#

1263

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

1264

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

1265

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

1266

#

1267

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

1268

#

1269

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

1270

#

1271

# Examples of error message applied to value:

1272

#

1273

# * `Malformed string`,

1274

# * `Field f not found in class C`

1275

# * `Null pointer dereference`

1276

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

1277

# specific parts of the containing object.

1278

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

1279

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

1280

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

1281

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

1282

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

1283

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

1284

"A String",

1285

],

1286

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

1287

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

1293

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

1294

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

1295

},

1296

},

1297

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

1298

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

1299

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

1300

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

1301

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

1302

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

1303

# Object with schema name: Variable

1304

],

1305

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

1306

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

1307

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

1308

# rather than a static type of an object.

1309

},

1310

],

Sai Cheemalapati

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

[diff] [blame]

1311

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

1312

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

1313

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

1314

# Note how the following variables are represented:

1315

#

1316

# 1) A simple variable:

#

# int x = 5

#

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

1321

#

1322

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1331

# name: "x",

1332

# type: "T",

1333

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

1334

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

1335

# }

1336

#

1337

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1343

# name: "p",

1344

# type: "T*",

1345

# value: "0x00500500",

1346

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

1347

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

1348

# }

1349

#

1350

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

#

# T* p = new T;

#

# { // Captured variable

1355

# name: "p",

1356

# type: "T*",

1357

# value: "0x00400400"

1358

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

1359

# }

1360

#

1361

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

1362

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

1363

#

1364

# Note that a null pointer should not have members.

1365

#

1366

# 5) An unnamed value:

1367

#

1368

# int* p = new int(7);

1369

#

1370

# { // Captured variable

1371

# name: "p",

1372

# value: "0x00500500",

1373

# type: "int*",

1374

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

1375

#

1376

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

1377

#

1378

# int* p = new int(7);

1379

# int** pp = &p;

1380

#

1381

# { // Captured variable

1382

# name: "pp",

1383

# value: "0x00500500",

1384

# type: "int**",

1385

# members {

1386

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1396

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

1397

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

1398

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

1399

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

1400

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

1401

#

1402

# 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

1409

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

1410

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

1411

#

1412

# { // Shared variable table entry #3:

1413

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

1414

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

1415

# }

1416

#

1417

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

1418

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

1419

# to be shared between pointers and references.

1420

#

1421

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

1422

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

1423

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

1424

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

1425

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

1426

# state.

1427

#

1428

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

1429

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

1430

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

1431

#

1432

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

1433

#

1434

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

1435

#

1436

# Examples of error message applied to value:

1437

#

1438

# * `Malformed string`,

1439

# * `Field f not found in class C`

1440

# * `Null pointer dereference`

1441

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

1442

# specific parts of the containing object.

1443

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

1444

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

1445

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

1446

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

1447

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

1448

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

1449

"A String",

1450

],

1451

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

1452

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

1458

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

1459

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

1460

},

1461

},

1462

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

1463

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

1464

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

1465

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

1466

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

1467

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

1468

# Object with schema name: Variable

1469

],

1470

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

1471

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

1472

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

1473

# rather than a static type of an object.

1474

},

1475

],

1476

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

1477

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

1478

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

1479

# this field.

Sai Cheemalapati

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

[diff] [blame]

1480

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

1481

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

1482

},

Takashi Matsuo

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

[diff] [blame]

1483

},

1484

],

Sai Cheemalapati

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

[diff] [blame]

1485

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

1486

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

Bu Sun Kim

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

[diff] [blame]

1487

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

1488

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

1489

# this field.

Sai Cheemalapati

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

[diff] [blame]

1490

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

1491

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

1492

},

1493

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

1494

# resolution.

1495

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

1496

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame]

1497

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

1498

# The expressions are composed using expressions in the programming language

1499

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

1500

# expressions are included in log statements.

1501

"A String",

1502

],

Sai Cheemalapati

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

[diff] [blame]

1503

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

1504

# breakpoint state will not change from here on.

1505

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

1506

# The evaluated expressions appear in exactly the same order they

1507

# are listed in the `expressions` field.

1508

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

1509

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

1510

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

1511

# will indicate an error and contain the error text.

1512

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

1513

# Note how the following variables are represented:

1514

#

1515

# 1) A simple variable:

#

# int x = 5

#

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

1520

#

1521

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1530

# name: "x",

1531

# type: "T",

1532

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

1533

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

1534

# }

1535

#

1536

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1542

# name: "p",

1543

# type: "T*",

1544

# value: "0x00500500",

1545

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

1546

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

1547

# }

1548

#

1549

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

#

# T* p = new T;

#

# { // Captured variable

1554

# name: "p",

1555

# type: "T*",

1556

# value: "0x00400400"

1557

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

1558

# }

1559

#

1560

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

1561

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

1562

#

1563

# Note that a null pointer should not have members.

1564

#

1565

# 5) An unnamed value:

1566

#

1567

# int* p = new int(7);

1568

#

1569

# { // Captured variable

1570

# name: "p",

1571

# value: "0x00500500",

1572

# type: "int*",

1573

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

1574

#

1575

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

1576

#

1577

# int* p = new int(7);

1578

# int** pp = &p;

1579

#

1580

# { // Captured variable

1581

# name: "pp",

1582

# value: "0x00500500",

1583

# type: "int**",

1584

# members {

1585

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1595

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

1596

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

1597

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

1598

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

1599

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

1600

#

1601

# 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

1608

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

1609

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

1610

#

1611

# { // Shared variable table entry #3:

1612

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

1613

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

1614

# }

1615

#

1616

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

1617

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

1618

# to be shared between pointers and references.

1619

#

1620

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

1621

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

1622

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

1623

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

1624

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

1625

# state.

1626

#

1627

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

1628

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

1629

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

1630

#

1631

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

1632

#

1633

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

1634

#

1635

# Examples of error message applied to value:

1636

#

1637

# * `Malformed string`,

1638

# * `Field f not found in class C`

1639

# * `Null pointer dereference`

1640

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

1641

# specific parts of the containing object.

1642

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

1643

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

Takashi Matsuo

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

[diff] [blame]

1644

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

1645

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

1646

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

1647

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

1648

"A String",

1649

],

Sai Cheemalapati

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

[diff] [blame]

1650

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

1651

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

1657

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

1658

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

Takashi Matsuo

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

[diff] [blame]

1659

},

1660

},

Jon Wayne Parrott

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

[diff] [blame]

1661

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

Sai Cheemalapati

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

[diff] [blame]

1662

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

1663

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

1664

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

Jon Wayne Parrott

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

[diff] [blame]

1665

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

1666

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

1667

# Object with schema name: Variable

1668

],

Sai Cheemalapati

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

[diff] [blame]

1669

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

1670

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

1671

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

1672

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1673

},

1674

],

1675

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

Sai Cheemalapati

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

[diff] [blame]

1676

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

1677

# The condition is a compound boolean expression composed using expressions

1678

# in a programming language at the source location.

Takashi Matsuo

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

[diff] [blame]

},

}

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

1683

Allowed values

1684

1 - v1 error format

1685

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

1686

1687

Returns:

1688

An object of the form:

1689

Sai Cheemalapati

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

[diff] [blame]

1690

{ # Response for updating an active breakpoint.

1691

# The message is defined to allow future extensions.

Takashi Matsuo