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

Jon Wayne Parrott

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

[diff] [blame]

78

<code><a href="#list">list(debuggeeId, successOnTimeout=None, waitToken=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

Jon Wayne Parrott

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

[diff] [blame]

85

<code class="details" id="list">list(debuggeeId, successOnTimeout=None, waitToken=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

88

The breakpoint specification (location, condition, and expression

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)

Sai Cheemalapati

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

[diff] [blame]

102

successOnTimeout: boolean, If set to `true`, returns `google.rpc.Code.OK` status and sets the

103

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

104

has expired (recommended).

105

106

If set to `false`, returns `google.rpc.Code.ABORTED` status when the

107

server-selected timeout has expired (deprecated).

108

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

109

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

110

expired. The value should be set from the last returned response.

Takashi Matsuo

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

[diff] [blame]

111

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

112

Allowed values

113

1 - v1 error format

114

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

115

116

Returns:

117

An object of the form:

118

Jon Wayne Parrott

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

[diff] [blame]

119

{ # Response for listing active breakpoints.

Sai Cheemalapati

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

[diff] [blame]

120

"waitExpired": True or False, # The `wait_expired` field is set to true by the server when the

121

# request times out and the field `success_on_timeout` is set to true.

122

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

123

# the list of breakpoints changes.

124

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

125

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

Takashi Matsuo

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

[diff] [blame]

126

{ # Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

127

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

128

#

129

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

130

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

131

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

132

# display the text message back to the user.

133

#

134

# Error status indicates complete failure of the breakpoint.

135

#

136

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

137

#

138

# Examples (final state):

139

#

140

# * `Invalid line number` referring to location

141

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

142

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

143

# specific parts of the containing object.

144

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

145

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

Takashi Matsuo

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

[diff] [blame]

146

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

147

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

148

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

149

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

150

"A String",

151

],

Sai Cheemalapati

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

[diff] [blame]

152

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

153

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

159

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

160

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

Takashi Matsuo

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

[diff] [blame]

161

},

162

},

Sai Cheemalapati

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

[diff] [blame]

163

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

164

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

165

# it from multiple variables, including variables stored in the

166

# `variable_table` itself.

167

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

168

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

169

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

170

#

171

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

172

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

173

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

174

# and the referenced variable.

175

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

176

# Note how the following variables are represented:

177

#

178

# 1) A simple variable:

#

# int x = 5

#

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

183

#

184

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

193

# name: "x",

194

# type: "T",

195

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

196

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

197

# }

198

#

199

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

205

# name: "p",

206

# type: "T*",

207

# value: "0x00500500",

208

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

209

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

210

# }

211

#

212

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

#

# T* p = new T;

#

# { // Captured variable

217

# name: "p",

218

# type: "T*",

219

# value: "0x00400400"

220

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

221

# }

222

#

223

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

224

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

225

#

226

# Note that a null pointer should not have members.

227

#

228

# 5) An unnamed value:

229

#

230

# int* p = new int(7);

231

#

232

# { // Captured variable

233

# name: "p",

234

# value: "0x00500500",

235

# type: "int*",

236

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

237

#

238

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

239

#

240

# int* p = new int(7);

241

# int** pp = &p;

242

#

243

# { // Captured variable

244

# name: "pp",

245

# value: "0x00500500",

246

# type: "int**",

247

# members {

248

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

258

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

259

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

260

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

261

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

262

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

263

#

264

# 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

271

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

272

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

273

#

274

# { // Shared variable table entry #3:

275

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

276

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

277

# }

278

#

279

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

280

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

281

# to be shared between pointers and references.

282

#

283

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

284

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

285

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

286

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

287

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

288

# state.

289

#

290

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

291

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

292

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

293

#

294

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

295

#

296

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

297

#

298

# Examples of error message applied to value:

299

#

300

# * `Malformed string`,

301

# * `Field f not found in class C`

302

# * `Null pointer dereference`

303

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

304

# specific parts of the containing object.

305

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

306

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

Takashi Matsuo

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

[diff] [blame]

307

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

308

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

309

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

310

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

311

"A String",

312

],

Sai Cheemalapati

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

[diff] [blame]

313

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

314

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

320

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

321

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

Takashi Matsuo

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

[diff] [blame]

322

},

323

},

Jon Wayne Parrott

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

[diff] [blame]

324

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

Sai Cheemalapati

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

[diff] [blame]

