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

Dan O'Meara

2020-05-01 07:42:23 -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

Dan O'Meara

2020-05-01 07:42:23 -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

92

doesn't change the breakpoint semantics.

93

94

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

95

when it encounters the same breakpoint on a successive call.

96

Moreover, an agent should remember the breakpoints that are completed

97

until the controller removes them from the active list to avoid

98

setting those breakpoints again.

Takashi Matsuo

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

[diff] [blame]

99

100

Args:

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

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

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

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

[diff] [blame]

122

{ # Response for listing active breakpoints.

Bu Sun Kim

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

[diff] [blame]

123

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

124

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

125

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

126

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

Sai Cheemalapati

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

[diff] [blame]

127

# the list of breakpoints changes.

128

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

129

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

130

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

131

# ## Breakpoint (the resource)

132

#

133

# Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

134

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

135

#

136

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

137

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

138

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

139

# display the text message back to the user.

140

#

141

# Error status indicates complete failure of the breakpoint.

142

#

143

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

144

#

145

# Examples (final state):

146

#

147

# * `Invalid line number` referring to location

148

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

149

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

150

# specific parts of the containing object.

151

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

152

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

Takashi Matsuo

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

[diff] [blame]

153

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

154

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

155

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

156

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

157

"A String",

158

],

Sai Cheemalapati

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

[diff] [blame]

159

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

160

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

166

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

167

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

Takashi Matsuo

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

[diff] [blame]

168

},

169

},

Sai Cheemalapati

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

[diff] [blame]

170

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

171

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

172

# it from multiple variables, including variables stored in the

173

# `variable_table` itself.

174

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

175

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

176

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

177

#

178

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

179

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

180

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

181

# and the referenced variable.

182

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

183

# Note how the following variables are represented:

184

#

185

# 1) A simple variable:

#

# int x = 5

#

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

190

#

191

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

200

# name: "x",

201

# type: "T",

202

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

203

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

204

# }

205

#

206

# 3) A pointer where the pointee was captured:

207

#

208

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

209

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

210

#

211

# { // Captured variable

212

# name: "p",

213

# type: "T*",

214

# value: "0x00500500",

215

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

216

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

217

# }

218

#

219

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

#

# T* p = new T;

#

# { // Captured variable

224

# name: "p",

225

# type: "T*",

226

# value: "0x00400400"

227

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

228

# }

229

#

230

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

Dan O'Meara

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

[diff] [blame]

231

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

Sai Cheemalapati

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

[diff] [blame]

232

#

233

# Note that a null pointer should not have members.

234

#

235

# 5) An unnamed value:

236

#

237

# int* p = new int(7);

238

#

239

# { // Captured variable

240

# name: "p",

241

# value: "0x00500500",

242

# type: "int*",

243

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

244

#

245

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

246

#

247

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

248

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

249

#

250

# { // Captured variable

251

# name: "pp",

252

# value: "0x00500500",

253

# type: "int**",

254

# members {

255

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

265

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

266

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

267

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

268

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

269

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

270

#

271

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

272

#

273

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

274

# T* p = &x;

275

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

276

#

277

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

278

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

Dan O'Meara

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

[diff] [blame]

279

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

Sai Cheemalapati

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

[diff] [blame]

280

#

281

# { // Shared variable table entry #3:

282

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

283

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

284

# }

285

#

286

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

287

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

288

# to be shared between pointers and references.

289

#

290

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

291

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

292

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

293

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

294

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

295

# state.

296

#

297

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

298

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

299

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

300

#

301

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

302

#

303

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

304

#

305

# Examples of error message applied to value:

306

#

307

# * `Malformed string`,

308

# * `Field f not found in class C`

309

# * `Null pointer dereference`

310

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

311

# specific parts of the containing object.

312

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

313

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

Takashi Matsuo

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

[diff] [blame]

314

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

315

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

316

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

317

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

318

"A String",

319

],

Sai Cheemalapati

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

[diff] [blame]

320

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

321

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

327

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

328

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

Takashi Matsuo

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

[diff] [blame]

329

},

330

},

Jon Wayne Parrott

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

[diff] [blame]

331

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

Sai Cheemalapati

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

[diff] [blame]

