Blame - docs/dyn/clouddebugger_v2.controller.debuggees.breakpoints.html - platform/external/python/google-api-python-client

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

[diff] [blame]

76

<h2>Instance Methods</h2>

77

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

78

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

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

81

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

Sai Cheemalapati

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

[diff] [blame]

82

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

Takashi Matsuo

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

[diff] [blame]

83

<h3>Method Details</h3>

84

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

85

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

Bu Sun Kim

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

[diff] [blame]

88

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

Sai Cheemalapati

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

[diff] [blame]

89

fields) is semantically immutable, although the field values may

90

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

91

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

92

doesn't change the breakpoint semantics.

Sai Cheemalapati

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

[diff] [blame]

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:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

101

debuggeeId: string, Required. Identifies the debuggee. (required)

102

agentId: string, Identifies the agent.

103

This is the ID returned in the RegisterDebuggee response.

Bu Sun Kim

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

[diff] [blame]

104

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

105

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

106

timeout has expired.

Sai Cheemalapati

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

[diff] [blame]

107

Bu Sun Kim

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

[diff] [blame]

108

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

109

when the server-selected timeout has expired.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

110

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

111

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

112

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

113

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

Takashi Matsuo

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

[diff] [blame]

114

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

115

Allowed values

116

1 - v1 error format

117

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

118

119

Returns:

120

An object of the form:

121

Jon Wayne Parrott

36e41bc

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

[diff] [blame]

122

{ # Response for listing active breakpoints.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

123

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

Sai Cheemalapati

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

[diff] [blame]

124

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

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

125

{ # ------------------------------------------------------------------------------

126

# ## Breakpoint (the resource)

127

#

128

# Represents the breakpoint specification, status and results.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

129

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

130

# The expressions are composed using expressions in the programming language

131

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

132

# expressions are included in log statements.

133

"A String",

134

],

135

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

136

# The evaluated expressions appear in exactly the same order they

137

# are listed in the `expressions` field.

138

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

139

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

140

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

141

# will indicate an error and contain the error text.

142

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

143

# Note how the following variables are represented:

144

#

145

# 1) A simple variable:

#

# int x = 5

#

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

150

#

151

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

160

# name: "x",

161

# type: "T",

162

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

163

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

164

# }

165

#

166

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

172

# name: "p",

173

# type: "T*",

174

# value: "0x00500500",

175

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

176

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

177

# }

178

#

179

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

#

# T* p = new T;

#

# { // Captured variable

184

# name: "p",

185

# type: "T*",

186

# value: "0x00400400"

187

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

188

# }

189

#

190

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

191

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

192

#

193

# Note that a null pointer should not have members.

194

#

195

# 5) An unnamed value:

196

#

197

# int* p = new int(7);

198

#

199

# { // Captured variable

200

# name: "p",

201

# value: "0x00500500",

202

# type: "int*",

203

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

204

#

205

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

206

#

207

# int* p = new int(7);

208

# int** pp = &p;

209

#

210

# { // Captured variable

211

# name: "pp",

212

# value: "0x00500500",

213

# type: "int**",

214

# members {

215

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

225

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

226

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

227

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

228

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

229

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

230

#

231

# 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

238

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

239

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

240

#

241

# { // Shared variable table entry #3:

242

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

243

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

244

# }

245

#

246

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

247

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

248

# to be shared between pointers and references.

249

#

250

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

251

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

252

# Object with schema name: Variable

253

],

254

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

255

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

256

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

257

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

258

# state.

259

#

260

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

261

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

262

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

263

#

264

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

265

#

266

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

267

#

268

# Examples of error message applied to value:

269

#

270

# * `Malformed string`,

271

# * `Field f not found in class C`

272

# * `Null pointer dereference`

273

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

274

# specific parts of the containing object.

275

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

276

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

277

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

278

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

279

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

280

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

286

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

287

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

288

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

"A String",

],

},

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

293

},

294

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

295

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

296

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

297

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

298

# rather than a static type of an object.

299

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

300

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

301

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

302

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

303

},

