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-03-13 12:12:03 -0400

[diff] [blame^]

338

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

339

# resolution.

Jon Wayne Parrott

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

[diff] [blame]

340

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

341

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

342

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

343

"a_key": "A String",

344

},

Sai Cheemalapati

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

[diff] [blame^]

345

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

346

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

347

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

348

# of the appropriate expression. Expressions not referenced in

349

# `log_message_format` are not logged.

350

#

351

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

352

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

353

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

354

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

Takashi Matsuo

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

[diff] [blame]

355

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

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.

358

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

359

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

360

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

Takashi Matsuo

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

[diff] [blame]

361

},

Sai Cheemalapati

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

[diff] [blame^]

362

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

363

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

364

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

365

# Note how the following variables are represented:

366

#

367

# 1) A simple variable:

#

# int x = 5

#

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

372

#

373

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

382

# name: "x",

383

# type: "T",

384

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

385

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

386

# }

387

#

388

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

394

# name: "p",

395

# type: "T*",

396

# value: "0x00500500",

397

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

398

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

399

# }

400

#

401

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

#

# T* p = new T;

#

# { // Captured variable

406

# name: "p",

407

# type: "T*",

408

# value: "0x00400400"

409

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

410

# }

411

#

412

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

413

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

414

#

415

# Note that a null pointer should not have members.

416

#

417

# 5) An unnamed value:

418

#

419

# int* p = new int(7);

420

#

421

# { // Captured variable

422

# name: "p",

423

# value: "0x00500500",

424

# type: "int*",

425

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

426

#

427

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

428

#

429

# int* p = new int(7);

430

# int** pp = &p;

431

#

432

# { // Captured variable

433

# name: "pp",

434

# value: "0x00500500",

435

# type: "int**",

436

# members {

437

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

447

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

448

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

449

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

450

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

451

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

452

#

453

# 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

460

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

461

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

462

#

463

# { // Shared variable table entry #3:

464

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

465

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

466

# }

467

#

468

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

469

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

470

# to be shared between pointers and references.

471

#

472

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

473

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

474

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

475

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

476

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

477

# state.

478

#

479

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

480

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

481

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

482

#

483

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

484

#

485

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

486

#

487

# Examples of error message applied to value:

488

#

489

# * `Malformed string`,

490

# * `Field f not found in class C`

491

# * `Null pointer dereference`

492

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

493

# specific parts of the containing object.

494

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

495

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

Takashi Matsuo

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

[diff] [blame]

496

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

497

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

498

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

499

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

500

"A String",

501

],

Sai Cheemalapati

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

[diff] [blame^]

502

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

503

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

509

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

510

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

Takashi Matsuo

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

[diff] [blame]

511

},

512

},

Jon Wayne Parrott

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

[diff] [blame]

513

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

Sai Cheemalapati

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

[diff] [blame^]

514

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

515

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

516

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

Jon Wayne Parrott

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

[diff] [blame]

517

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

518

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

519

# Object with schema name: Variable

520

],

Sai Cheemalapati

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

[diff] [blame^]

521

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

522

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

523

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

524

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

525

},

526

],

Sai Cheemalapati

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

[diff] [blame^]

527

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

528

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

529

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

530

# Note how the following variables are represented:

531

#

532

# 1) A simple variable:

#

# int x = 5

#

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

537

#

538

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

547

# name: "x",

548

# type: "T",

549

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

550

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

551

# }

552

#

553

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

559

# name: "p",

560

# type: "T*",

561

# value: "0x00500500",

562

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

563

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

564

# }

565

#

566

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

#

# T* p = new T;

#

# { // Captured variable

571

# name: "p",

572

# type: "T*",

573

# value: "0x00400400"

574

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

575

# }

576

#

577

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

578

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

579

#

580

# Note that a null pointer should not have members.

581

#

582

# 5) An unnamed value:

583

#

584

# int* p = new int(7);

585

#

586

# { // Captured variable

587

# name: "p",

588

# value: "0x00500500",

589

# type: "int*",

590

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

591

#

592

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

593

#

594

# int* p = new int(7);

595

# int** pp = &p;

596

#

597

# { // Captured variable

598

# name: "pp",

599

# value: "0x00500500",

600

# type: "int**",

601

# members {

602

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