332

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

333

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

334

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

Jon Wayne Parrott

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

[diff] [blame]

335

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

336

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

337

# Object with schema name: Variable

338

],

Sai Cheemalapati

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

[diff] [blame]

339

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

340

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

341

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

342

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

343

},

344

],

Sai Cheemalapati

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

[diff] [blame]

345

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

Bu Sun Kim

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

[diff] [blame]

346

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

347

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

348

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

349

# of the appropriate expression. Expressions not referenced in

350

# `log_message_format` are not logged.

351

#

352

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

353

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

Dan O'Meara

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

[diff] [blame]

354

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

Jon Wayne Parrott

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

[diff] [blame]

355

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

Sai Cheemalapati

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

[diff] [blame]

356

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

357

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

358

"a_key": "A String",

359

},

Bu Sun Kim

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

[diff] [blame]

360

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

361

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

362

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

363

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

Thomas Coffee

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

[diff] [blame]

364

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

365

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

366

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

367

# Note how the following variables are represented:

368

#

369

# 1) A simple variable:

#

# int x = 5

#

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

374

#

375

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

384

# name: "x",

385

# type: "T",

386

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

387

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

388

# }

389

#

390

# 3) A pointer where the pointee was captured:

391

#

392

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

393

# T* p = &x;

Thomas Coffee

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

[diff] [blame]

394

#

395

# { // Captured variable

396

# name: "p",

397

# type: "T*",

398

# value: "0x00500500",

399

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

400

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

401

# }

402

#

403

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

#

# T* p = new T;

#

# { // Captured variable

408

# name: "p",

409

# type: "T*",

410

# value: "0x00400400"

411

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

412

# }

413

#

414

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

Dan O'Meara

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

[diff] [blame]

415

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

Thomas Coffee

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

[diff] [blame]

416

#

417

# Note that a null pointer should not have members.

418

#

419

# 5) An unnamed value:

420

#

421

# int* p = new int(7);

422

#

423

# { // Captured variable

424

# name: "p",

425

# value: "0x00500500",

426

# type: "int*",

427

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

428

#

429

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

430

#

431

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

432

# int** pp = &p;

Thomas Coffee

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

[diff] [blame]

433

#

434

# { // Captured variable

435

# name: "pp",

436

# value: "0x00500500",

437

# type: "int**",

438

# members {

439

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

449

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

450

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

451

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

452

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

453

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

454

#

455

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

456

#

457

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

458

# T* p = &x;

459

# T& r = x;

Thomas Coffee

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

[diff] [blame]

460

#

461

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

462

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

Dan O'Meara

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

[diff] [blame]

463

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

Thomas Coffee

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

[diff] [blame]

464

#

465

# { // Shared variable table entry #3:

466

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

467

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

468

# }

469

#

470

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

471

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

472

# to be shared between pointers and references.

473

#

474

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

475

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

476

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

477

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

478

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

479

# state.

480

#

481

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

482

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

483

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

484

#

485

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

486

#

487

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

488

#

489

# Examples of error message applied to value:

490

#

491

# * `Malformed string`,

492

# * `Field f not found in class C`

493

# * `Null pointer dereference`

494

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

495

# specific parts of the containing object.

496

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

497

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

498

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

499

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

500

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

501

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

502

"A String",

503

],

504

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

505

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

511

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

512

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

513

},

514

},

515

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

516

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

517

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

518

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

519

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

520

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

521

# Object with schema name: Variable

522

],

523

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

524

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

525

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

526

# rather than a static type of an object.

527

},

528

],

Sai Cheemalapati

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

[diff] [blame]

529

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

530

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

531

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

532

# Note how the following variables are represented:

533

#

534

# 1) A simple variable:

#

# int x = 5

#

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

539

#

540

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

549

# name: "x",

550

# type: "T",

551

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

552

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

553

# }

554

#

555

# 3) A pointer where the pointee was captured:

556

#

557

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

558

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

559

#

560

# { // Captured variable

561

# name: "p",

562

# type: "T*",

563

# value: "0x00500500",

564

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

565

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

566

# }

567

#

568

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

#

# T* p = new T;

#

# { // Captured variable

573

# name: "p",

574