304

],

305

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

306

# breakpoint state will not change from here on.

307

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

308

# recently entered function.

309

{ # Represents a stack frame context.

310

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

311

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

312

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

313

# Note how the following variables are represented:

314

#

315

# 1) A simple variable:

#

# int x = 5

#

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

320

#

321

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

330

# name: "x",

331

# type: "T",

332

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

333

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

334

# }

335

#

336

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

342

# name: "p",

343

# type: "T*",

344

# value: "0x00500500",

345

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

346

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

347

# }

348

#

349

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

#

# T* p = new T;

#

# { // Captured variable

354

# name: "p",

355

# type: "T*",

356

# value: "0x00400400"

357

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

358

# }

359

#

360

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

361

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

362

#

363

# Note that a null pointer should not have members.

364

#

365

# 5) An unnamed value:

366

#

367

# int* p = new int(7);

368

#

369

# { // Captured variable

370

# name: "p",

371

# value: "0x00500500",

372

# type: "int*",

373

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

374

#

375

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

376

#

377

# int* p = new int(7);

378

# int** pp = &p;

379

#

380

# { // Captured variable

381

# name: "pp",

382

# value: "0x00500500",

383

# type: "int**",

384

# members {

385

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

395

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

396

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

397

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

398

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

399

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

400

#

401

# 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

408

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

409

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

410

#

411

# { // Shared variable table entry #3:

412

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

413

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

414

# }

415

#

416

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

417

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

418

# to be shared between pointers and references.

419

#

420

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

421

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

422

# Object with schema name: Variable

423

],

424

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

425

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

426

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

427

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

428

# state.

429

#

430

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

431

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

432

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

433

#

434

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

435

#

436

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

437

#

438

# Examples of error message applied to value:

439

#

440

# * `Malformed string`,

441

# * `Field f not found in class C`

442

# * `Null pointer dereference`

443

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

444

# specific parts of the containing object.

445

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

446

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

447

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

448

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

449

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

450

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

456

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

457

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

458

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

"A String",

],

},

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

463

},

464

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

465

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

466

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

467

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

468

# rather than a static type of an object.

469

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

470

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

471

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

472

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

473

},

474

],

475

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

476

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

477

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

478

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

479

# this field.

480

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

481

},

482

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

483

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

484

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

485

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

486

# Note how the following variables are represented:

487

#

488

# 1) A simple variable:

#

# int x = 5

#

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

493

#

494

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

503

# name: "x",

504

# type: "T",

505

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

506

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

507

# }

508

#

509

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

515

# name: "p",

516

# type: "T*",

517

# value: "0x00500500",

518

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

519

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

520

# }

521

#

522

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

#

# T* p = new T;

#

# { // Captured variable

527

# name: "p",

528

# type: "T*",

529

# value: "0x00400400"

530

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

531

# }

532

#

533

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

534

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

535

#

536

# Note that a null pointer should not have members.

537

#

538

# 5) An unnamed value:

539

#

540

# int* p = new int(7);

541

#

542

# { // Captured variable

543

# name: "p",

544

# value: "0x00500500",

545

# type: "int*",

546

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

547

#

548

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

549

#

550

# int* p = new int(7);

551

# int** pp = &p;

552

#

553

# { // Captured variable

554

# name: "pp",

555

# value: "0x00500500",

556

# type: "int**",

557

# members {

558

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

568

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

569

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

570

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

571

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

572

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

573

#

574

# 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

581

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

582

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

583

#

584

# { // Shared variable table entry #3:

585

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

586

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

587

# }

588

#

589

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

590

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

591

# to be shared between pointers and references.

592

#

593

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

594

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

595

# Object with schema name: Variable

596

],

597

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

598

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

599

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

600

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

601

# state.

602

#

603

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

604

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

605

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

606

#

607

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

608

#

609

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

610

#

611

# Examples of error message applied to value:

612

#

613

# * `Malformed string`,

614

# * `Field f not found in class C`

615

# * `Null pointer dereference`

616

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

617

# specific parts of the containing object.

618

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