612

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

613

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

614

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

615

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

616

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

617

#

618

# 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

625

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

626

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

627

#

628

# { // Shared variable table entry #3:

629

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

630

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

631

# }

632

#

633

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

634

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

635

# to be shared between pointers and references.

636

#

637

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

638

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

639

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

640

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

641

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

642

# state.

643

#

644

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

645

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

646

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

647

#

648

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

649

#

650

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

651

#

652

# Examples of error message applied to value:

653

#

654

# * `Malformed string`,

655

# * `Field f not found in class C`

656

# * `Null pointer dereference`

657

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

658

# specific parts of the containing object.

659

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

660

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

Takashi Matsuo

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

[diff] [blame]

661

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

662

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

663

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

664

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

665

"A String",

666

],

Sai Cheemalapati

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

[diff] [blame^]

667

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

668

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

674

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

675

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

Takashi Matsuo

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

[diff] [blame]

676

},

677

},

Jon Wayne Parrott

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

[diff] [blame]

678

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

Sai Cheemalapati

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

[diff] [blame^]

679

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

680

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

681

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

Jon Wayne Parrott

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

[diff] [blame]

682

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

683

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

684

# Object with schema name: Variable

685

],

Sai Cheemalapati

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

[diff] [blame^]

686

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

687

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

688

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

689

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

},

],

},

],

Jon Wayne Parrott

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

[diff] [blame]

694

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

695

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

696

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

Takashi Matsuo

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

[diff] [blame]

697

},

Sai Cheemalapati

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

[diff] [blame^]

698

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

699

# breakpoint location is hit.

700

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

701

# The expressions are composed using expressions in the programming language

702

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

703

# expressions are included in log statements.

Takashi Matsuo

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

[diff] [blame]

704

"A String",

705

],

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-03-13 12:12:03 -0400

[diff] [blame^]

1119

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

1120

# resolution.

Jon Wayne Parrott

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

[diff] [blame]

1121

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

1122

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

1123

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

1124

"a_key": "A String",

1125

},

Sai Cheemalapati

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

[diff] [blame^]

1126

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

1127

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

1128

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

1129

# of the appropriate expression. Expressions not referenced in

1130

# `log_message_format` are not logged.

1131

#

1132

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

1133

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

1134

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

1135

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

Takashi Matsuo

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

[diff] [blame]

1136

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

1137

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1138

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

1139

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

1140

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

1141

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

Takashi Matsuo

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

[diff] [blame]

1142

},

Sai Cheemalapati

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

[diff] [blame^]

1143

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

1144

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

1145

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

1146

# Note how the following variables are represented:

1147

#

1148

# 1) A simple variable:

#

# int x = 5

#

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

1153

#

1154

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1163

# name: "x",

1164

# type: "T",

1165

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

1166

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

1167

# }

1168

#

1169

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1175

# name: "p",

1176

# type: "T*",

1177

# value: "0x00500500",

1178

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

1179

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

1180

# }

1181

#

1182

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

#

# T* p = new T;

#

# { // Captured variable

1187

# name: "p",

1188

# type: "T*",

1189

# value: "0x00400400"

1190

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

1191

# }

1192

#

1193

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

1194

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

1195

#

1196

# Note that a null pointer should not have members.

1197

#

1198

# 5) An unnamed value:

1199

#

1200

# int* p = new int(7);

1201

#

1202

# { // Captured variable

1203

# name: "p",

1204

# value: "0x00500500",

1205

# type: "int*",

1206

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

1207

#

1208

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

1209

#

1210

# int* p = new int(7);

1211

# int** pp = &p;

1212

#

1213

# { // Captured variable

1214

# name: "pp",

1215

# value: "0x00500500",

1216

# type: "int**",

1217

# members {

1218

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1228

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

1229

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

1230

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

1231

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

1232

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

1233

#

1234

# 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

1241

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

1242

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

1243

#

1244

# { // Shared variable table entry #3:

1245

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

1246

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

1247

# }

1248

#

1249

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

1250

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

1251

# to be shared between pointers and references.

1252

#

1253

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

1254

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

1255

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

1256

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

1257

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

1258

# state.

1259

#

1260

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

1261

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

1262

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

1263

#

1264

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

1265

#

1266

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

1267

#