325

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

326

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

327

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

Jon Wayne Parrott

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

[diff] [blame]

328

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

329

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

330

# Object with schema name: Variable

331

],

Sai Cheemalapati

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

[diff] [blame]

332

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

333

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

334

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

335

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

336

},

337

],

Sai Cheemalapati

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

[diff] [blame]

338

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

Jon Wayne Parrott

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

[diff] [blame]

339

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

340

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

341

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

342

"a_key": "A String",

343

},

Takashi Matsuo

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

[diff] [blame]

344

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

345

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

346

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

Thomas Coffee

2f24537

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

[diff] [blame]

347

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

348

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

349

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

350

# Note how the following variables are represented:

351

#

352

# 1) A simple variable:

#

# int x = 5

#

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

357

#

358

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

367

# name: "x",

368

# type: "T",

369

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

370

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

371

# }

372

#

373

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

379

# name: "p",

380

# type: "T*",

381

# value: "0x00500500",

382

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

383

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

384

# }

385

#

386

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

#

# T* p = new T;

#

# { // Captured variable

391

# name: "p",

392

# type: "T*",

393

# value: "0x00400400"

394

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

395

# }

396

#

397

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

398

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

399

#

400

# Note that a null pointer should not have members.

401

#

402

# 5) An unnamed value:

403

#

404

# int* p = new int(7);

405

#

406

# { // Captured variable

407

# name: "p",

408

# value: "0x00500500",

409

# type: "int*",

410

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

411

#

412

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

413

#

414

# int* p = new int(7);

415

# int** pp = &p;

416

#

417

# { // Captured variable

418

# name: "pp",

419

# value: "0x00500500",

420

# type: "int**",

421

# members {

422

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

432

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

433

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

434

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

435

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

436

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

437

#

438

# 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

445

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

446

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

447

#

448

# { // Shared variable table entry #3:

449

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

450

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

451

# }

452

#

453

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

454

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

455

# to be shared between pointers and references.

456

#

457

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

458

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

459

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

460

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

461

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

462

# state.

463

#

464

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

465

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

466

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

467

#

468

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

469

#

470

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

471

#

472

# Examples of error message applied to value:

473

#

474

# * `Malformed string`,

475

# * `Field f not found in class C`

476

# * `Null pointer dereference`

477

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

478

# specific parts of the containing object.

479

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

480

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

481

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

482

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

483

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

484

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

485

"A String",

486

],

487

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

488

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

494

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

495

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

496

},

497

},

498

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

499

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

500

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

501

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

502

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

503

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

504

# Object with schema name: Variable

505

],

506

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

507

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

508

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

509

# rather than a static type of an object.

510

},

511

],

Sai Cheemalapati

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

[diff] [blame]

512

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

513

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

514

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

515

# Note how the following variables are represented:

516

#

517

# 1) A simple variable:

#

# int x = 5

#

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

522

#

523

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

532

# name: "x",

533

# type: "T",

534

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

535

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

536

# }

537

#

538

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

544

# name: "p",

545

# type: "T*",

546

# value: "0x00500500",

547

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

548

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

549

# }

550

#

551

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

#

# T* p = new T;

#

# { // Captured variable

556

# name: "p",

557

# type: "T*",

558

# value: "0x00400400"

559

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

560

# }

561

#

562

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

563

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

564

#

565

# Note that a null pointer should not have members.

566

#

567

# 5) An unnamed value:

568

#

569

# int* p = new int(7);

570

#

571

# { // Captured variable

572

# name: "p",

573

# value: "0x00500500",

574

# type: "int*",

575

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

576

#

577

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

578

#

579

# int* p = new int(7);

580

# int** pp = &p;

581

#

582

# { // Captured variable

583

# name: "pp",

584

# value: "0x00500500",

585

# type: "int**",

586

# members {

587

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

597

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

598

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

599

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

600

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

601

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

602

#

603

# 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

610

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

611

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

612

#

613

# { // Shared variable table entry #3:

614

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

615

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

616

# }

617

#

618

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

619

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

620

# to be shared between pointers and references.

621

#

622

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

623

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

624

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

625

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

626

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

627

# state.

628

#

629

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

630

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

631

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

632

#

633

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

634

#

635

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

636

#

637

# Examples of error message applied to value:

638

#

639

# * `Malformed string`,

640

# * `Field f not found in class C`

641

# * `Null pointer dereference`