619

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

620

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

621

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

622

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

623

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

629

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

630

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

631

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

"A String",

],

},

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

636

},

637

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

638

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

639

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

640

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

641

# rather than a static type of an object.

642

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

643

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

644

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

645

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

},

],

},

],

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

651

# The condition is a compound boolean expression composed using expressions

652

# in a programming language at the source location.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

653

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

654

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

655

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

Sai Cheemalapati

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

[diff] [blame]

656

#

657

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

658

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

659

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

660

# display the text message back to the user.

661

#

662

# Error status indicates complete failure of the breakpoint.

663

#

664

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

665

#

666

# Examples (final state):

667

#

668

# * `Invalid line number` referring to location

669

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

670

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

671

# specific parts of the containing object.

672

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

673

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

674

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

675

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

676

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

Sai Cheemalapati

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

[diff] [blame]

677

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

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

682

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

Sai Cheemalapati

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

[diff] [blame]

683

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

684

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

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

685

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

686

"A String",

687

],

Takashi Matsuo

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

[diff] [blame]

688

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

689

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

Takashi Matsuo

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

[diff] [blame]

690

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

691

"state": "A String", # The current state of the breakpoint.

692

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

693

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

694

# breakpoint location is hit.

695

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

696

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

697

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

698

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

699

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

700

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

701

# this field.

702

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

703

},

704

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

705

# resolution.

706

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

Sai Cheemalapati

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

[diff] [blame]

707

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

708

# it from multiple variables, including variables stored in the

709

# `variable_table` itself.

710

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

711

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

712

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

713

#

714

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

715

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

716

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

717

# and the referenced variable.

718

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

719

# Note how the following variables are represented:

720

#

721

# 1) A simple variable:

722

#

723

# int x = 5

724

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

725

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

Sai Cheemalapati

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

[diff] [blame]

726

#

727

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

736

# name: "x",

737

# type: "T",

738

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

739

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

Sai Cheemalapati

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

[diff] [blame]

740

# }

741

#

742

# 3) A pointer where the pointee was captured:

743

#

744

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

745

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

746

#

747

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

748

# name: "p",

749

# type: "T*",

750

# value: "0x00500500",

751

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

752

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

Sai Cheemalapati

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

[diff] [blame]

753

# }

754

#

755

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

#

# T* p = new T;

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

760

# name: "p",

761

# type: "T*",

762

# value: "0x00400400"

763

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

Sai Cheemalapati

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

[diff] [blame]

764

# }

765

#

766

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

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

767

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

Sai Cheemalapati

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

[diff] [blame]

768

#

769

# Note that a null pointer should not have members.

770

#

771

# 5) An unnamed value:

772

#

773

# int* p = new int(7);

774

#

775

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

776

# name: "p",

777

# value: "0x00500500",

778

# type: "int*",

779

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

Sai Cheemalapati

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

[diff] [blame]

780

#

781

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

782

#

783

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

784

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

785

#

786

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

787

# name: "pp",

788

# value: "0x00500500",

789

# type: "int**",

Sai Cheemalapati

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

[diff] [blame]

790

# members {

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

791

# value: "0x00400400",

792

# type: "int*"

Sai Cheemalapati

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

[diff] [blame]

793

# status {

794

# is_error: true,

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

795

# description: { format: "unavailable" } }

Sai Cheemalapati

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

[diff] [blame]

# }

# }

# }

#

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

801

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

802

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

803

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

804

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

805

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

806

#

807

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

808

#

809

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

810

# T* p = &x;

811

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

812

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

813

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

814

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

815

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

Sai Cheemalapati

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

[diff] [blame]

816

#

817

# { // Shared variable table entry #3:

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

818

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

819

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

Sai Cheemalapati

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

[diff] [blame]

820

# }

821

#

822

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

823

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

824

# to be shared between pointers and references.

825

#

826

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

827

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

828

# Object with schema name: Variable

829

],

830

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

Sai Cheemalapati

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

[diff] [blame]

831

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

832

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

833

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

834

# state.

835

#

836

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