# type: "T*",

575

# value: "0x00400400"

576

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

577

# }

578

#

579

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

Dan O'Meara

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

[diff] [blame]

580

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

Sai Cheemalapati

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

[diff] [blame]

581

#

582

# Note that a null pointer should not have members.

583

#

584

# 5) An unnamed value:

585

#

586

# int* p = new int(7);

587

#

588

# { // Captured variable

589

# name: "p",

590

# value: "0x00500500",

591

# type: "int*",

592

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

593

#

594

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

595

#

596

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

597

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

598

#

599

# { // Captured variable

600

# name: "pp",

601

# value: "0x00500500",

602

# type: "int**",

603

# members {

604

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

614

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

615

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

616

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

617

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

618

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

619

#

620

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

621

#

622

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

623

# T* p = &x;

624

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

625

#

626

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

627

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

Dan O'Meara

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

[diff] [blame]

628

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

Sai Cheemalapati

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

[diff] [blame]

629

#

630

# { // Shared variable table entry #3:

631

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

632

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

633

# }

634

#

635

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

636

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

637

# to be shared between pointers and references.

638

#

639

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

640

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

641

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

642

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

643

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

644

# state.

645

#

646

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

647

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

648

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

649

#

650

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

651

#

652

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

653

#

654

# Examples of error message applied to value:

655

#

656

# * `Malformed string`,

657

# * `Field f not found in class C`

658

# * `Null pointer dereference`

659

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

660

# specific parts of the containing object.

661

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

662

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

663

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

664

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

665

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

666

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

667

"A String",

668

],

669

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

670

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

676

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

677

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

678

},

679

},

680

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

681

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

682

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

683

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

684

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

685

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

686

# Object with schema name: Variable

687

],

688

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

689

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

690

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

691

# rather than a static type of an object.

692

},

693

],

694

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

Bu Sun Kim

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

[diff] [blame]

695

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

696

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

697

# this field.

Sai Cheemalapati

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

[diff] [blame]

698

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

699

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

700

},

Takashi Matsuo

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

[diff] [blame]

701

},

702

],

Sai Cheemalapati

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

[diff] [blame]

703

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

Dan O'Meara

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

[diff] [blame]

704

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

705

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

Sai Cheemalapati

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

[diff] [blame]

706

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

Bu Sun Kim

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

[diff] [blame]

707

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

708

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

709

# this field.

Sai Cheemalapati

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

[diff] [blame]

710

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

711

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

712

},

713

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

714

# resolution.

715

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

716

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame]

717

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

718

# The expressions are composed using expressions in the programming language

719

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

720

# expressions are included in log statements.

721

"A String",

722

],

Sai Cheemalapati

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

[diff] [blame]

723

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

724

# breakpoint state will not change from here on.

725

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

726

# The evaluated expressions appear in exactly the same order they

727

# are listed in the `expressions` field.

728

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

729

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

730

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

731

# will indicate an error and contain the error text.

732

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

733

# Note how the following variables are represented:

734

#

735

# 1) A simple variable:

#

# int x = 5

#

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

740

#

741

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

750

# name: "x",

751

# type: "T",

752

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

753

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

754

# }

755

#

756

# 3) A pointer where the pointee was captured:

757

#

758

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

759

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

760

#

761

# { // Captured variable

762

# name: "p",

763

# type: "T*",

764

# value: "0x00500500",

765

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

766

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

767

# }

768

#

769

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

#

# T* p = new T;

#

# { // Captured variable

774

# name: "p",

775

# type: "T*",

776

# value: "0x00400400"

777

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

778

# }

779

#

780

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

Dan O'Meara

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

[diff] [blame]

781

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

Sai Cheemalapati

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

[diff] [blame]

782

#

783

# Note that a null pointer should not have members.

784

#

785

# 5) An unnamed value:

786

#

787

# int* p = new int(7);

788

#

789

# { // Captured variable

790

# name: "p",

791

# value: "0x00500500",

792

# type: "int*",

793

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

794

#

795

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

796

#

797

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

798

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

799

#

800

# { // Captured variable

801

# name: "pp",

802

# value: "0x00500500",

803

# type: "int**",

804

# members {

805

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

815

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