642

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

643

# specific parts of the containing object.

644

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

645

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

646

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

647

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

648

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

649

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

650

"A String",

651

],

652

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

653

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

659

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

660

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

661

},

662

},

663

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

664

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

665

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

666

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

667

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

668

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

669

# Object with schema name: Variable

670

],

671

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

672

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

673

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

674

# rather than a static type of an object.

675

},

676

],

677

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

678

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

679

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

680

},

Takashi Matsuo

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

[diff] [blame]

681

},

682

],

Sai Cheemalapati

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

[diff] [blame]

683

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

Sai Cheemalapati

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

[diff] [blame]

684

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

685

# The expressions are composed using expressions in the programming language

686

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

687

# expressions are included in log statements.

Takashi Matsuo

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

[diff] [blame]

688

"A String",

689

],

Sai Cheemalapati

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

[diff] [blame]

690

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

691

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

692

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

693

},

694

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

695

# resolution.

696

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

697

# breakpoint location is hit.

698

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

699

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

700

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

701

# of the appropriate expression. Expressions not referenced in

702

# `log_message_format` are not logged.

703

#

704

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

705

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

Sai Cheemalapati

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

[diff] [blame]

706

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

707

# breakpoint state will not change from here on.

708

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

709

# The evaluated expressions appear in exactly the same order they

710

# are listed in the `expressions` field.

711

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

712

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

713

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

714

# will indicate an error and contain the error text.

715

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

716

# Note how the following variables are represented:

717

#

718

# 1) A simple variable:

#

# int x = 5

#

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

723

#

724

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

733

# name: "x",

734

# type: "T",

735

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

736

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

737

# }

738

#

739

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

745

# name: "p",

746

# type: "T*",

747

# value: "0x00500500",

748

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

749

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

750

# }

751

#

752

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

#

# T* p = new T;

#

# { // Captured variable

757

# name: "p",

758

# type: "T*",

759

# value: "0x00400400"

760

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

761

# }

762

#

763

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

764

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

765

#

766

# Note that a null pointer should not have members.

767

#

768

# 5) An unnamed value:

769

#

770

# int* p = new int(7);

771

#

772

# { // Captured variable

773

# name: "p",

774

# value: "0x00500500",

775

# type: "int*",

776

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

777

#

778

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

779

#

780

# int* p = new int(7);

781

# int** pp = &p;

782

#

783

# { // Captured variable

784

# name: "pp",

785

# value: "0x00500500",

786

# type: "int**",

787

# members {

788

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

798

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

799

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

800

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

801

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

802

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

803

#

804

# 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

811

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

812

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

813

#

814

# { // Shared variable table entry #3:

815

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

816

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

817

# }

818

#

819

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

820

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

821

# to be shared between pointers and references.

822

#

823

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

824

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

825

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

826

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

827

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

828

# state.

829

#

830

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

831

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

832

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

833

#

834

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

835

#

836

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

837

#

838

# Examples of error message applied to value:

839

#

840

# * `Malformed string`,

841

# * `Field f not found in class C`

842

# * `Null pointer dereference`

843

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

844

# specific parts of the containing object.

845

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

846

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

Takashi Matsuo

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

[diff] [blame]

847

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

848

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

849

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

850

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

851

"A String",

852

],

Sai Cheemalapati

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

[diff] [blame]

853

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

854

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

860

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

861

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

Takashi Matsuo

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

[diff] [blame]

862

},

863

},

Jon Wayne Parrott

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

[diff] [blame]

864

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

Sai Cheemalapati

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

[diff] [blame]

865

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

866

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

867

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

Jon Wayne Parrott

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

[diff] [blame]

868

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

869

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

870

# Object with schema name: Variable

871

],

Sai Cheemalapati

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

[diff] [blame]

872

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

873

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

874

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

875

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

876

},

877

],

878

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

Sai Cheemalapati

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

[diff] [blame]

879

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

880

# The condition is a compound boolean expression composed using expressions

881

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

889

<pre>Updates the breakpoint state or mutable fields.

890

The entire Breakpoint message must be sent back to the controller

891

service.

892

893

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

894

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

895

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

896

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

897

or snapping the location to the correct line of code.

Takashi Matsuo

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

[diff] [blame]

898

899

Args:

900

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

901

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

902

body: object, The request body. (required)

903

The object takes the form of:

904

Jon Wayne Parrott

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