837

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

838

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

839

#

840

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

841

#

842

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

843

#

844

# Examples of error message applied to value:

845

#

846

# * `Malformed string`,

847

# * `Field f not found in class C`

848

# * `Null pointer dereference`

849

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

850

# specific parts of the containing object.

851

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

852

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

853

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

854

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

855

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

Sai Cheemalapati

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

[diff] [blame]

856

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

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

861

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

Sai Cheemalapati

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

[diff] [blame]

862

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

863

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

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

864

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

865

"A String",

866

],

Takashi Matsuo

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

[diff] [blame]

867

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

868

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

Takashi Matsuo

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

[diff] [blame]

869

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

870

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

871

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

Sai Cheemalapati

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

[diff] [blame]

872

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

873

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

874

# rather than a static type of an object.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

875

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

876

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

877

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

878

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

Takashi Matsuo

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

[diff] [blame]

879

},

880

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

881

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

882

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

Bu Sun Kim

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

[diff] [blame]

883

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

884

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

885

# of the appropriate expression. Expressions not referenced in

886

# `log_message_format` are not logged.

887

#

888

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

889

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

890

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

Sai Cheemalapati

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

[diff] [blame]

891

# displayed to the user.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

892

"a_key": "A String",

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

893

},

Takashi Matsuo

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

[diff] [blame]

894

},

895

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

896

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

897

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

898

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

899

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

900

# the list of breakpoints changes.

Takashi Matsuo

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

[diff] [blame]

}</pre>

</div>

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

905

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

Sai Cheemalapati

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

[diff] [blame]

906

<pre>Updates the breakpoint state or mutable fields.

Bu Sun Kim

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

[diff] [blame]

907

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

Sai Cheemalapati

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

[diff] [blame]

908

909

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

910

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

Bu Sun Kim

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

[diff] [blame]

911

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

Sai Cheemalapati

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

[diff] [blame]

912

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

913

or snapping the location to the correct line of code.

Takashi Matsuo

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

[diff] [blame]

914

915

Args:

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

916

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

Takashi Matsuo

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

[diff] [blame]

917

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

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

918

body: object, The request body.

Takashi Matsuo

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

[diff] [blame]

919

The object takes the form of:

920

Jon Wayne Parrott

36e41bc

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

[diff] [blame]

921

{ # Request to update an active breakpoint.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

922

"breakpoint": { # ------------------------------------------------------------------------------ # Required. Updated breakpoint information.

Bu Sun Kim

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

[diff] [blame]

923

# The field `id` must be set.

924

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

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

925

# ## Breakpoint (the resource)

926

#

927

# Represents the breakpoint specification, status and results.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

928

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

929

# The expressions are composed using expressions in the programming language

930

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

931

# expressions are included in log statements.

932

"A String",

933

],

934

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

935

# The evaluated expressions appear in exactly the same order they

936

# are listed in the `expressions` field.

937

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

938

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

939

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

940

# will indicate an error and contain the error text.

941

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

942

# Note how the following variables are represented:

943

#

944

# 1) A simple variable:

#

# int x = 5

#

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

949

#

950

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

959

# name: "x",

960

# type: "T",

961

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

962

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

963

# }

964

#

965

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

971

# name: "p",

972

# type: "T*",

973

# value: "0x00500500",

974

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

975

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

976

# }

977

#

978

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

#

# T* p = new T;

#

# { // Captured variable

983

# name: "p",

984

# type: "T*",

985

# value: "0x00400400"

986

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

987

# }

988

#

989

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

990

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

991

#

992

# Note that a null pointer should not have members.

993

#

994

# 5) An unnamed value:

995

#

996

# int* p = new int(7);

997

#

998

# { // Captured variable

999

# name: "p",

1000

# value: "0x00500500",

1001

# type: "int*",

1002

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

1003

#

1004

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

1005

#

1006

# int* p = new int(7);

1007

# int** pp = &p;

1008

#

1009

# { // Captured variable

1010

# name: "pp",

1011

# value: "0x00500500",

1012

# type: "int**",

1013

# members {

1014

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1024

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

1025

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

1026

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

1027

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

1028

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

1029

#

1030

# 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

1037

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

1038

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

1039

#

1040

# { // Shared variable table entry #3:

1041

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

1042

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

1043

# }

1044

#

1045

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

1046

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

1047

# to be shared between pointers and references.

1048

#

1049

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

1050

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

1051

# Object with schema name: Variable

1052

],