816

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

817

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

818

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

819

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

820

#

821

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

822

#

823

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

824

# T* p = &x;

825

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

826

#

827

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

828

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

Dan O'Meara

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

[diff] [blame]

829

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

Sai Cheemalapati

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

[diff] [blame]

830

#

831

# { // Shared variable table entry #3:

832

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

833

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

834

# }

835

#

836

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

837

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

838

# to be shared between pointers and references.

839

#

840

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

841

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

842

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

843

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

844

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

845

# state.

846

#

847

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

848

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

849

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

850

#

851

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

852

#

853

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

854

#

855

# Examples of error message applied to value:

856

#

857

# * `Malformed string`,

858

# * `Field f not found in class C`

859

# * `Null pointer dereference`

860

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

861

# specific parts of the containing object.

862

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

863

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

Takashi Matsuo

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

[diff] [blame]

864

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

865

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

866

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

867

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

868

"A String",

869

],

Sai Cheemalapati

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

[diff] [blame]

870

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

871

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

877

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

878

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

Takashi Matsuo

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

[diff] [blame]

879

},

880

},

Jon Wayne Parrott

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

[diff] [blame]

881

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

Sai Cheemalapati

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

[diff] [blame]

882

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

883

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

884

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

Jon Wayne Parrott

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

[diff] [blame]

885

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

886

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

887

# Object with schema name: Variable

888

],

Sai Cheemalapati

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

[diff] [blame]

889

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

890

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

891

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

892

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

893

},

894

],

895

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

Sai Cheemalapati

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

[diff] [blame]

896

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

897

# The condition is a compound boolean expression composed using expressions

898

# in a programming language at the source location.

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

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

[diff] [blame]

921

{ # Request to update an active breakpoint.

Dan O'Meara

2020-05-01 07:42:23 -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.

Sai Cheemalapati

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

[diff] [blame]

928

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

929

#

930

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

931

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

932

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

933

# display the text message back to the user.

934

#

935

# Error status indicates complete failure of the breakpoint.

936

#

937

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

938

#

939

# Examples (final state):

940

#

941

# * `Invalid line number` referring to location

942

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

943

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

944

# specific parts of the containing object.

945

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

946

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

Takashi Matsuo

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

[diff] [blame]

947

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

948

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

949

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

950

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

951

"A String",

952

],

Sai Cheemalapati

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

[diff] [blame]

953

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

954

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

960

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

961

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

Takashi Matsuo

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

[diff] [blame]

962

},

963

},

Sai Cheemalapati

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

[diff] [blame]

964

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

965

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

966

# it from multiple variables, including variables stored in the

967

# `variable_table` itself.

968

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

969

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

970

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

971

#

972

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

973

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

974

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

975

# and the referenced variable.

976

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

977

# Note how the following variables are represented:

978

#

979

# 1) A simple variable:

#

# int x = 5

#

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

984

#

985

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

994

# name: "x",

995

# type: "T",

996

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

997

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

998

# }

999

#

1000

# 3) A pointer where the pointee was captured:

1001

#

1002

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1003

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1004

#

1005

# { // Captured variable

1006

# name: "p",

1007

# type: "T*",

1008

# value: "0x00500500",

1009

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

1010

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

1011

# }

1012

#

1013

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

#

# T* p = new T;

#

# { // Captured variable

1018

# name: "p",

1019

# type: "T*",

1020

# value: "0x00400400"

1021

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

1022

# }

1023

#

1024

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

Dan O'Meara

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

[diff] [blame]

1025

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

Sai Cheemalapati

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

[diff] [blame]

1026

#

1027

# Note that a null pointer should not have members.

1028

#

1029

# 5) An unnamed value:

1030

#

1031

# int* p = new int(7);

1032

#

1033

# { // Captured variable

1034

# name: "p",

1035

# value: "0x00500500",

1036

# type: "int*",

1037

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

1038

#

1039

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

1040

#

1041

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1042

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1043

#

1044

# { // Captured variable

1045

# name: "pp",

1046

# value: "0x00500500",

1047

# type: "int**",

1048

# members {

1049

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1059

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

1060

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

1061

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

1062

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

1063

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

1064

#

1065

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

1066

