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-07-22 17:02:09 -0700

[diff] [blame]

78

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

Sai Cheemalapati

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

[diff] [blame]

79

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

Takashi Matsuo

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

[diff] [blame]

80

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-07-22 17:02:09 -0700

[diff] [blame]

85

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

Sai Cheemalapati

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

[diff] [blame]

86

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

87

Bu Sun Kim

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

[diff] [blame]

88

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

Sai Cheemalapati

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

[diff] [blame]

89

fields) is semantically immutable, although the field values may

90

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

91

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

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

2020-07-22 17:02:09 -0700

[diff] [blame]

104

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

105

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

106

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

107

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

Bu Sun Kim

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

[diff] [blame]

108

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

109

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

110

timeout has expired.

Sai Cheemalapati

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

[diff] [blame]

111

Bu Sun Kim

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

[diff] [blame]

112

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

113

when the server-selected timeout has expired.

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-07-22 17:02:09 -0700

[diff] [blame]

123

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

124

# the list of breakpoints changes.

Bu Sun Kim

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

[diff] [blame]

125

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

Sai Cheemalapati

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

[diff] [blame]

126

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

127

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

128

# ## Breakpoint (the resource)

129

#

130

# Represents the breakpoint specification, status and results.

Bu Sun Kim

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

[diff] [blame]

131

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

132

# The evaluated expressions appear in exactly the same order they

133

# are listed in the `expressions` field.

134

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

135

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

136

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

137

# will indicate an error and contain the error text.

138

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

139

# Note how the following variables are represented:

140

#

141

# 1) A simple variable:

#

# int x = 5

#

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

146

#

147

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

156

# name: "x",

157

# type: "T",

158

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

159

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

160

# }

161

#

162

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

168

# name: "p",

169

# type: "T*",

170

# value: "0x00500500",

171

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

172

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

173

# }

174

#

175

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

#

# T* p = new T;

#

# { // Captured variable

180

# name: "p",

181

# type: "T*",

182

# value: "0x00400400"

183

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

184

# }

185

#

186

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

187

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

188

#

189

# Note that a null pointer should not have members.

190

#

191

# 5) An unnamed value:

192

#

193

# int* p = new int(7);

194

#

195

# { // Captured variable

196

# name: "p",

197

# value: "0x00500500",

198

# type: "int*",

199

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

200

#

201

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

202

#

203

# int* p = new int(7);

204

# int** pp = &p;

205

#

206

# { // Captured variable

207

# name: "pp",

208

# value: "0x00500500",

209

# type: "int**",

210

# members {

211

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

221

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

222

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

223

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

224

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

225

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

226

#

227

# 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

234

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

235

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

236

#

237

# { // Shared variable table entry #3:

238

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

239

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

240

# }

241

#

242

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

243

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

244

# to be shared between pointers and references.

245

#

246

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

Bu Sun Kim

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

[diff] [blame]

247

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

248

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

249

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

250

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

251

# state.

252

#

253

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

254

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

255

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

256

#

257

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

258

#

259

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

260

#

261

# Examples of error message applied to value:

262

#

263

# * `Malformed string`,

264

# * `Field f not found in class C`

265

# * `Null pointer dereference`

266

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

267

# specific parts of the containing object.

268

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

269

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

270

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

271

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

272

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

273

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

279

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

280

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

281

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

"A String",

],

},

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

286

},

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

287

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

288

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

289

# Object with schema name: Variable

290

],

Bu Sun Kim

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

[diff] [blame]

291

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

292

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

293

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

294

# rather than a static type of an object.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

295

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

Bu Sun Kim

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

[diff] [blame]

296

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

297

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

298

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

299

},

300

],

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

301

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

302

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

303

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

304

#

305

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

306

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

307

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

308

# display the text message back to the user.

309

#

310

# Error status indicates complete failure of the breakpoint.

311

#

312

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

313

#

314

# Examples (final state):

315

#

316

# * `Invalid line number` referring to location

317

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

318

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

319

# specific parts of the containing object.