1053

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

1054

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

1055

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

1056

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

1057

# state.

1058

#

1059

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

1060

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

1061

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

1062

#

1063

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

1064

#

1065

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

1066

#

1067

# Examples of error message applied to value:

1068

#

1069

# * `Malformed string`,

1070

# * `Field f not found in class C`

1071

# * `Null pointer dereference`

1072

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

1073

# specific parts of the containing object.

1074

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

1075

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

1076

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

1077

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

1078

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

1079

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

1085

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

1086

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

1087

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

"A String",

],

},

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

1092

},

1093

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

1094

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

1095

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

1096

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

1097

# rather than a static type of an object.

1098

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

1099

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

1100

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

1101

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

1102

},

1103

],

1104

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

1105

# breakpoint state will not change from here on.

1106

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

1107

# recently entered function.

1108

{ # Represents a stack frame context.

1109

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

1110

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

1111

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

1112

# Note how the following variables are represented:

1113

#

1114

# 1) A simple variable:

#

# int x = 5

#

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

1119

#

1120

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1129

# name: "x",

1130

# type: "T",

1131

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

1132

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

1133

# }

1134

#

1135

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1141

# name: "p",

1142

# type: "T*",

1143

# value: "0x00500500",

1144

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

1145

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

1146

# }

1147

#

1148

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

#

# T* p = new T;

#

# { // Captured variable

1153

# name: "p",

1154

# type: "T*",

1155

# value: "0x00400400"

1156

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

1157

# }

1158

#

1159

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

1160

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

1161

#

1162

# Note that a null pointer should not have members.

1163

#

1164

# 5) An unnamed value:

1165

#

1166

# int* p = new int(7);

1167

#

1168

# { // Captured variable

1169

# name: "p",

1170

# value: "0x00500500",

1171

# type: "int*",

1172

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

1173

#

1174

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

1175

#

1176

# int* p = new int(7);

1177

# int** pp = &p;

1178

#

1179

# { // Captured variable

1180

# name: "pp",

1181

# value: "0x00500500",

1182

# type: "int**",

1183

# members {

1184

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1194

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

1195

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

1196

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

1197

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

1198

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

1199

#

1200

# 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

1207

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

1208

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

1209

#

1210

# { // Shared variable table entry #3:

1211

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

1212

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

1213

# }

1214

#

1215

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

1216

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

1217

# to be shared between pointers and references.

1218

#

1219

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

1220

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

1221

# Object with schema name: Variable

1222

],

1223

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

1224

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

1225

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

1226

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

1227

# state.

1228

#

1229

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

1230

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

1231

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

1232

#

1233

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

1234

#

1235

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

1236

#

1237

# Examples of error message applied to value:

1238

#

1239

# * `Malformed string`,

1240

# * `Field f not found in class C`

1241

# * `Null pointer dereference`

1242

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

1243

# specific parts of the containing object.

1244

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

1245

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

1246

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

1247

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

1248

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

1249

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

1255

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

1256

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

1257

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

"A String",

],

},

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

1262

},

1263

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

1264

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

1265

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

1266

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

1267

# rather than a static type of an object.

1268

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

1269

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

1270

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

1271

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

1272

},

1273

],

1274

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

1275

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

1276

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

1277

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

1278

# this field.

1279

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

1280

},

1281

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

1282

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

1283

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

1284

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

1285

# Note how the following variables are represented:

1286

#

1287

# 1) A simple variable:

#

# int x = 5

#

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

1292

#

1293

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1302

# name: "x",

1303

# type: "T",

1304

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

1305

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

1306

# }

1307

#

1308

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1314

# name: "p",

1315