1268

# Examples of error message applied to value:

1269

#

1270

# * `Malformed string`,

1271

# * `Field f not found in class C`

1272

# * `Null pointer dereference`

1273

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

1274

# specific parts of the containing object.

1275

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

1276

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

Takashi Matsuo

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

[diff] [blame]

1277

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

1278

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

1279

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

1280

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

1281

"A String",

1282

],

Sai Cheemalapati

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

[diff] [blame^]

1283

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

1284

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

1290

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

1291

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

Takashi Matsuo

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

[diff] [blame]

1292

},

1293

},

Jon Wayne Parrott

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

[diff] [blame]

1294

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

Sai Cheemalapati

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

[diff] [blame^]

1295

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

1296

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

1297

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

Jon Wayne Parrott

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

[diff] [blame]

1298

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

1299

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

1300

# Object with schema name: Variable

1301

],

Sai Cheemalapati

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

[diff] [blame^]

1302

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

1303

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

1304

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

1305

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1306

},

1307

],

Sai Cheemalapati

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

[diff] [blame^]

1308

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

1309

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

1310

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

1311

# Note how the following variables are represented:

1312

#

1313

# 1) A simple variable:

#

# int x = 5

#

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

1318

#

1319

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1328

# name: "x",

1329

# type: "T",

1330

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

1331

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

1332

# }

1333

#

1334

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1340

# name: "p",

1341

# type: "T*",

1342

# value: "0x00500500",

1343

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

1344

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

1345

# }

1346

#

1347

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

#

# T* p = new T;

#

# { // Captured variable

1352

# name: "p",

1353

# type: "T*",

1354

# value: "0x00400400"

1355

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

1356

# }

1357

#

1358

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

1359

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

1360

#

1361

# Note that a null pointer should not have members.

1362

#

1363

# 5) An unnamed value:

1364

#

1365

# int* p = new int(7);

1366

#

1367

# { // Captured variable

1368

# name: "p",

1369

# value: "0x00500500",

1370

# type: "int*",

1371

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

1372

#

1373

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

1374

#

1375

# int* p = new int(7);

1376

# int** pp = &p;

1377

#

1378

# { // Captured variable

1379

# name: "pp",

1380

# value: "0x00500500",

1381

# type: "int**",

1382

# members {

1383

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1393

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

1394

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

1395

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

1396

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

1397

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

1398

#

1399

# 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

1406

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

1407

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

1408

#

1409

# { // Shared variable table entry #3:

1410

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

1411

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

1412

# }

1413

#

1414

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

1415

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

1416

# to be shared between pointers and references.

1417

#

1418

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

1419

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

1420

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

1421

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

1422

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

1423

# state.

1424

#

1425

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

1426

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

1427

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

1428

#

1429

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

1430

#

1431

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

1432

#

1433

# Examples of error message applied to value:

1434

#

1435

# * `Malformed string`,

1436

# * `Field f not found in class C`

1437

# * `Null pointer dereference`

1438

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

1439

# specific parts of the containing object.

1440

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

1441

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

Takashi Matsuo

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

[diff] [blame]

1442

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

1443

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

1444

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

1445

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

1446

"A String",

1447

],

Sai Cheemalapati

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

[diff] [blame^]

1448

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

1449

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

1455

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

1456

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

Takashi Matsuo

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

[diff] [blame]

1457

},

1458

},

Jon Wayne Parrott

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

[diff] [blame]

1459

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

Sai Cheemalapati

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

[diff] [blame^]

1460

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

1461

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

1462

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

Jon Wayne Parrott

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

[diff] [blame]

1463

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

1464

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

1465

# Object with schema name: Variable

1466

],

Sai Cheemalapati

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

[diff] [blame^]

1467

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

1468

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

1469

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

1470

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

},

],

},

],

Jon Wayne Parrott

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

[diff] [blame]

1475

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

1476

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

1477

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

Takashi Matsuo

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

[diff] [blame]

1478

},

Sai Cheemalapati

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

[diff] [blame^]

1479

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

1480

# breakpoint location is hit.

1481

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

1482

# The expressions are composed using expressions in the programming language

1483

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

1484

# expressions are included in log statements.

Takashi Matsuo

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

[diff] [blame]

1485

"A String",

1486

],

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