[diff] [blame]

905

{ # Request to update an active breakpoint.

Sai Cheemalapati

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

[diff] [blame]

906

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

907

# The field 'id' must be set.

908

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

909

#

910

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

911

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

912

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

913

# display the text message back to the user.

914

#

915

# Error status indicates complete failure of the breakpoint.

916

#

917

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

918

#

919

# Examples (final state):

920

#

921

# * `Invalid line number` referring to location

922

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

923

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

924

# specific parts of the containing object.

925

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

926

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

Takashi Matsuo

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

[diff] [blame]

927

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

928

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

929

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

930

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

931

"A String",

932

],

Sai Cheemalapati

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

[diff] [blame]

933

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

934

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

940

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

941

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

Takashi Matsuo

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

[diff] [blame]

942

},

943

},

Sai Cheemalapati

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

[diff] [blame]

944

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

945

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

946

# it from multiple variables, including variables stored in the

947

# `variable_table` itself.

948

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

949

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

950

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

951

#

952

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

953

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

954

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

955

# and the referenced variable.

956

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

957

# Note how the following variables are represented:

958

#

959

# 1) A simple variable:

#

# int x = 5

#

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

964

#

965

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

974

# name: "x",

975

# type: "T",

976

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

977

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

978

# }

979

#

980

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

986

# name: "p",

987

# type: "T*",

988

# value: "0x00500500",

989

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

990

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

991

# }

992

#

993

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

#

# T* p = new T;

#

# { // Captured variable

998

# name: "p",

999

# type: "T*",

1000

# value: "0x00400400"

1001

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

1002

# }

1003

#

1004

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

1005

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

1006

#

1007

# Note that a null pointer should not have members.

1008

#

1009

# 5) An unnamed value:

1010

#

1011

# int* p = new int(7);

1012

#

1013

# { // Captured variable

1014

# name: "p",

1015

# value: "0x00500500",

1016

# type: "int*",

1017

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

1018

#

1019

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

1020

#

1021

# int* p = new int(7);

1022

# int** pp = &p;

1023

#

1024

# { // Captured variable

1025

# name: "pp",

1026

# value: "0x00500500",

1027

# type: "int**",

1028

# members {

1029

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1039

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

1040

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

1041

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

1042

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

1043

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

1044

#

1045

# 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

1052

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

1053

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

1054

#

1055

# { // Shared variable table entry #3:

1056

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

1057

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

1058

# }

1059

#

1060

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

1061

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

1062

# to be shared between pointers and references.

1063

#

1064

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

1065

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

1066

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

1067

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

1068

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

1069

# state.

1070

#

1071

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

1072

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

1073

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

1074

#

1075

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

1076

#

1077

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

1078

#

1079

# Examples of error message applied to value:

1080

#

1081

# * `Malformed string`,

1082

# * `Field f not found in class C`

1083

# * `Null pointer dereference`

1084

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

1085

# specific parts of the containing object.

1086

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

1087

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

Takashi Matsuo

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

[diff] [blame]

1088

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

1089

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

1090

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

1091

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

1092

"A String",

1093

],

Sai Cheemalapati

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

[diff] [blame]

1094

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

1095

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

1101

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

1102

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

Takashi Matsuo

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

[diff] [blame]

1103

},

1104

},

Jon Wayne Parrott

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

[diff] [blame]

1105

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

Sai Cheemalapati

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

[diff] [blame]

1106

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

1107

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

1108

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

Jon Wayne Parrott

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

[diff] [blame]

1109

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

1110

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

1111

# Object with schema name: Variable

1112

],

Sai Cheemalapati

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

[diff] [blame]

1113

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

1114

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

1115

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

1116

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1117

},

1118

],

Sai Cheemalapati

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

[diff] [blame]

1119

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

Jon Wayne Parrott

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

[diff] [blame]

1120

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

1121

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

1122

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

1123

"a_key": "A String",

1124

},

Takashi Matsuo

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

[diff] [blame]

1125

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

1126

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1127

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

Thomas Coffee

2f24537

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

[diff] [blame]

1128

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

1129

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

1130

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

1131

# Note how the following variables are represented:

1132

#

1133

# 1) A simple variable:

#

# int x = 5

#

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

1138

#

1139

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1148

# name: "x",

1149

# type: "T",

1150

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

1151

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

1152

# }

1153

#

1154

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1160

# name: "p",

1161