#

1067

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1068

# T* p = &x;

1069

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1070

#

1071

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

1072

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

Dan O'Meara

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

[diff] [blame]

1073

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

Sai Cheemalapati

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

[diff] [blame]

1074

#

1075

# { // Shared variable table entry #3:

1076

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

1077

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

1078

# }

1079

#

1080

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

1081

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

1082

# to be shared between pointers and references.

1083

#

1084

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

1085

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

1086

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

1087

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

1088

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

1089

# state.

1090

#

1091

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

1092

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

1093

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

1094

#

1095

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

1096

#

1097

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

1098

#

1099

# Examples of error message applied to value:

1100

#

1101

# * `Malformed string`,

1102

# * `Field f not found in class C`

1103

# * `Null pointer dereference`

1104

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

1105

# specific parts of the containing object.

1106

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

1107

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

Takashi Matsuo

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

[diff] [blame]

1108

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

1109

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

1110

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

1111

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

1112

"A String",

1113

],

Sai Cheemalapati

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

[diff] [blame]

1114

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

1115

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

1121

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

1122

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

Takashi Matsuo

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

[diff] [blame]

1123

},

1124

},

Jon Wayne Parrott

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

[diff] [blame]

1125

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

Sai Cheemalapati

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

[diff] [blame]

1126

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

1127

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

1128

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

Jon Wayne Parrott

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

[diff] [blame]

1129

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

1130

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

1131

# Object with schema name: Variable

1132

],

Sai Cheemalapati

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

[diff] [blame]

1133

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

1134

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

1135

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

1136

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1137

},

1138

],

Sai Cheemalapati

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

[diff] [blame]

1139

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

Bu Sun Kim

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

[diff] [blame]

1140

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

1141

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

1142

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

1143

# of the appropriate expression. Expressions not referenced in

1144

# `log_message_format` are not logged.

1145

#

1146

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

1147

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

Dan O'Meara

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

[diff] [blame]

1148

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

Jon Wayne Parrott

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

[diff] [blame]

1149

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

Sai Cheemalapati

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

[diff] [blame]

1150

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

1151

# displayed to the user.

Jon Wayne Parrott

0a471d3

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

[diff] [blame]

1152

"a_key": "A String",

1153

},

Bu Sun Kim

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

[diff] [blame]

1154

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

1155

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

1156

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1157

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

Thomas Coffee

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

[diff] [blame]

1158

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

1159

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

1160

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

1161

# Note how the following variables are represented:

1162

#

1163

# 1) A simple variable:

#

# int x = 5

#

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

1168

#

1169

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1178

# name: "x",

1179

# type: "T",

1180

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

1181

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

1182

# }

1183

#

1184

# 3) A pointer where the pointee was captured:

1185

#

1186

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1187

# T* p = &x;

Thomas Coffee

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

[diff] [blame]

1188

#

1189

# { // Captured variable

1190

# name: "p",

1191

# type: "T*",

1192

# value: "0x00500500",

1193

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

1194

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

1195

# }

1196

#

1197

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

#

# T* p = new T;

#

# { // Captured variable

1202

# name: "p",

1203

# type: "T*",

1204

# value: "0x00400400"

1205

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

1206

# }

1207

#

1208

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

Dan O'Meara

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

[diff] [blame]

1209

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

Thomas Coffee

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

[diff] [blame]

1210

#

1211

# Note that a null pointer should not have members.

1212

#

1213

# 5) An unnamed value:

1214

#

1215

# int* p = new int(7);

1216

#

1217

# { // Captured variable

1218

# name: "p",

1219

# value: "0x00500500",

1220

# type: "int*",

1221

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

1222

#

1223

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

1224

#

1225

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1226

# int** pp = &p;

Thomas Coffee

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

[diff] [blame]

1227

#

1228

# { // Captured variable

1229

# name: "pp",

1230

# value: "0x00500500",

1231

# type: "int**",

1232

# members {

1233

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1243

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

1244

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

1245

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

1246

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

1247

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

1248

#

1249

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

1250

#

1251

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1252

# T* p = &x;

1253

# T& r = x;

Thomas Coffee

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

[diff] [blame]

1254

#

1255

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

1256

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