# type: "T*",

1316

# value: "0x00500500",

1317

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

1318

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

1319

# }

1320

#

1321

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

#

# T* p = new T;

#

# { // Captured variable

1326

# name: "p",

1327

# type: "T*",

1328

# value: "0x00400400"

1329

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

1330

# }

1331

#

1332

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

1333

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

1334

#

1335

# Note that a null pointer should not have members.

1336

#

1337

# 5) An unnamed value:

1338

#

1339

# int* p = new int(7);

1340

#

1341

# { // Captured variable

1342

# name: "p",

1343

# value: "0x00500500",

1344

# type: "int*",

1345

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

1346

#

1347

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

1348

#

1349

# int* p = new int(7);

1350

# int** pp = &p;

1351

#

1352

# { // Captured variable

1353

# name: "pp",

1354

# value: "0x00500500",

1355

# type: "int**",

1356

# members {

1357

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1367

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

1368

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

1369

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

1370

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

1371

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

1372

#

1373

# 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

1380

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

1381

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

1382

#

1383

# { // Shared variable table entry #3:

1384

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

1385

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

1386

# }

1387

#

1388

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

1389

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

1390

# to be shared between pointers and references.

1391

#

1392

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

1393

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

1394

# Object with schema name: Variable

1395

],

1396

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

1397

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

1398

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

1399

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

1400

# state.

1401

#

1402

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

1403

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

1404

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

1405

#

1406

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

1407

#

1408

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

1409

#

1410

# Examples of error message applied to value:

1411

#

1412

# * `Malformed string`,

1413

# * `Field f not found in class C`

1414

# * `Null pointer dereference`

1415

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

1416

# specific parts of the containing object.

1417

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

1418

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

1419

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

1420

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

1421

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

1422

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

1428

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

1429

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

1430

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

"A String",

],

},

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

1435

},

1436

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

1437

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

1438

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

1439

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

1440

# rather than a static type of an object.

1441

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

1442

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

1443

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

1444

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

},

],

},

],

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

1450

# The condition is a compound boolean expression composed using expressions

1451

# in a programming language at the source location.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1452

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

1453

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

1454

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

Sai Cheemalapati

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

[diff] [blame]

1455

#

1456

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

1457

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

1458

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

1459

# display the text message back to the user.

1460

#

1461

# Error status indicates complete failure of the breakpoint.

1462

#

1463

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

1464

#

1465

# Examples (final state):

1466

#

1467

# * `Invalid line number` referring to location

1468

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

1469

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

1470

# specific parts of the containing object.

1471

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

1472

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1473

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

1474

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1475

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

Sai Cheemalapati

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

[diff] [blame]

1476

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

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1481

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

Sai Cheemalapati

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

[diff] [blame]

1482

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

1483

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

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

1484

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

1485

"A String",

1486

],

Takashi Matsuo

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

[diff] [blame]

1487

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1488

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

Takashi Matsuo

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

[diff] [blame]

1489

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1490

"state": "A String", # The current state of the breakpoint.

1491

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

1492

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

1493

# breakpoint location is hit.

1494

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

1495

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

1496

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

1497

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

1498

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

1499

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

1500

# this field.

1501

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

1502

},

1503

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

1504

# resolution.

1505

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

Sai Cheemalapati

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

[diff] [blame]

1506

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

1507

# it from multiple variables, including variables stored in the

1508

# `variable_table` itself.

1509

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

1510

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

1511

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

1512

#

1513

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

1514

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

1515

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

1516

# and the referenced variable.

1517

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

1518

# Note how the following variables are represented:

1519

#

1520

# 1) A simple variable:

1521

#

1522

# int x = 5

1523

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1524

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

Sai Cheemalapati

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

[diff] [blame]

1525

#

1526

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1535

# name: "x",

1536

# type: "T",

1537

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

1538

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

Sai Cheemalapati

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

[diff] [blame]

1539

# }

1540

#

1541

# 3) A pointer where the pointee was captured:

1542

#

1543

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1544

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1545

#

1546

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1547

# name: "p",