# type: "T*",

1162

# value: "0x00500500",

1163

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

1164

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

1165

# }

1166

#

1167

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

#

# T* p = new T;

#

# { // Captured variable

1172

# name: "p",

1173

# type: "T*",

1174

# value: "0x00400400"

1175

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

1176

# }

1177

#

1178

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

1179

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

1180

#

1181

# Note that a null pointer should not have members.

1182

#

1183

# 5) An unnamed value:

1184

#

1185

# int* p = new int(7);

1186

#

1187

# { // Captured variable

1188

# name: "p",

1189

# value: "0x00500500",

1190

# type: "int*",

1191

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

1192

#

1193

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

1194

#

1195

# int* p = new int(7);

1196

# int** pp = &p;

1197

#

1198

# { // Captured variable

1199

# name: "pp",

1200

# value: "0x00500500",

1201

# type: "int**",

1202

# members {

1203

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1213

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

1214

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

1215

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

1216

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

1217

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

1218

#

1219

# 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

1226

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

1227

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

1228

#

1229

# { // Shared variable table entry #3:

1230

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

1231

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

1232

# }

1233

#

1234

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

1235

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

1236

# to be shared between pointers and references.

1237

#

1238

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

1239

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

1240

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

1241

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

1242

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

1243

# state.

1244

#

1245

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

1246

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

1247

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

1248

#

1249

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

1250

#

1251

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

1252

#

1253

# Examples of error message applied to value:

1254

#

1255

# * `Malformed string`,

1256

# * `Field f not found in class C`

1257

# * `Null pointer dereference`

1258

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

1259

# specific parts of the containing object.

1260

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

1261

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

1262

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

1263

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

1264

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

1265

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

1266

"A String",

1267

],

1268

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

1269

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

# character.

#

# Examples:

#

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

1275

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

1276

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

1277

},

1278

},

1279

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

1280

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

1281

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

1282

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

1283

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

1284

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

1285

# Object with schema name: Variable

1286

],

1287

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

1288

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

1289

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

1290

# rather than a static type of an object.

1291

},

1292

],

Sai Cheemalapati

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

[diff] [blame]

1293

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

1294

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

1295

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

1296

# Note how the following variables are represented:

1297

#

1298

# 1) A simple variable:

#

# int x = 5

#

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

1303

#

1304

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1313

# name: "x",

1314

# type: "T",

1315

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

1316

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

1317

# }

1318

#

1319

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1325

# name: "p",

1326

# type: "T*",

1327

# value: "0x00500500",

1328

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

1329

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

1330

# }

1331

#

1332

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

#

# T* p = new T;

#

# { // Captured variable

1337

# name: "p",

1338

# type: "T*",

1339

# value: "0x00400400"

1340

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

1341

# }

1342

#

1343

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

1344

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

1345

#

1346

# Note that a null pointer should not have members.

1347

#

1348

# 5) An unnamed value:

1349

#

1350

# int* p = new int(7);

1351

#

1352

# { // Captured variable

1353

# name: "p",

1354

# value: "0x00500500",

1355

# type: "int*",

1356

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

1357

#

1358

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

1359

#

1360

# int* p = new int(7);

1361

# int** pp = &p;

1362

#

1363

# { // Captured variable

1364

# name: "pp",

1365

# value: "0x00500500",

1366

# type: "int**",

1367

# members {

1368

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1378

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

1379

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

1380

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

1381

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

1382

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

1383

#

1384

# 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

1391

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

1392

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

1393

#

1394

# { // Shared variable table entry #3:

1395

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

1396

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

1397

# }

1398

#

1399

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

1400

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

1401

# to be shared between pointers and references.

1402

#

1403

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

1404

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

1405

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

1406

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

1407

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

1408

# state.

1409

#

1410

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

1411

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

1412

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

1413

#

1414

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

1415

#

1416

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

1417

#

1418

# Examples of error message applied to value:

1419

#

1420

# * `Malformed string`,

1421

# * `Field f not found in class C`

1422

# * `Null pointer dereference`

1423

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

1424

# specific parts of the containing object.

1425

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

1426

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

1427

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

1428

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

1429

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

1430

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

1431

"A String",

1432

],

1433

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

1434

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

1440

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

1441

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

1442

},

1443

},

1444

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

1445

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

1446

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

1447

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

1448

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

1449

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

1450

# Object with schema name: Variable

1451

],