Dan O'Meara

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

[diff] [blame]

1257

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

Thomas Coffee

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

[diff] [blame]

1258

#

1259

# { // Shared variable table entry #3:

1260

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

1261

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

1262

# }

1263

#

1264

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

1265

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

1266

# to be shared between pointers and references.

1267

#

1268

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

1269

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

1270

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

1271

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

1272

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

1273

# state.

1274

#

1275

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

1276

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

1277

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

1278

#

1279

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

1280

#

1281

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

1282

#

1283

# Examples of error message applied to value:

1284

#

1285

# * `Malformed string`,

1286

# * `Field f not found in class C`

1287

# * `Null pointer dereference`

1288

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

1289

# specific parts of the containing object.

1290

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

1291

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

1292

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

1293

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

1294

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

1295

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

1296

"A String",

1297

],

1298

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

1299

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

1305

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

1306

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

1307

},

1308

},

1309

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

1310

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

1311

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

1312

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

1313

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

1314

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

1315

# Object with schema name: Variable

1316

],

1317

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

1318

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

1319

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

1320

# rather than a static type of an object.

1321

},

1322

],

Sai Cheemalapati

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

[diff] [blame]

1323

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

1324

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

1325

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

1326

# Note how the following variables are represented:

1327

#

1328

# 1) A simple variable:

#

# int x = 5

#

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

1333

#

1334

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1343

# name: "x",

1344

# type: "T",

1345

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

1346

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

1347

# }

1348

#

1349

# 3) A pointer where the pointee was captured:

1350

#

1351

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1352

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1353

#

1354

# { // Captured variable

1355

# name: "p",

1356

# type: "T*",

1357

# value: "0x00500500",

1358

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

1359

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

1360

# }

1361

#

1362

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

#

# T* p = new T;

#

# { // Captured variable

1367

# name: "p",

1368

# type: "T*",

1369

# value: "0x00400400"

1370

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

1371

# }

1372

#

1373

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

Dan O'Meara

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

[diff] [blame]

1374

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

Sai Cheemalapati

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

[diff] [blame]

1375

#

1376

# Note that a null pointer should not have members.

1377

#

1378

# 5) An unnamed value:

1379

#

1380

# int* p = new int(7);

1381

#

1382

# { // Captured variable

1383

# name: "p",

1384

# value: "0x00500500",

1385

# type: "int*",

1386

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

1387

#

1388

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

1389

#

1390

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1391

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1392

#

1393

# { // Captured variable

1394

# name: "pp",

1395

# value: "0x00500500",

1396

# type: "int**",

1397

# members {

1398

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1408

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

1409

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

1410

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

1411

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

1412

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

1413

#

1414

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

1415

#

1416

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1417

# T* p = &x;

1418

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1419

#

1420

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

1421

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

Dan O'Meara

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

[diff] [blame]

1422

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

Sai Cheemalapati

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

[diff] [blame]

1423

#

1424

# { // Shared variable table entry #3:

1425

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

1426

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

1427

# }

1428

#

1429

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

1430

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

1431

# to be shared between pointers and references.

1432

#

1433

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

1434

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

1435

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

1436

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

1437

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

1438

# state.

1439

#

1440

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

1441

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

1442

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

1443

#

1444

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

1445

#

1446

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

1447

#

1448

# Examples of error message applied to value:

1449

#

1450

# * `Malformed string`,

1451

# * `Field f not found in class C`

1452

# * `Null pointer dereference`

1453

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

1454

# specific parts of the containing object.

1455

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

1456

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

1457

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

1458

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

1459

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

1460

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

1461

"A String",

1462

],

1463

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

1464

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

1470

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

1471

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

1472

},

1473

},

1474

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

1475

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

1476

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

1477

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

1478

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

1479

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

1480

# Object with schema name: Variable

1481

],

1482

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

1483

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

1484

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

1485

# rather than a static type of an object.

1486

},

1487

],

1488

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

Bu Sun Kim

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

[diff] [blame]

1489

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

1490

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

1491

# this field.

Sai Cheemalapati

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

[diff] [blame]

1492

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

1493

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

1494

},

Takashi Matsuo

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

[diff] [blame]

1495

},