320

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

321

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

322

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

323

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

324

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

325

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

331

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

332

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

333

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

"A String",

],

},

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

338

},

339

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

340

# The expressions are composed using expressions in the programming language

341

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

342

# expressions are included in log statements.

343

"A String",

344

],

345

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

346

# displayed to the user.

347

"a_key": "A String",

348

},

349

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

350

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

351

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

352

# of the appropriate expression. Expressions not referenced in

353

# `log_message_format` are not logged.

354

#

355

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

356

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

357

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

358

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

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`.

361

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

362

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

363

# this field.

364

},

Bu Sun Kim

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

[diff] [blame]

365

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

366

# breakpoint state will not change from here on.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

367

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

368

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

369

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

370

# breakpoint location is hit.

371

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

372

# resolution.

373

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

Bu Sun Kim

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

[diff] [blame]

374

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

375

# recently entered function.

376

{ # Represents a stack frame context.

Bu Sun Kim

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

[diff] [blame]

377

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

378

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

379

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

380

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

381

# Note how the following variables are represented:

382

#

383

# 1) A simple variable:

#

# int x = 5

#

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

388

#

389

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

398

# name: "x",

399

# type: "T",

400

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

401

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

402

# }

403

#

404

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

410

# name: "p",

411

# type: "T*",

412

# value: "0x00500500",

413

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

414

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

415

# }

416

#

417

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

#

# T* p = new T;

#

# { // Captured variable

422

# name: "p",

423

# type: "T*",

424

# value: "0x00400400"

425

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

426

# }

427

#

428

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

429

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

430

#

431

# Note that a null pointer should not have members.

432

#

433

# 5) An unnamed value:

434

#

435

# int* p = new int(7);

436

#

437

# { // Captured variable

438

# name: "p",

439

# value: "0x00500500",

440

# type: "int*",

441

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

442

#

443

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

444

#

445

# int* p = new int(7);

446

# int** pp = &p;

447

#

448

# { // Captured variable

449

# name: "pp",

450

# value: "0x00500500",

451

# type: "int**",

452

# members {

453

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

463

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

464

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

465

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

466

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

467

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

468

#

469

# 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

476

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

477

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

478

#

479

# { // Shared variable table entry #3:

480

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

481

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

482

# }

483

#

484

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

485

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

486

# to be shared between pointers and references.

487

#

488

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

Bu Sun Kim

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

[diff] [blame]

489

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

490

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

491

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

492

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

493

# state.

494

#

495

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

496

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

497

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

498

#

499

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

500

#

501

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

502

#

503

# Examples of error message applied to value:

504

#

505

# * `Malformed string`,

506

# * `Field f not found in class C`

507

# * `Null pointer dereference`

508

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

509

# specific parts of the containing object.

510

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

511

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

512

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

513

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

514

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

515

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

521

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

522

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

523

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

"A String",

],

},

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

528

},

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

529

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

530

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

531

# Object with schema name: Variable

532

],

Bu Sun Kim

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

[diff] [blame]

533

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

534

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

535

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

536

# rather than a static type of an object.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

537

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

Bu Sun Kim

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

[diff] [blame]

538

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

539

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

540

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

541

},

542

],

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

543

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

544

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

545

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

546

# Note how the following variables are represented:

547

#

548

# 1) A simple variable:

#

# int x = 5

#

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

553

#

554

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

563

# name: "x",

564

# type: "T",

565

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

566

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

567

# }

568

#

569

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

575

# name: "p",

576

# type: "T*",

577

# value: "0x00500500",

578

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

579

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

580

# }

581

#

582

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

#

# T* p = new T;

#

# { // Captured variable

587

# name: "p",

588

# type: "T*",

589

# value: "0x00400400"

590

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

591

# }

592

#

593

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

594

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

595

#

596

# Note that a null pointer should not have members.

597

#

598

# 5) An unnamed value:

599

#

600

# int* p = new int(7);

601

#

602

# { // Captured variable

603

# name: "p",

604

# value: "0x00500500",

605

# type: "int*",

606

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

607

#

608

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

609

#

610

# int* p = new int(7);

611

# int** pp = &p;

612

#

613

# { // Captured variable

614

# name: "pp",

615

# value: "0x00500500",

616

# type: "int**",

617

# members {

618

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

628

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

629

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

630

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

631

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

632

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

633

#

634

# 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

641

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

642

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

643

#

644

# { // Shared variable table entry #3:

645

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

646

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

647

# }

648

#

649

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

650

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

651

# to be shared between pointers and references.

652

#

653

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

654

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

655

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

656

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

657

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

658

# state.

659

#

660

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

661

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

662

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

663

#

664

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

665

#

666

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

667

#

668

# Examples of error message applied to value:

669

#

670

# * `Malformed string`,

671

# * `Field f not found in class C`

672

# * `Null pointer dereference`

673

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

674

# specific parts of the containing object.

675

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

676

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

677

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

678

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

679

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

680

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

686

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

687

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

688

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

"A String",

],

},

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

693

},

694

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

695

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

696

# Object with schema name: Variable

697

],

698

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

699

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

700

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

701

# rather than a static type of an object.

702

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

703

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

704

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

705

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

706

},

707

],

708

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

709

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

710

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

711

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

712

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

713

# this field.

714

},

Bu Sun Kim

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

[diff] [blame]

715

},

716

],

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

717

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

Bu Sun Kim

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

[diff] [blame]

718

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

719

# The condition is a compound boolean expression composed using expressions

720

# in a programming language at the source location.

Bu Sun Kim

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

[diff] [blame]

721

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

Sai Cheemalapati

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

[diff] [blame]

722

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

723

# it from multiple variables, including variables stored in the

724

# `variable_table` itself.

725

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

726

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

727

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

728

#

729

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

730

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

731

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

732

# and the referenced variable.

733

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

734

# Note how the following variables are represented:

735

#

736

# 1) A simple variable:

737

#

738

# int x = 5

739

#

Bu Sun Kim

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

[diff] [blame]

740

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

Sai Cheemalapati

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

[diff] [blame]

741

#

742

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

751

# name: "x",

752

# type: "T",

753

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

754

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

Sai Cheemalapati

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

[diff] [blame]

755

# }

756

#

757

# 3) A pointer where the pointee was captured:

758

#

759

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

760

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

761

#

762

# { // Captured variable

Bu Sun Kim

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

[diff] [blame]

763

# name: "p",

764

# type: "T*",

765

# value: "0x00500500",

766

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

767

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

Sai Cheemalapati

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

[diff] [blame]

768

# }

769

#

770

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

775

# name: "p",

776

# type: "T*",

777

# value: "0x00400400"

778

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

Sai Cheemalapati

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

[diff] [blame]

779

# }

780

#

781

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

Dan O'Meara

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

[diff] [blame]

782

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

Sai Cheemalapati

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

[diff] [blame]

783

#

784

# Note that a null pointer should not have members.

785

#

786

# 5) An unnamed value:

787

#

788

# int* p = new int(7);

789

#

790

# { // Captured variable

Bu Sun Kim

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

[diff] [blame]

791

# name: "p",

792

# value: "0x00500500",

793

# type: "int*",

794

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

Sai Cheemalapati

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

[diff] [blame]

795

#

796

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

797

#

798

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

799

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

800

#

801

# { // Captured variable

Bu Sun Kim

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

[diff] [blame]

802

# name: "pp",

803

# value: "0x00500500",

804

# type: "int**",

Sai Cheemalapati

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

[diff] [blame]

805

# members {

Bu Sun Kim

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

[diff] [blame]

806

# value: "0x00400400",

807

# type: "int*"

Sai Cheemalapati

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

[diff] [blame]

808

# status {

809

# is_error: true,

Bu Sun Kim

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

[diff] [blame]

810

# description: { format: "unavailable" } }

Sai Cheemalapati

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

[diff] [blame]

# }

# }

# }

#

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

816

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

817

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

818

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

819

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

820

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

821

#

822

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

823

#

824

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

825

# T* p = &x;

826

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

827

#

Bu Sun Kim

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

[diff] [blame]

828

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

829

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

830

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

Sai Cheemalapati

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

[diff] [blame]

831

#

832

# { // Shared variable table entry #3:

Bu Sun Kim

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

[diff] [blame]

833

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

834

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

Sai Cheemalapati

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

[diff] [blame]

835

# }

836

#

837

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

838

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

839

# to be shared between pointers and references.

840

#

841

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

842

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

843

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

844

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

845

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

846

# state.

847

#

848

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

849

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

850

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

851

#

852

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

853

#

854

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

855

#

856

# Examples of error message applied to value:

857

#

858

# * `Malformed string`,

859

# * `Field f not found in class C`

860

# * `Null pointer dereference`

861

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

862

# specific parts of the containing object.

863

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

864

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

Bu Sun Kim

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

[diff] [blame]

865

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

866

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

Bu Sun Kim

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

[diff] [blame]

867

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

Sai Cheemalapati

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

[diff] [blame]

868

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

873

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

Sai Cheemalapati

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

[diff] [blame]

874

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

875

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

Bu Sun Kim

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

[diff] [blame]

876

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

877

"A String",

878

],

Takashi Matsuo

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

[diff] [blame]

879

},

Bu Sun Kim

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

[diff] [blame]

880

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

Takashi Matsuo

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

[diff] [blame]

881

},

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

882

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

883

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

884

# Object with schema name: Variable

885

],

Bu Sun Kim

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

[diff] [blame]

886

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

887

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

888

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

889

# rather than a static type of an object.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

890

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

Bu Sun Kim

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

[diff] [blame]

891

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

892

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

893

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

Takashi Matsuo

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

[diff] [blame]

894

},

895

],

Takashi Matsuo

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

[diff] [blame]

896

},

897

],

Bu Sun Kim

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

[diff] [blame]

898

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

899

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

900

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

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

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

929

# The evaluated expressions appear in exactly the same order they

930

# are listed in the `expressions` field.

931

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

932

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

933

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

934

# will indicate an error and contain the error text.

935

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

936

# Note how the following variables are represented:

937

#

938

# 1) A simple variable:

#

# int x = 5

#

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

943

#

944

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

953

# name: "x",

954

# type: "T",

955

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

956

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

957

# }

958

#

959

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

965

# name: "p",

966

# type: "T*",

967

# value: "0x00500500",

968

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

969

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

970

# }

971

#

972

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

#

# T* p = new T;

#

# { // Captured variable

977

# name: "p",

978

# type: "T*",

979

# value: "0x00400400"

980

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

981

# }

982

#

983

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

984

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

985

#

986

# Note that a null pointer should not have members.

987

#

988

# 5) An unnamed value:

989

#

990

# int* p = new int(7);

991

#

992

# { // Captured variable

993

# name: "p",

994

# value: "0x00500500",

995

# type: "int*",

996

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

997

#

998

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

999

#

1000

# int* p = new int(7);

1001

# int** pp = &p;

1002

#

1003

# { // Captured variable

1004

# name: "pp",

1005

# value: "0x00500500",

1006

# type: "int**",

1007

# members {

1008

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1018

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

1019

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

1020

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

1021

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

1022

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

1023

#

1024

# 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

1031

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

1032

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

1033

#

1034

# { // Shared variable table entry #3:

1035

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

1036

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

1037

# }

1038

#

1039

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

1040

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

1041

# to be shared between pointers and references.

1042

#

1043

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

Bu Sun Kim

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

[diff] [blame]

1044

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

1045

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

1046

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

1047

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

1048

# state.

1049

#

1050

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

1051

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

1052

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

1053

#

1054

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

1055

#

1056

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

1057

#

1058

# Examples of error message applied to value:

1059

#

1060

# * `Malformed string`,

1061

# * `Field f not found in class C`

1062

# * `Null pointer dereference`

1063

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

1064

# specific parts of the containing object.

1065

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

1066

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

1067

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

1068

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

1069

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

1070

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

1076

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

1077

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

1078

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

"A String",

],

},

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

1083

},

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1084

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

1085

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

1086

# Object with schema name: Variable

1087

],

Bu Sun Kim

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

[diff] [blame]

1088

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

1089

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

1090

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

1091

# rather than a static type of an object.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1092

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

Bu Sun Kim

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

[diff] [blame]

1093

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

1094

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

1095

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

1096

},

1097

],

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1098

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

1099

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

1100

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

1101

#

1102

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

1103

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

1104

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

1105

# display the text message back to the user.

1106

#

1107

# Error status indicates complete failure of the breakpoint.

1108

#

1109

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

1110

#

1111

# Examples (final state):

1112

#

1113

# * `Invalid line number` referring to location

1114

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

1115

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

1116

# specific parts of the containing object.

1117

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

1118

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

1119

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

1120

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

1121

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

1122

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

1128

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

1129

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

1130

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

"A String",

],

},

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

1135

},

1136

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

1137

# The expressions are composed using expressions in the programming language

1138

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

1139

# expressions are included in log statements.

1140

"A String",

1141

],

1142

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

1143

# displayed to the user.

1144

"a_key": "A String",

1145

},

1146

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

1147

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

1148

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

1149

# of the appropriate expression. Expressions not referenced in

1150

# `log_message_format` are not logged.

1151

#

1152

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

1153

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

1154

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

1155

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

1156

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

1157

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

1158

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

1159

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

1160

# this field.

1161

},

Bu Sun Kim

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

[diff] [blame]

1162

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

1163

# breakpoint state will not change from here on.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1164

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

1165

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

1166

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

1167

# breakpoint location is hit.

1168

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

1169

# resolution.

1170

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

Bu Sun Kim

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

[diff] [blame]

1171

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

1172

# recently entered function.

1173

{ # Represents a stack frame context.

Bu Sun Kim

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

[diff] [blame]

1174

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

1175

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

1176

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

1177

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

1178

# Note how the following variables are represented:

1179

#

1180

# 1) A simple variable:

#

# int x = 5

#

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

1185

#

1186

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1195

# name: "x",

1196

# type: "T",

1197

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

1198

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

1199

# }

1200

#

1201

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1207

# name: "p",

1208

# type: "T*",

1209

# value: "0x00500500",

1210

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

1211

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

1212

# }

1213

#

1214

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

#

# T* p = new T;

#

# { // Captured variable

1219

# name: "p",

1220

# type: "T*",

1221

# value: "0x00400400"

1222

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

1223

# }

1224

#

1225

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

1226

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

1227

#

1228

# Note that a null pointer should not have members.

1229

#

1230

# 5) An unnamed value:

1231

#

1232

# int* p = new int(7);

1233

#

1234

# { // Captured variable

1235

# name: "p",

1236

# value: "0x00500500",

1237

# type: "int*",

1238

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

1239

#

1240

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

1241

#

1242

# int* p = new int(7);

1243

# int** pp = &p;

1244

#

1245

# { // Captured variable

1246

# name: "pp",

1247

# value: "0x00500500",

1248

# type: "int**",

1249

# members {

1250

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1260

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

1261

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

1262

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

1263

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

1264

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

1265

#

1266

# 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

1273

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

1274

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

1275

#

1276

# { // Shared variable table entry #3:

1277

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

1278

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

1279

# }

1280

#

1281

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

1282

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

1283

# to be shared between pointers and references.

1284

#

1285

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

Bu Sun Kim

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

[diff] [blame]

1286

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

1287

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

1288

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

1289

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

1290

# state.

1291

#

1292

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

1293

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

1294

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

1295

#

1296

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

1297

#

1298

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

1299

#

1300

# Examples of error message applied to value:

1301

#

1302

# * `Malformed string`,

1303

# * `Field f not found in class C`

1304

# * `Null pointer dereference`

1305

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

1306

# specific parts of the containing object.

1307

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

1308

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

1309

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

1310

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

1311

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

1312

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

1318

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

1319

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

1320

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

"A String",

],

},

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

1325

},

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1326

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

1327

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

1328

# Object with schema name: Variable

1329

],

Bu Sun Kim

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

[diff] [blame]

1330

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

1331

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

1332

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

1333

# rather than a static type of an object.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1334

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

Bu Sun Kim

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

[diff] [blame]

1335

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

1336

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

1337

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

1338

},

1339

],

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1340

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

1341

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

1342

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

1343

# Note how the following variables are represented:

1344

#

1345

# 1) A simple variable:

#

# int x = 5

#

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

1350

#

1351

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1360

# name: "x",

1361

# type: "T",

1362

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

1363

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

1364

# }

1365

#

1366

# 3) A pointer where the pointee was captured:

#

# T x = { 3, 7 };

# T* p = &x;

#

# { // Captured variable

1372

# name: "p",

1373

# type: "T*",

1374

# value: "0x00500500",

1375

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

1376

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

1377

# }

1378

#

1379

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

#

# T* p = new T;

#

# { // Captured variable

1384

# name: "p",

1385

# type: "T*",

1386

# value: "0x00400400"

1387

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

1388

# }

1389

#

1390

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

1391

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

1392

#

1393

# Note that a null pointer should not have members.

1394

#

1395

# 5) An unnamed value:

1396

#

1397

# int* p = new int(7);

1398

#

1399

# { // Captured variable

1400

# name: "p",

1401

# value: "0x00500500",

1402

# type: "int*",

1403

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

1404

#

1405

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

1406

#

1407

# int* p = new int(7);

1408

# int** pp = &p;

1409

#

1410

# { // Captured variable

1411

# name: "pp",

1412

# value: "0x00500500",

1413

# type: "int**",

1414

# members {

1415

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1425

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

1426

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

1427

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

1428

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

1429

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

1430

#

1431

# 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

1438

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

1439

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

1440

#

1441

# { // Shared variable table entry #3:

1442

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

1443

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

1444

# }

1445

#

1446

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

1447

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

1448

# to be shared between pointers and references.

1449

#

1450

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

1451

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

1452

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

1453

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

1454

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

1455

# state.

1456

#

1457

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

1458

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

1459

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

1460

#

1461

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

1462

#

1463

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

1464

#

1465

# Examples of error message applied to value:

1466

#

1467

# * `Malformed string`,

1468

# * `Field f not found in class C`

1469

# * `Null pointer dereference`

1470

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

1471

# specific parts of the containing object.

1472

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

1473

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

1474

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

1475

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

1476

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

1477

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

1483

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

1484

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

1485

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

"A String",

],

},

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

1490

},

1491

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

1492

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

1493

# Object with schema name: Variable

1494

],

1495

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

1496

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

1497

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

1498

# rather than a static type of an object.

1499

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

1500

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

1501

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

1502

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

1503

},

1504

],

1505

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

1506

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

1507

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

1508

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

1509

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

1510

# this field.

1511

},

Bu Sun Kim

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

[diff] [blame]

1512

},

1513

],

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1514

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

Bu Sun Kim

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

[diff] [blame]

1515

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

1516

# The condition is a compound boolean expression composed using expressions

1517

# in a programming language at the source location.

Bu Sun Kim

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

[diff] [blame]

1518

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

Sai Cheemalapati

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

[diff] [blame]

1519

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

1520

# it from multiple variables, including variables stored in the

1521

# `variable_table` itself.

1522

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

1523

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

1524

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

1525

#

1526

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

1527

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

1528

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

1529

# and the referenced variable.

1530

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

1531

# Note how the following variables are represented:

1532

#

1533

# 1) A simple variable:

1534

#

1535

# int x = 5

1536

#

Bu Sun Kim

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

[diff] [blame]

1537

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

Sai Cheemalapati

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

[diff] [blame]

1538

#

1539

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

1548

# name: "x",

1549

# type: "T",

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

# 3) A pointer where the pointee was captured:

1555

#

1556

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1557

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1558

#

1559

# { // Captured variable

Bu Sun Kim

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

[diff] [blame]

1560

# name: "p",

1561

# type: "T*",

1562

# value: "0x00500500",

1563

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

1564

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

Sai Cheemalapati

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

[diff] [blame]

1565

# }

1566

#

1567

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

1572

# name: "p",

1573

# type: "T*",

1574

# value: "0x00400400"

1575

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

Sai Cheemalapati

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

[diff] [blame]

1576

# }

1577

#

1578

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

Dan O'Meara

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

[diff] [blame]

1579

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

Sai Cheemalapati

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

[diff] [blame]

1580

#

1581

# Note that a null pointer should not have members.

1582

#

1583

# 5) An unnamed value:

1584

#

1585

# int* p = new int(7);

1586

#

1587

# { // Captured variable

Bu Sun Kim

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

[diff] [blame]

1588

# name: "p",

1589

# value: "0x00500500",

1590

# type: "int*",

1591

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

Sai Cheemalapati

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

[diff] [blame]

1592

#

1593

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

1594

#

1595

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1596

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1597

#

1598

# { // Captured variable

Bu Sun Kim

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

[diff] [blame]

1599

# name: "pp",

1600

# value: "0x00500500",

1601

# type: "int**",

Sai Cheemalapati

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

[diff] [blame]

1602

# members {

Bu Sun Kim

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

[diff] [blame]

1603

# value: "0x00400400",

1604

# type: "int*"

Sai Cheemalapati

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

[diff] [blame]

1605

# status {

1606

# is_error: true,

Bu Sun Kim

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

[diff] [blame]

1607

# description: { format: "unavailable" } }

Sai Cheemalapati

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

[diff] [blame]

# }

# }

# }

#

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

1613

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

1614

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

1615

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

1616

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

1617

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

1618

#

1619

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

1620

#

1621

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1622

# T* p = &x;

1623

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1624

#

Bu Sun Kim

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

[diff] [blame]

1625

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

1626

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

1627

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

Sai Cheemalapati

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

[diff] [blame]

1628

#

1629

# { // Shared variable table entry #3:

Bu Sun Kim

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

[diff] [blame]

1630

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

1631

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

Sai Cheemalapati

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

[diff] [blame]

1632

# }

1633

#

1634

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

1635

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

1636

# to be shared between pointers and references.

1637

#

1638

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

1639

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

1640

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

1641

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

1642

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

1643

# state.

1644

#

1645

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

1646

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

1647

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

1648

#

1649

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

1650

#

1651

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

1652

#

1653

# Examples of error message applied to value:

1654

#

1655

# * `Malformed string`,

1656

# * `Field f not found in class C`

1657

# * `Null pointer dereference`

1658

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

1659

# specific parts of the containing object.

1660

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

1661

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

Bu Sun Kim

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

[diff] [blame]

1662

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

1663

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

Bu Sun Kim

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

[diff] [blame]

1664

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

Sai Cheemalapati

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

[diff] [blame]

1665

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

1670

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

Sai Cheemalapati

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

[diff] [blame]

1671

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

1672

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

Bu Sun Kim

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

[diff] [blame]

1673

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

1674

"A String",

1675

],

Takashi Matsuo

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

[diff] [blame]

1676

},

Bu Sun Kim

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

[diff] [blame]

1677

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

Takashi Matsuo

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

[diff] [blame]

1678

},

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1679

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

1680

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

1681

# Object with schema name: Variable

1682

],

Bu Sun Kim

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

[diff] [blame]

1683

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

1684

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

1685

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

1686

# rather than a static type of an object.

Bu Sun Kim

2020-07-22 17:02:09 -0700

[diff] [blame]

1687

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

Bu Sun Kim

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

[diff] [blame]

1688

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

1689

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

1690

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

Takashi Matsuo

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

[diff] [blame]

1691

},

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