1452

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

1453

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

1454

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

1455

# rather than a static type of an object.

1456

},

1457

],

1458

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

1459

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

1460

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

1461

},

Takashi Matsuo

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

[diff] [blame]

1462

},

1463

],

Sai Cheemalapati

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

[diff] [blame]

1464

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

Sai Cheemalapati

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

[diff] [blame]

1465

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

1466

# The expressions are composed using expressions in the programming language

1467

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

1468

# expressions are included in log statements.

Takashi Matsuo

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

[diff] [blame]

1469

"A String",

1470

],

Sai Cheemalapati

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

[diff] [blame]

1471

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

1472

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

1473

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

1474

},

1475

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

1476

# resolution.

1477

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

1478

# breakpoint location is hit.

1479

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

1480

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

1481

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

1482

# of the appropriate expression. Expressions not referenced in

1483

# `log_message_format` are not logged.

1484

#

1485

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

1486

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

Sai Cheemalapati

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

[diff] [blame]

1487

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

1488

# breakpoint state will not change from here on.

1489

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

1490

# The evaluated expressions appear in exactly the same order they

1491

# are listed in the `expressions` field.

1492

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

1493

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

1494

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

1495

# will indicate an error and contain the error text.

1496

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

1497

# Note how the following variables are represented:

1498

#

1499

# 1) A simple variable:

#

# int x = 5

#

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

1504

#

1505

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1514

# name: "x",

1515

# type: "T",

1516

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

1517

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

1518

# }

1519

#

1520

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1526

# name: "p",

1527

# type: "T*",

1528

# value: "0x00500500",

1529

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

1530

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

1531

# }

1532

#

1533

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

#

# T* p = new T;

#

# { // Captured variable

1538

# name: "p",

1539

# type: "T*",

1540

# value: "0x00400400"

1541

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

1542

# }

1543

#

1544

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

1545

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

1546

#

1547

# Note that a null pointer should not have members.

1548

#

1549

# 5) An unnamed value:

1550

#

1551

# int* p = new int(7);

1552

#

1553

# { // Captured variable

1554

# name: "p",

1555

# value: "0x00500500",

1556

# type: "int*",

1557

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

1558

#

1559

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

1560

#

1561

# int* p = new int(7);

1562

# int** pp = &p;

1563

#

1564

# { // Captured variable

1565

# name: "pp",

1566

# value: "0x00500500",

1567

# type: "int**",

1568

# members {

1569

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1579

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

1580

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

1581

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

1582

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

1583

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

1584

#

1585

# 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

1592

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

1593

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

1594

#

1595

# { // Shared variable table entry #3:

1596

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

1597

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

1598

# }

1599

#

1600

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

1601

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

1602

# to be shared between pointers and references.

1603

#

1604

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

1605

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

1606

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

1607

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

1608

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

1609

# state.

1610

#

1611

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

1612

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

1613

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

1614

#

1615

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

1616

#

1617

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

1618

#

1619

# Examples of error message applied to value:

1620

#

1621

# * `Malformed string`,

1622

# * `Field f not found in class C`

1623

# * `Null pointer dereference`

1624

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

1625

# specific parts of the containing object.

1626

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

1627

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

Takashi Matsuo

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

[diff] [blame]

1628

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

1629

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

1630

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

1631

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

1632

"A String",

1633

],

Sai Cheemalapati

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

[diff] [blame]

1634

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

1635

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

1641

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

1642

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

Takashi Matsuo

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

[diff] [blame]

1643

},

1644

},

Jon Wayne Parrott

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

[diff] [blame]

1645

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

Sai Cheemalapati

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

[diff] [blame]

1646

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

1647

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

1648

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

Jon Wayne Parrott

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

[diff] [blame]

1649

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

1650

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

1651

# Object with schema name: Variable

1652

],

Sai Cheemalapati

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

[diff] [blame]

1653

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

1654

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

1655

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

1656

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1657

},

1658

],

1659

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

Sai Cheemalapati

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

[diff] [blame]

1660

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

1661

# The condition is a compound boolean expression composed using expressions

1662

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

1667

Allowed values

1668

1 - v1 error format

1669

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

1670

1671

Returns:

1672

An object of the form:

1673

Sai Cheemalapati

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

[diff] [blame]

1674

{ # Response for updating an active breakpoint.

1675

# The message is defined to allow future extensions.

Takashi Matsuo