1496

],

Sai Cheemalapati

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

[diff] [blame]

1497

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

Dan O'Meara

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

[diff] [blame]

1498

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

1499

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

Sai Cheemalapati

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

[diff] [blame]

1500

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

Bu Sun Kim

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

[diff] [blame]

1501

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

1502

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

1503

# this field.

Sai Cheemalapati

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

[diff] [blame]

1504

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

1505

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

1506

},

1507

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

1508

# resolution.

1509

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

1510

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame]

1511

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

1512

# The expressions are composed using expressions in the programming language

1513

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

1514

# expressions are included in log statements.

1515

"A String",

1516

],

Sai Cheemalapati

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

[diff] [blame]

1517

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

1518

# breakpoint state will not change from here on.

1519

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

1520

# The evaluated expressions appear in exactly the same order they

1521

# are listed in the `expressions` field.

1522

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

1523

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

1524

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

1525

# will indicate an error and contain the error text.

1526

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

1527

# Note how the following variables are represented:

1528

#

1529

# 1) A simple variable:

#

# int x = 5

#

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

1534

#

1535

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1544

# name: "x",

1545

# type: "T",

1546

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

1547

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

1548

# }

1549

#

1550

# 3) A pointer where the pointee was captured:

1551

#

1552

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1553

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1554

#

1555

# { // Captured variable

1556

# name: "p",

1557

# type: "T*",

1558

# value: "0x00500500",

1559

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

1560

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

1561

# }

1562

#

1563

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

#

# T* p = new T;

#

# { // Captured variable

1568

# name: "p",

1569

# type: "T*",

1570

# value: "0x00400400"

1571

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

1572

# }

1573

#

1574

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

Dan O'Meara

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

[diff] [blame]

1575

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

Sai Cheemalapati

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

[diff] [blame]

1576

#

1577

# Note that a null pointer should not have members.

1578

#

1579

# 5) An unnamed value:

1580

#

1581

# int* p = new int(7);

1582

#

1583

# { // Captured variable

1584

# name: "p",

1585

# value: "0x00500500",

1586

# type: "int*",

1587

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

1588

#

1589

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

1590

#

1591

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1592

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1593

#

1594

# { // Captured variable

1595

# name: "pp",

1596

# value: "0x00500500",

1597

# type: "int**",

1598

# members {

1599

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1609

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

1610

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

1611

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

1612

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

1613

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

1614

#

1615

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

1616

#

1617

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1618

# T* p = &x;

1619

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1620

#

1621

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

1622

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

Dan O'Meara

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

[diff] [blame]

1623

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

Sai Cheemalapati

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

[diff] [blame]

1624

#

1625

# { // Shared variable table entry #3:

1626

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

1627

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

1628

# }

1629

#

1630

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

1631

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

1632

# to be shared between pointers and references.

1633

#

1634

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

1635

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

1636

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

1637

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

1638

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

1639

# state.

1640

#

1641

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

1642

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

1643

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

1644

#

1645

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

1646

#

1647

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

1648

#

1649

# Examples of error message applied to value:

1650

#

1651

# * `Malformed string`,

1652

# * `Field f not found in class C`

1653

# * `Null pointer dereference`

1654

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

1655

# specific parts of the containing object.

1656

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

1657

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

Takashi Matsuo

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

[diff] [blame]

1658

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

1659

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

1660

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

1661

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

1662

"A String",

1663

],

Sai Cheemalapati

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

[diff] [blame]

1664

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

1665

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

1671

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

1672

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

Takashi Matsuo

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

[diff] [blame]

1673

},

1674

},

Jon Wayne Parrott

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

[diff] [blame]

1675

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

Sai Cheemalapati

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

[diff] [blame]

1676

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

1677

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

1678

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

Jon Wayne Parrott

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

[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

],

Sai Cheemalapati

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

[diff] [blame]

1683

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

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.

Takashi Matsuo

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

[diff] [blame]

1687

},

1688

],

1689

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

Sai Cheemalapati

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

[diff] [blame]

1690

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

1691

# The condition is a compound boolean expression composed using expressions

1692

# in a programming language at the source location.

Takashi Matsuo

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

[diff] [blame]

},

}

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

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