1548

# type: "T*",

1549

# value: "0x00500500",

1550

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

1551

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

Sai Cheemalapati

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

[diff] [blame]

1552

# }

1553

#

1554

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

#

# T* p = new T;

#

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1559

# name: "p",

1560

# type: "T*",

1561

# value: "0x00400400"

1562

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

Sai Cheemalapati

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

[diff] [blame]

1563

# }

1564

#

1565

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

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1566

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

Sai Cheemalapati

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

[diff] [blame]

1567

#

1568

# Note that a null pointer should not have members.

1569

#

1570

# 5) An unnamed value:

1571

#

1572

# int* p = new int(7);

1573

#

1574

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1575

# name: "p",

1576

# value: "0x00500500",

1577

# type: "int*",

1578

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

Sai Cheemalapati

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

[diff] [blame]

1579

#

1580

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

1581

#

1582

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1583

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1584

#

1585

# { // Captured variable

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1586

# name: "pp",

1587

# value: "0x00500500",

1588

# type: "int**",

Sai Cheemalapati

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

[diff] [blame]

1589

# members {

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1590

# value: "0x00400400",

1591

# type: "int*"

Sai Cheemalapati

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

[diff] [blame]

1592

# status {

1593

# is_error: true,

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1594

# description: { format: "unavailable" } }

Sai Cheemalapati

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

[diff] [blame]

# }

# }

# }

#

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

1600

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

1601

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

1602

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

1603

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

1604

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

1605

#

1606

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

1607

#

1608

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1609

# T* p = &x;

1610

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1611

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1612

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

1613

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

1614

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

Sai Cheemalapati

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

[diff] [blame]

1615

#

1616

# { // Shared variable table entry #3:

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1617

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

1618

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

Sai Cheemalapati

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

[diff] [blame]

1619

# }

1620

#

1621

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

1622

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

1623

# to be shared between pointers and references.

1624

#

1625

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1626

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

1627

# Object with schema name: Variable

1628

],

1629

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

Sai Cheemalapati

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

[diff] [blame]

1630

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

1631

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

1632

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

1633

# state.

1634

#

1635

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

1636

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

1637

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

1638

#

1639

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

1640

#

1641

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

1642

#

1643

# Examples of error message applied to value:

1644

#

1645

# * `Malformed string`,

1646

# * `Field f not found in class C`

1647

# * `Null pointer dereference`

1648

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

1649

# specific parts of the containing object.

1650

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

1651

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1652

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

1653

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1654

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

Sai Cheemalapati

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

[diff] [blame]

1655

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

# character.

#

# Examples:

#

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1660

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

Sai Cheemalapati

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

[diff] [blame]

1661

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

1662

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

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

1663

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

1664

"A String",

1665

],

Takashi Matsuo

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

[diff] [blame]

1666

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1667

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

Takashi Matsuo

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

[diff] [blame]

1668

},

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1669

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

1670

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

Sai Cheemalapati

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

[diff] [blame]

1671

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

1672

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

1673

# rather than a static type of an object.

Bu Sun Kim

2020-05-27 12:20:54 -0700

[diff] [blame]

1674

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1675

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

1676

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

1677

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

Takashi Matsuo

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

[diff] [blame]

1678

},

1679

],

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1680

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

1681

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

Bu Sun Kim

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

[diff] [blame]

1682

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

1683

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

1684

# of the appropriate expression. Expressions not referenced in

1685

# `log_message_format` are not logged.

1686

#

1687

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

1688

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

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1689

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

Sai Cheemalapati

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

[diff] [blame]

1690

# displayed to the user.

Bu Sun Kim

2020-05-20 12:08:20 -0700

[diff] [blame]

1691

"a_key": "A String",

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

1692

},

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]

1697

Allowed values

1698

1 - v1 error format

1699

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

1700

1701

Returns:

1702

An object of the form:

1703

Sai Cheemalapati

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

[diff] [blame]

1704

{ # Response for updating an active breakpoint.

1705

# The message is defined to allow future extensions.

Takashi Matsuo