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

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

[diff] [blame]

76

<h2>Instance Methods</h2>

77

Jon Wayne Parrott

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

[diff] [blame]

78

<code><a href="#delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>

Takashi Matsuo

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

[diff] [blame]

79

<p class="firstline">Deletes the breakpoint from the debuggee.</p>

80

Jon Wayne Parrott

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

[diff] [blame]

81

<code><a href="#get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</a></code></p>

Takashi Matsuo

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

[diff] [blame]

82

<p class="firstline">Gets breakpoint information.</p>

83

Dan O'Meara

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

[diff] [blame]

84

<code><a href="#list">list(debuggeeId, stripResults=None, includeInactive=None, x__xgafv=None, clientVersion=None, includeAllUsers=None, action_value=None, waitToken=None)</a></code></p>

Jon Wayne Parrott

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

[diff] [blame]

85

<p class="firstline">Lists all breakpoints for the debuggee.</p>

Takashi Matsuo

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

[diff] [blame]

86

Dan O'Meara

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

[diff] [blame]

87

<code><a href="#set">set(debuggeeId, body=None, clientVersion=None, canaryOption=None, x__xgafv=None)</a></code></p>

Takashi Matsuo

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

[diff] [blame]

88

<p class="firstline">Sets the breakpoint to the debuggee.</p>

89

<h3>Method Details</h3>

90

Jon Wayne Parrott

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

[diff] [blame]

91

<code class="details" id="delete">delete(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>

Takashi Matsuo

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

[diff] [blame]

92

<pre>Deletes the breakpoint from the debuggee.

93

94

Args:

Dan O'Meara

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

[diff] [blame]

95

debuggeeId: string, Required. ID of the debuggee whose breakpoint to delete. (required)

96

breakpointId: string, Required. ID of the breakpoint to delete. (required)

97

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

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

[diff] [blame]

98

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

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

[diff] [blame]

99

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

100

Allowed values

101

1 - v1 error format

102

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

103

104

Returns:

105

An object of the form:

106

Sai Cheemalapati

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

[diff] [blame]

107

{ # A generic empty message that you can re-use to avoid defining duplicated

108

# empty messages in your APIs. A typical example is to use it as the request

109

# or the response type of an API method. For instance:

110

#

111

# service Foo {

112

# rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);

113

# }

114

#

115

# The JSON representation for `Empty` is empty JSON object `{}`.

Takashi Matsuo

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

[diff] [blame]

}</pre>

</div>

Jon Wayne Parrott

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

[diff] [blame]

120

<code class="details" id="get">get(debuggeeId, breakpointId, clientVersion=None, x__xgafv=None)</code>

Takashi Matsuo

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

[diff] [blame]

121

<pre>Gets breakpoint information.

122

123

Args:

Dan O'Meara

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

[diff] [blame]

124

debuggeeId: string, Required. ID of the debuggee whose breakpoint to get. (required)

125

breakpointId: string, Required. ID of the breakpoint to get. (required)

126

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

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

[diff] [blame]

127

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Takashi Matsuo

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

[diff] [blame]

128

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

129

Allowed values

130

1 - v1 error format

131

2 - v2 error format

Takashi Matsuo

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

[diff] [blame]

132

133

Returns:

134

An object of the form:

135

Jon Wayne Parrott

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

[diff] [blame]

136

{ # Response for getting breakpoint information.

Dan O'Meara

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

[diff] [blame]

137

"breakpoint": { # ------------------------------------------------------------------------------ # Complete breakpoint state.

Sai Cheemalapati

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

[diff] [blame]

138

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

Dan O'Meara

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

[diff] [blame]

139

# ## Breakpoint (the resource)

140

#

141

# Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

142

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

143

#

144

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

145

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

146

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

147

# display the text message back to the user.

148

#

149

# Error status indicates complete failure of the breakpoint.

150

#

151

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

152

#

153

# Examples (final state):

154

#

155

# * `Invalid line number` referring to location

156

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

157

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

158

# specific parts of the containing object.

159

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

160

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

Takashi Matsuo

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

[diff] [blame]

161

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

162

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

163

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

164

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

165

"A String",

166

],

Sai Cheemalapati

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

[diff] [blame]

167

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

168

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

174

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

175

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

Takashi Matsuo

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

[diff] [blame]

176

},

177

},

Sai Cheemalapati

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

[diff] [blame]

178

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

179

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

180

# it from multiple variables, including variables stored in the

181

# `variable_table` itself.

182

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

183

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

184

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

185

#

186

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

187

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

188

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

189

# and the referenced variable.

190

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

191

# Note how the following variables are represented:

192

#

193

# 1) A simple variable:

#

# int x = 5

#

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

198

#

199

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

208

# name: "x",

209

# type: "T",

210

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

211

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

212

# }

213

#

214

# 3) A pointer where the pointee was captured:

215

#

216

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

217

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

218

#

219

# { // Captured variable

220

# name: "p",

221

# type: "T*",

222

# value: "0x00500500",

223

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

224

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

225

# }

226

#

227

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

#

# T* p = new T;

#

# { // Captured variable

232

# name: "p",

233

# type: "T*",

234

# value: "0x00400400"

235

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

236

# }

237

#

238

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

Dan O'Meara

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

[diff] [blame]

239

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

Sai Cheemalapati

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

[diff] [blame]

240

#

241

# Note that a null pointer should not have members.

242

#

243

# 5) An unnamed value:

244

#

245

# int* p = new int(7);

246

#

247

# { // Captured variable

248

# name: "p",

249

# value: "0x00500500",

250

# type: "int*",

251

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

252

#

253

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

254

#

255

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

256

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

257

#

258

# { // Captured variable

259

# name: "pp",

260

# value: "0x00500500",

261

# type: "int**",

262

# members {

263

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

273

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

274

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

275

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

276

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

277

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

278

#

279

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

280

#

281

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

282

# T* p = &x;

283

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

284

#

285

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

286

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

Dan O'Meara

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

[diff] [blame]

287

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

Sai Cheemalapati

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

[diff] [blame]

288

#

289

# { // Shared variable table entry #3:

290

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

291

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

292

# }

293

#

294

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

295

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

296

# to be shared between pointers and references.

297

#

298

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

299

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

300

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

301

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

302

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

303

# state.

304

#

305

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

306

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

307

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

308

#

309

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

310

#

311

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

312

#

313

# Examples of error message applied to value:

314

#

315

# * `Malformed string`,

316

# * `Field f not found in class C`

317

# * `Null pointer dereference`

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

Takashi Matsuo

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

[diff] [blame]

322

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

323

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

324

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

325

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

326

"A String",

327

],

Sai Cheemalapati

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

[diff] [blame]

328

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

329

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

335

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

336

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

Takashi Matsuo

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

[diff] [blame]

337

},

338

},

Jon Wayne Parrott

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

[diff] [blame]

339

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

Sai Cheemalapati

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

[diff] [blame]

340

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

341

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

342

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

Jon Wayne Parrott

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

[diff] [blame]

343

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

344

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

345

# Object with schema name: Variable

346

],

Sai Cheemalapati

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

[diff] [blame]

347

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

348

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

349

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

350

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

351

},

352

],

Sai Cheemalapati

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

[diff] [blame]

353

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

354

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

355

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

356

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

357

# of the appropriate expression. Expressions not referenced in

358

# `log_message_format` are not logged.

359

#

360

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

361

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

Dan O'Meara

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

[diff] [blame]

362

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

Jon Wayne Parrott

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

[diff] [blame]

363

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

364

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

365

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

366

"a_key": "A String",

367

},

Bu Sun Kim

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

[diff] [blame]

368

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

369

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

370

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

371

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

Thomas Coffee

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

[diff] [blame]

372

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

373

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

374

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

375

# Note how the following variables are represented:

376

#

377

# 1) A simple variable:

#

# int x = 5

#

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

382

#

383

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

392

# name: "x",

393

# type: "T",

394

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

395

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

396

# }

397

#

398

# 3) A pointer where the pointee was captured:

399

#

400

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

401

# T* p = &x;

Thomas Coffee

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

[diff] [blame]

402

#

403

# { // Captured variable

404

# name: "p",

405

# type: "T*",

406

# value: "0x00500500",

407

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

408

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

409

# }

410

#

411

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

#

# T* p = new T;

#

# { // Captured variable

416

# name: "p",

417

# type: "T*",

418

# value: "0x00400400"

419

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

420

# }

421

#

422

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

Dan O'Meara

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

[diff] [blame]

423

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

Thomas Coffee

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

[diff] [blame]

424

#

425

# Note that a null pointer should not have members.

426

#

427

# 5) An unnamed value:

428

#

429

# int* p = new int(7);

430

#

431

# { // Captured variable

432

# name: "p",

433

# value: "0x00500500",

434

# type: "int*",

435

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

436

#

437

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

438

#

439

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

440

# int** pp = &p;

Thomas Coffee

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

[diff] [blame]

441

#

442

# { // Captured variable

443

# name: "pp",

444

# value: "0x00500500",

445

# type: "int**",

446

# members {

447

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

457

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

458

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

459

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

460

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

461

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

462

#

463

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

464

#

465

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

466

# T* p = &x;

467

# T& r = x;

Thomas Coffee

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

[diff] [blame]

468

#

469

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

470

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

Dan O'Meara

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

[diff] [blame]

471

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

Thomas Coffee

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

[diff] [blame]

472

#

473

# { // Shared variable table entry #3:

474

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

475

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

476

# }

477

#

478

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

479

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

480

# to be shared between pointers and references.

481

#

482

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

483

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

484

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

485

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

486

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

487

# state.

488

#

489

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

490

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

491

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

492

#

493

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

494

#

495

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

496

#

497

# Examples of error message applied to value:

498

#

499

# * `Malformed string`,

500

# * `Field f not found in class C`

501

# * `Null pointer dereference`

502

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

503

# specific parts of the containing object.

504

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

505

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

506

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

507

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

508

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

509

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

510

"A String",

511

],

512

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

513

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

519

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

520

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

521

},

522

},

523

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

524

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

525

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

526

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

527

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

528

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

529

# Object with schema name: Variable

530

],

531

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

532

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

533

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

534

# rather than a static type of an object.

535

},

536

],

Sai Cheemalapati

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

[diff] [blame]

537

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

538

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

539

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

540

# Note how the following variables are represented:

541

#

542

# 1) A simple variable:

#

# int x = 5

#

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

547

#

548

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

557

# name: "x",

558

# type: "T",

559

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

560

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

561

# }

562

#

563

# 3) A pointer where the pointee was captured:

564

#

565

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

566

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

567

#

568

# { // Captured variable

569

# name: "p",

570

# type: "T*",

571

# value: "0x00500500",

572

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

573

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

574

# }

575

#

576

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

#

# T* p = new T;

#

# { // Captured variable

581

# name: "p",

582

# type: "T*",

583

# value: "0x00400400"

584

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

585

# }

586

#

587

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

Dan O'Meara

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

[diff] [blame]

588

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

Sai Cheemalapati

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

[diff] [blame]

589

#

590

# Note that a null pointer should not have members.

591

#

592

# 5) An unnamed value:

593

#

594

# int* p = new int(7);

595

#

596

# { // Captured variable

597

# name: "p",

598

# value: "0x00500500",

599

# type: "int*",

600

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

601

#

602

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

603

#

604

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

605

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

606

#

607

# { // Captured variable

608

# name: "pp",

609

# value: "0x00500500",

610

# type: "int**",

611

# members {

612

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

622

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

623

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

624

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

625

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

626

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

627

#

628

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

629

#

630

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

631

# T* p = &x;

632

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

633

#

634

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

635

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

Dan O'Meara

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

[diff] [blame]

636

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

Sai Cheemalapati

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

[diff] [blame]

637

#

638

# { // Shared variable table entry #3:

639

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

640

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

641

# }

642

#

643

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

644

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

645

# to be shared between pointers and references.

646

#

647

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

648

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

649

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

650

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

651

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

652

# state.

653

#

654

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

655

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

656

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

657

#

658

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

659

#

660

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

661

#

662

# Examples of error message applied to value:

663

#

664

# * `Malformed string`,

665

# * `Field f not found in class C`

666

# * `Null pointer dereference`

667

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

668

# specific parts of the containing object.

669

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

670

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

671

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

672

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

673

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

674

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

675

"A String",

676

],

677

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

678

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

684

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

685

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

686

},

687

},

688

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

689

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

690

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

691

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

692

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

693

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

694

# Object with schema name: Variable

695

],

696

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

697

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

698

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

699

# rather than a static type of an object.

700

},

701

],

702

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

703

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

704

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

705

# this field.

Sai Cheemalapati

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

[diff] [blame]

706

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

707

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

708

},

Takashi Matsuo

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

[diff] [blame]

709

},

710

],

Sai Cheemalapati

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

[diff] [blame]

711

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

712

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

713

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

Sai Cheemalapati

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

[diff] [blame]

714

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

Bu Sun Kim

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

[diff] [blame]

715

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

716

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

717

# this field.

Sai Cheemalapati

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

[diff] [blame]

718

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

719

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

720

},

721

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

722

# resolution.

723

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

724

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame]

725

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

726

# The expressions are composed using expressions in the programming language

727

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

728

# expressions are included in log statements.

729

"A String",

730

],

Sai Cheemalapati

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

[diff] [blame]

731

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

732

# breakpoint state will not change from here on.

733

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

734

# The evaluated expressions appear in exactly the same order they

735

# are listed in the `expressions` field.

736

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

737

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

738

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

739

# will indicate an error and contain the error text.

740

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

741

# Note how the following variables are represented:

742

#

743

# 1) A simple variable:

#

# int x = 5

#

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

748

#

749

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

758

# name: "x",

759

# type: "T",

760

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

761

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

762

# }

763

#

764

# 3) A pointer where the pointee was captured:

765

#

766

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

767

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

768

#

769

# { // Captured variable

770

# name: "p",

771

# type: "T*",

772

# value: "0x00500500",

773

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

774

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

775

# }

776

#

777

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

#

# T* p = new T;

#

# { // Captured variable

782

# name: "p",

783

# type: "T*",

784

# value: "0x00400400"

785

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

786

# }

787

#

788

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

Dan O'Meara

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

[diff] [blame]

789

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

Sai Cheemalapati

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

[diff] [blame]

790

#

791

# Note that a null pointer should not have members.

792

#

793

# 5) An unnamed value:

794

#

795

# int* p = new int(7);

796

#

797

# { // Captured variable

798

# name: "p",

799

# value: "0x00500500",

800

# type: "int*",

801

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

802

#

803

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

804

#

805

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

806

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

807

#

808

# { // Captured variable

809

# name: "pp",

810

# value: "0x00500500",

811

# type: "int**",

812

# members {

813

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

823

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

824

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

825

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

826

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

827

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

828

#

829

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

830

#

831

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

832

# T* p = &x;

833

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

834

#

835

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

836

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

Dan O'Meara

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

[diff] [blame]

837

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

Sai Cheemalapati

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

[diff] [blame]

838

#

839

# { // Shared variable table entry #3:

840

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

841

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

842

# }

843

#

844

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

845

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

846

# to be shared between pointers and references.

847

#

848

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

849

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

850

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

851

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

852

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

853

# state.

854

#

855

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

856

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

857

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

858

#

859

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

860

#

861

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

862

#

863

# Examples of error message applied to value:

864

#

865

# * `Malformed string`,

866

# * `Field f not found in class C`

867

# * `Null pointer dereference`

868

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

869

# specific parts of the containing object.

870

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

871

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

Takashi Matsuo

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

[diff] [blame]

872

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

873

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

874

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

875

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

876

"A String",

877

],

Sai Cheemalapati

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

[diff] [blame]

878

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

879

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

885

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

886

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

Takashi Matsuo

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

[diff] [blame]

887

},

888

},

Jon Wayne Parrott

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

[diff] [blame]

889

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

Sai Cheemalapati

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

[diff] [blame]

890

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

891

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

892

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

Jon Wayne Parrott

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

[diff] [blame]

893

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

894

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

895

# Object with schema name: Variable

896

],

Sai Cheemalapati

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

[diff] [blame]

897

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

898

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

899

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

900

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

901

},

902

],

903

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

Sai Cheemalapati

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

[diff] [blame]

904

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

905

# The condition is a compound boolean expression composed using expressions

906

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

912

<code class="details" id="list">list(debuggeeId, stripResults=None, includeInactive=None, x__xgafv=None, clientVersion=None, includeAllUsers=None, action_value=None, waitToken=None)</code>

Jon Wayne Parrott

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

[diff] [blame]

913

<pre>Lists all breakpoints for the debuggee.

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. ID of the debuggee whose breakpoints to list. (required)

917

stripResults: boolean, This field is deprecated. The following fields are always stripped out of

918

the result: `stack_frames`, `evaluated_expressions` and `variable_table`.

Sai Cheemalapati

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

[diff] [blame]

919

includeInactive: boolean, When set to `true`, the response includes active and inactive

920

breakpoints. Otherwise, it includes only active breakpoints.

Takashi Matsuo

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

[diff] [blame]

921

x__xgafv: string, V1 error format.

Sai Cheemalapati

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

[diff] [blame]

922

Allowed values

923

1 - v1 error format

924

2 - v2 error format

Dan O'Meara

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

[diff] [blame]

925

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

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

[diff] [blame]

926

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Dan O'Meara

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

[diff] [blame]

927

includeAllUsers: boolean, When set to `true`, the response includes the list of breakpoints set by

928

any user. Otherwise, it includes only breakpoints set by the caller.

Takashi Matsuo

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

[diff] [blame]

929

action_value: string, Only breakpoints with the specified action will pass the filter.

Sai Cheemalapati

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

[diff] [blame]

930

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

931

list has changed, or a server selected timeout has expired. The value

932

should be set from the last response. The error code

933

`google.rpc.Code.ABORTED` (RPC) is returned on wait timeout, which

934

should be called again with the same `wait_token`.

Takashi Matsuo

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

[diff] [blame]

935

936

Returns:

937

An object of the form:

938

Jon Wayne Parrott

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

[diff] [blame]

939

{ # Response for listing breakpoints.

Sai Cheemalapati

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

[diff] [blame]

940

"nextWaitToken": "A String", # A wait token that can be used in the next call to `list` (REST) or

941

# `ListBreakpoints` (RPC) to block until the list of breakpoints has changes.

942

"breakpoints": [ # List of breakpoints matching the request.

943

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

944

# The fields: `stack_frames`, `evaluated_expressions` and `variable_table`

Bu Sun Kim

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

[diff] [blame]

945

# are cleared on each breakpoint regardless of its status.

Dan O'Meara

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

[diff] [blame]

946

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

947

# ## Breakpoint (the resource)

948

#

949

# Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

950

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

951

#

952

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

953

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

954

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

955

# display the text message back to the user.

956

#

957

# Error status indicates complete failure of the breakpoint.

958

#

959

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

960

#

961

# Examples (final state):

962

#

963

# * `Invalid line number` referring to location

964

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

965

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

966

# specific parts of the containing object.

967

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

968

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

Takashi Matsuo

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

[diff] [blame]

969

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

970

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

971

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

972

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

973

"A String",

974

],

Sai Cheemalapati

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

[diff] [blame]

975

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

976

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

982

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

983

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

Takashi Matsuo

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

[diff] [blame]

984

},

985

},

Sai Cheemalapati

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

[diff] [blame]

986

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

987

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

988

# it from multiple variables, including variables stored in the

989

# `variable_table` itself.

990

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

991

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

992

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

993

#

994

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

995

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

996

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

997

# and the referenced variable.

998

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

999

# Note how the following variables are represented:

1000

#

1001

# 1) A simple variable:

#

# int x = 5

#

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

1006

#

1007

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1016

# name: "x",

1017

# type: "T",

1018

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

1019

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

1020

# }

1021

#

1022

# 3) A pointer where the pointee was captured:

1023

#

1024

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1025

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1026

#

1027

# { // Captured variable

1028

# name: "p",

1029

# type: "T*",

1030

# value: "0x00500500",

1031

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

1032

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

1033

# }

1034

#

1035

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

#

# T* p = new T;

#

# { // Captured variable

1040

# name: "p",

1041

# type: "T*",

1042

# value: "0x00400400"

1043

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

1044

# }

1045

#

1046

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

Dan O'Meara

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

[diff] [blame]

1047

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

Sai Cheemalapati

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

[diff] [blame]

1048

#

1049

# Note that a null pointer should not have members.

1050

#

1051

# 5) An unnamed value:

1052

#

1053

# int* p = new int(7);

1054

#

1055

# { // Captured variable

1056

# name: "p",

1057

# value: "0x00500500",

1058

# type: "int*",

1059

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

1060

#

1061

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

1062

#

1063

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1064

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1065

#

1066

# { // Captured variable

1067

# name: "pp",

1068

# value: "0x00500500",

1069

# type: "int**",

1070

# members {

1071

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1081

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

1082

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

1083

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

1084

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

1085

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

1086

#

1087

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

1088

#

1089

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1090

# T* p = &x;

1091

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1092

#

1093

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

1094

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

Dan O'Meara

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

[diff] [blame]

1095

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

Sai Cheemalapati

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

[diff] [blame]

1096

#

1097

# { // Shared variable table entry #3:

1098

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

1099

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

1100

# }

1101

#

1102

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

1103

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

1104

# to be shared between pointers and references.

1105

#

1106

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

1107

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

1108

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

1109

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

1110

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

1111

# state.

1112

#

1113

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

1114

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

1115

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

1116

#

1117

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

1118

#

1119

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

1120

#

1121

# Examples of error message applied to value:

1122

#

1123

# * `Malformed string`,

1124

# * `Field f not found in class C`

1125

# * `Null pointer dereference`

1126

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

1127

# specific parts of the containing object.

1128

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

1129

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

Takashi Matsuo

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

[diff] [blame]

1130

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

1131

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

1132

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

1133

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

1134

"A String",

1135

],

Sai Cheemalapati

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

[diff] [blame]

1136

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

1137

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

1143

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

1144

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

Takashi Matsuo

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

[diff] [blame]

1145

},

1146

},

Jon Wayne Parrott

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

[diff] [blame]

1147

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

Sai Cheemalapati

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

[diff] [blame]

1148

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

1149

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

1150

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

Jon Wayne Parrott

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

[diff] [blame]

1151

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

1152

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

1153

# Object with schema name: Variable

1154

],

Sai Cheemalapati

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

[diff] [blame]

1155

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

1156

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

1157

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

1158

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1159

},

1160

],

Sai Cheemalapati

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

[diff] [blame]

1161

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

1162

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

1163

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

1164

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

1165

# of the appropriate expression. Expressions not referenced in

1166

# `log_message_format` are not logged.

1167

#

1168

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

1169

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

Dan O'Meara

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

[diff] [blame]

1170

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

Jon Wayne Parrott

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

[diff] [blame]

1171

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

1172

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

1173

# displayed to the user.

Jon Wayne Parrott

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

[diff] [blame]

1174

"a_key": "A String",

1175

},

Bu Sun Kim

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

[diff] [blame]

1176

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

1177

# recently entered function.

Takashi Matsuo

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

[diff] [blame]

1178

{ # Represents a stack frame context.

Jon Wayne Parrott

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

[diff] [blame]

1179

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

Thomas Coffee

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

[diff] [blame]

1180

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

1181

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

1182

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

1183

# Note how the following variables are represented:

1184

#

1185

# 1) A simple variable:

#

# int x = 5

#

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

1190

#

1191

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1200

# name: "x",

1201

# type: "T",

1202

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

1203

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

1204

# }

1205

#

1206

# 3) A pointer where the pointee was captured:

1207

#

1208

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1209

# T* p = &x;

Thomas Coffee

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

[diff] [blame]

1210

#

1211

# { // Captured variable

1212

# name: "p",

1213

# type: "T*",

1214

# value: "0x00500500",

1215

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

1216

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

1217

# }

1218

#

1219

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

#

# T* p = new T;

#

# { // Captured variable

1224

# name: "p",

1225

# type: "T*",

1226

# value: "0x00400400"

1227

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

1228

# }

1229

#

1230

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

Dan O'Meara

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

[diff] [blame]

1231

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

Thomas Coffee

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

[diff] [blame]

1232

#

1233

# Note that a null pointer should not have members.

1234

#

1235

# 5) An unnamed value:

1236

#

1237

# int* p = new int(7);

1238

#

1239

# { // Captured variable

1240

# name: "p",

1241

# value: "0x00500500",

1242

# type: "int*",

1243

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

1244

#

1245

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

1246

#

1247

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1248

# int** pp = &p;

Thomas Coffee

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

[diff] [blame]

1249

#

1250

# { // Captured variable

1251

# name: "pp",

1252

# value: "0x00500500",

1253

# type: "int**",

1254

# members {

1255

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1265

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

1266

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

1267

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

1268

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

1269

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

1270

#

1271

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

1272

#

1273

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1274

# T* p = &x;

1275

# T& r = x;

Thomas Coffee

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

[diff] [blame]

1276

#

1277

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

1278

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

Dan O'Meara

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

[diff] [blame]

1279

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

Thomas Coffee

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

[diff] [blame]

1280

#

1281

# { // Shared variable table entry #3:

1282

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

1283

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

1284

# }

1285

#

1286

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

1287

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

1288

# to be shared between pointers and references.

1289

#

1290

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

1291

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

1292

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

1293

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

1294

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

1295

# state.

1296

#

1297

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

1298

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

1299

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

1300

#

1301

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

1302

#

1303

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

1304

#

1305

# Examples of error message applied to value:

1306

#

1307

# * `Malformed string`,

1308

# * `Field f not found in class C`

1309

# * `Null pointer dereference`

1310

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

1311

# specific parts of the containing object.

1312

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

1313

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

1314

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

1315

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

1316

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

1317

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

1318

"A String",

1319

],

1320

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

1321

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

1327

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

1328

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

1329

},

1330

},

1331

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

1332

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

1333

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

1334

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

1335

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

1336

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

1337

# Object with schema name: Variable

1338

],

1339

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

1340

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

1341

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

1342

# rather than a static type of an object.

1343

},

1344

],

Sai Cheemalapati

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

[diff] [blame]

1345

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

1346

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

1347

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

1348

# Note how the following variables are represented:

1349

#

1350

# 1) A simple variable:

#

# int x = 5

#

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

1355

#

1356

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1365

# name: "x",

1366

# type: "T",

1367

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

1368

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

1369

# }

1370

#

1371

# 3) A pointer where the pointee was captured:

1372

#

1373

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1374

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1375

#

1376

# { // Captured variable

1377

# name: "p",

1378

# type: "T*",

1379

# value: "0x00500500",

1380

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

1381

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

1382

# }

1383

#

1384

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

#

# T* p = new T;

#

# { // Captured variable

1389

# name: "p",

1390

# type: "T*",

1391

# value: "0x00400400"

1392

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

1393

# }

1394

#

1395

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

Dan O'Meara

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

[diff] [blame]

1396

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

Sai Cheemalapati

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

[diff] [blame]

1397

#

1398

# Note that a null pointer should not have members.

1399

#

1400

# 5) An unnamed value:

1401

#

1402

# int* p = new int(7);

1403

#

1404

# { // Captured variable

1405

# name: "p",

1406

# value: "0x00500500",

1407

# type: "int*",

1408

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

1409

#

1410

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

1411

#

1412

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1413

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1414

#

1415

# { // Captured variable

1416

# name: "pp",

1417

# value: "0x00500500",

1418

# type: "int**",

1419

# members {

1420

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1430

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

1431

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

1432

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

1433

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

1434

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

1435

#

1436

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

1437

#

1438

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1439

# T* p = &x;

1440

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1441

#

1442

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

1443

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

Dan O'Meara

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

[diff] [blame]

1444

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

Sai Cheemalapati

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

[diff] [blame]

1445

#

1446

# { // Shared variable table entry #3:

1447

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

1448

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

1449

# }

1450

#

1451

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

1452

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

1453

# to be shared between pointers and references.

1454

#

1455

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

1456

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

1457

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

1458

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

1459

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

1460

# state.

1461

#

1462

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

1463

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

1464

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

1465

#

1466

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

1467

#

1468

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

1469

#

1470

# Examples of error message applied to value:

1471

#

1472

# * `Malformed string`,

1473

# * `Field f not found in class C`

1474

# * `Null pointer dereference`

1475

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

1476

# specific parts of the containing object.

1477

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

1478

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

1479

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

1480

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

1481

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

1482

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

1483

"A String",

1484

],

1485

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

1486

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

1492

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

1493

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

1494

},

1495

},

1496

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

1497

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

1498

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

1499

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

1500

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

1501

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

1502

# Object with schema name: Variable

1503

],

1504

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

1505

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

1506

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

1507

# rather than a static type of an object.

1508

},

1509

],

1510

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

1511

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

1512

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

1513

# this field.

Sai Cheemalapati

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

[diff] [blame]

1514

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

1515

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

1516

},

Takashi Matsuo

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

[diff] [blame]

1517

},

1518

],

Sai Cheemalapati

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

[diff] [blame]

1519

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

1520

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

1521

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

Sai Cheemalapati

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

[diff] [blame]

1522

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

Bu Sun Kim

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

[diff] [blame]

1523

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

1524

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

1525

# this field.

Sai Cheemalapati

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

[diff] [blame]

1526

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

1527

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

1528

},

1529

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

1530

# resolution.

1531

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

1532

# breakpoint location is hit.

Bu Sun Kim

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

[diff] [blame]

1533

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

1534

# The expressions are composed using expressions in the programming language

1535

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

1536

# expressions are included in log statements.

1537

"A String",

1538

],

Sai Cheemalapati

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

[diff] [blame]

1539

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

1540

# breakpoint state will not change from here on.

1541

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

1542

# The evaluated expressions appear in exactly the same order they

1543

# are listed in the `expressions` field.

1544

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

1545

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

1546

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

1547

# will indicate an error and contain the error text.

1548

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

1549

# Note how the following variables are represented:

1550

#

1551

# 1) A simple variable:

#

# int x = 5

#

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

1556

#

1557

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1566

# name: "x",

1567

# type: "T",

1568

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

1569

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

1570

# }

1571

#

1572

# 3) A pointer where the pointee was captured:

1573

#

1574

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1575

# T* p = &x;

Sai Cheemalapati

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

[diff] [blame]

1576

#

1577

# { // Captured variable

1578

# name: "p",

1579

# type: "T*",

1580

# value: "0x00500500",

1581

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

1582

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

1583

# }

1584

#

1585

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

#

# T* p = new T;

#

# { // Captured variable

1590

# name: "p",

1591

# type: "T*",

1592

# value: "0x00400400"

1593

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

1594

# }

1595

#

1596

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

Dan O'Meara

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

[diff] [blame]

1597

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

Sai Cheemalapati

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

[diff] [blame]

1598

#

1599

# Note that a null pointer should not have members.

1600

#

1601

# 5) An unnamed value:

1602

#

1603

# int* p = new int(7);

1604

#

1605

# { // Captured variable

1606

# name: "p",

1607

# value: "0x00500500",

1608

# type: "int*",

1609

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

1610

#

1611

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

1612

#

1613

# int* p = new int(7);

Dan O'Meara

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

[diff] [blame]

1614

# int** pp = &p;

Sai Cheemalapati

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

[diff] [blame]

1615

#

1616

# { // Captured variable

1617

# name: "pp",

1618

# value: "0x00500500",

1619

# type: "int**",

1620

# members {

1621

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

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

1631

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

1632

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

1633

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

1634

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

1635

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

1636

#

1637

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

1638

#

1639

# T x = { 3, 7 };

Dan O'Meara

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

[diff] [blame]

1640

# T* p = &x;

1641

# T& r = x;

Sai Cheemalapati

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

[diff] [blame]

1642

#

1643

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

1644

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

Dan O'Meara

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

[diff] [blame]

1645

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

Sai Cheemalapati

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

[diff] [blame]

1646

#

1647

# { // Shared variable table entry #3:

1648

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

1649

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

1650

# }

1651

#

1652

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

1653

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

1654

# to be shared between pointers and references.

1655

#

1656

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

1657

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

1658

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

1659

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

1660

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

1661

# state.

1662

#

1663

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

1664

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

1665

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

1666

#

1667

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

1668

#

1669

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

1670

#

1671

# Examples of error message applied to value:

1672

#

1673

# * `Malformed string`,

1674

# * `Field f not found in class C`

1675

# * `Null pointer dereference`

1676

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

1677

# specific parts of the containing object.

1678

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

1679

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

Takashi Matsuo

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

[diff] [blame]

1680

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

1681

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

1682

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

1683

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

1684

"A String",

1685

],

Sai Cheemalapati

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

[diff] [blame]

1686

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

1687

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

1693

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

1694

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

Takashi Matsuo

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

[diff] [blame]

1695

},

1696

},

Jon Wayne Parrott

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

[diff] [blame]

1697

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

Sai Cheemalapati

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

[diff] [blame]

1698

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

1699

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

1700

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

Jon Wayne Parrott

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

[diff] [blame]

1701

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

1702

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

1703

# Object with schema name: Variable

1704

],

Sai Cheemalapati

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

[diff] [blame]

1705

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

1706

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

1707

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

1708

# rather than a static type of an object.

Takashi Matsuo

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

[diff] [blame]

1709

},

1710

],

1711

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

Sai Cheemalapati

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

[diff] [blame]

1712

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

1713

# The condition is a compound boolean expression composed using expressions

1714

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

1721

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

Takashi Matsuo

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

[diff] [blame]

1722

<pre>Sets the breakpoint to the debuggee.

1723

1724

Args:

Dan O'Meara

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

[diff] [blame]

1725

debuggeeId: string, Required. ID of the debuggee where the breakpoint is to be set. (required)

1726

body: object, The request body.

Takashi Matsuo

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

[diff] [blame]

1727

The object takes the form of:

1728

Dan O'Meara

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

[diff] [blame]

1729

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

1730

# ## Breakpoint (the resource)

1731

#

1732

# Represents the breakpoint specification, status and results.

Sai Cheemalapati

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

[diff] [blame]

1733

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

1734

#

1735

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

1736

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

1737

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

1738

# display the text message back to the user.

1739

#

1740

# Error status indicates complete failure of the breakpoint.

1741

#

1742

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

1743

#

1744

# Examples (final state):

1745

#

1746

# * `Invalid line number` referring to location

1747

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

1748

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

1749

# specific parts of the containing object.

1750

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

1751

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

Takashi Matsuo

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

[diff] [blame]

1752

"isError": True or False, # Distinguishes errors from informational messages.

1753

"refersTo": "A String", # Reference to which the message applies.

1754

"description": { # Represents a message with parameters. # Status message text.

1755

"parameters": [ # Optional parameters to be embedded into the message.

1756

"A String",

1757

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1758

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

1759

# `$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

1765

# is loaded. Again, $0 is very important.`

1766

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1767

},

1768

},

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1769

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

1770

# traffic optimization. It enables storing a variable once and reference

1771

# it from multiple variables, including variables stored in the

1772

# `variable_table` itself.

1773

# For example, the same `this` object, which may appear at many levels of

1774

# the stack, can have all of its data stored once in this table. The

1775

# stack frame variables then would hold only a reference to it.

1776

#

1777

# The variable `var_table_index` field is an index into this repeated field.

1778

# The stored objects are nameless and get their name from the referencing

1779

# variable. The effective variable is a merge of the referencing variable

1780

# and the referenced variable.

1781

{ # Represents a variable or an argument possibly of a compound object type.

1782

# Note how the following variables are represented:

1783

#

1784

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

1789

#

1790

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1799

# name: "x",

1800

# type: "T",

1801

# members { name: "m1", value: "3", type: "int" },

1802

# members { name: "m2", value: "7", type: "int" }

1803

# }

1804

#

1805

# 3) A pointer where the pointee was captured:

1806

#

1807

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1808

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1809

#

1810

# { // Captured variable

1811

# name: "p",

1812

# type: "T*",

1813

# value: "0x00500500",

1814

# members { name: "m1", value: "3", type: "int" },

1815

# members { name: "m2", value: "7", type: "int" }

1816

# }

1817

#

1818

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

1823

# name: "p",

1824

# type: "T*",

1825

# value: "0x00400400"

1826

# status { is_error: true, description { format: "unavailable" } }

1827

# }

1828

#

1829

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1830

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1831

#

1832

# Note that a null pointer should not have members.

1833

#

1834

# 5) An unnamed value:

1835

#

1836

# int* p = new int(7);

1837

#

1838

# { // Captured variable

1839

# name: "p",

1840

# value: "0x00500500",

1841

# type: "int*",

1842

# members { value: "7", type: "int" } }

1843

#

1844

# 6) An unnamed pointer where the pointee was not captured:

1845

#

1846

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1847

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1848

#

1849

# { // Captured variable

1850

# name: "pp",

1851

# value: "0x00500500",

1852

# type: "int**",

1853

# members {

1854

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

1864

# repeat in the output multiple times can be stored once in a shared

1865

# variable table and be referenced using the `var_table_index` field. The

1866

# variables stored in the shared table are nameless and are essentially

1867

# a partition of the complete variable. To reconstruct the complete

1868

# variable, merge the referencing variable with the referenced variable.

1869

#

1870

# When using the shared variable table, the following variables:

1871

#

1872

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1873

# T* p = &x;

1874

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1875

#

1876

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

1877

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1878

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1879

#

1880

# { // Shared variable table entry #3:

1881

# members { name: "m1", value: "3", type: "int" },

1882

# members { name: "m2", value: "7", type: "int" }

1883

# }

1884

#

1885

# Note that the pointer address is stored with the referencing variable

1886

# and not with the referenced variable. This allows the referenced variable

1887

# to be shared between pointers and references.

1888

#

1889

# The type field is optional. The debugger agent may or may not support it.

1890

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

1891

# unset. A status of a single variable only applies to that variable or

1892

# expression. The rest of breakpoint data still remains valid. Variables

1893

# might be reported in error state even when breakpoint is not in final

1894

# state.

1895

#

1896

# The message may refer to variable name with `refers_to` set to

1897

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

1898

# In either case variable value and members will be unset.

1899

#

1900

# Example of error message applied to name: `Invalid expression syntax`.

1901

#

1902

# Example of information message applied to value: `Not captured`.

1903

#

1904

# Examples of error message applied to value:

1905

#

1906

# * `Malformed string`,

1907

# * `Field f not found in class C`

1908

# * `Null pointer dereference`

1909

# The message can indicate an error or informational status, and refer to

1910

# specific parts of the containing object.

1911

# For example, the `Breakpoint.status` field can indicate an error referring

1912

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1913

"isError": True or False, # Distinguishes errors from informational messages.

1914

"refersTo": "A String", # Reference to which the message applies.

1915

"description": { # Represents a message with parameters. # Status message text.

1916

"parameters": [ # Optional parameters to be embedded into the message.

1917

"A String",

1918

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1919

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

1920

# `$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

1926

# is loaded. Again, $0 is very important.`

1927

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1928

},

1929

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

1930

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1931

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

1932

# one variable can reference the same variable in the table. The

1933

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

1934

"value": "A String", # Simple value of the variable.

1935

"members": [ # Members contained or pointed to by the variable.

1936

# Object with schema name: Variable

1937

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

1938

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

1939

# `var_table_index`, `type` goes next to `value`. The interpretation of

1940

# a type is agent specific. It is recommended to include the dynamic type

1941

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1942

},

1943

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

1944

"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]

1945

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

1946

# the breakpoint hits. The message may include parameter placeholders `$0`,

1947

# `$1`, etc. These placeholders are replaced with the evaluated value

1948

# of the appropriate expression. Expressions not referenced in

1949

# `log_message_format` are not logged.

1950

#

1951

# Example: `Message received, id = $0, count = $1` with

1952

# `expressions` = `[ message.id, message.count ]`.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1953

"state": "A String", # The current state of the breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

1954

"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]

1955

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

1956

# displayed to the user.

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

1957

"a_key": "A String",

1958

},

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

1959

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

1960

# recently entered function.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

1961

{ # Represents a stack frame context.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

1962

"function": "A String", # Demangled function name at the call site.

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

1963

"arguments": [ # Set of arguments passed to this function.

1964

# Note that this might not be populated for all stack frames.

1965

{ # Represents a variable or an argument possibly of a compound object type.

1966

# Note how the following variables are represented:

1967

#

1968

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

1973

#

1974

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

1983

# name: "x",

1984

# type: "T",

1985

# members { name: "m1", value: "3", type: "int" },

1986

# members { name: "m2", value: "7", type: "int" }

1987

# }

1988

#

1989

# 3) A pointer where the pointee was captured:

1990

#

1991

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

1992

# T* p = &x;

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

1993

#

1994

# { // Captured variable

1995

# name: "p",

1996

# type: "T*",

1997

# value: "0x00500500",

1998

# members { name: "m1", value: "3", type: "int" },

1999

# members { name: "m2", value: "7", type: "int" }

2000

# }

2001

#

2002

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2007

# name: "p",

2008

# type: "T*",

2009

# value: "0x00400400"

2010

# status { is_error: true, description { format: "unavailable" } }

2011

# }

2012

#

2013

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2014

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2015

#

2016

# Note that a null pointer should not have members.

2017

#

2018

# 5) An unnamed value:

2019

#

2020

# int* p = new int(7);

2021

#

2022

# { // Captured variable

2023

# name: "p",

2024

# value: "0x00500500",

2025

# type: "int*",

2026

# members { value: "7", type: "int" } }

2027

#

2028

# 6) An unnamed pointer where the pointee was not captured:

2029

#

2030

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2031

# int** pp = &p;

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2032

#

2033

# { // Captured variable

2034

# name: "pp",

2035

# value: "0x00500500",

2036

# type: "int**",

2037

# members {

2038

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2048

# repeat in the output multiple times can be stored once in a shared

2049

# variable table and be referenced using the `var_table_index` field. The

2050

# variables stored in the shared table are nameless and are essentially

2051

# a partition of the complete variable. To reconstruct the complete

2052

# variable, merge the referencing variable with the referenced variable.

2053

#

2054

# When using the shared variable table, the following variables:

2055

#

2056

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2057

# T* p = &x;

2058

# T& r = x;

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2059

#

2060

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2061

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2062

# { name: "r", type="T&", var_table_index: 3 }

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2063

#

2064

# { // Shared variable table entry #3:

2065

# members { name: "m1", value: "3", type: "int" },

2066

# members { name: "m2", value: "7", type: "int" }

2067

# }

2068

#

2069

# Note that the pointer address is stored with the referencing variable

2070

# and not with the referenced variable. This allows the referenced variable

2071

# to be shared between pointers and references.

2072

#

2073

# The type field is optional. The debugger agent may or may not support it.

2074

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2075

# unset. A status of a single variable only applies to that variable or

2076

# expression. The rest of breakpoint data still remains valid. Variables

2077

# might be reported in error state even when breakpoint is not in final

2078

# state.

2079

#

2080

# The message may refer to variable name with `refers_to` set to

2081

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2082

# In either case variable value and members will be unset.

2083

#

2084

# Example of error message applied to name: `Invalid expression syntax`.

2085

#

2086

# Example of information message applied to value: `Not captured`.

2087

#

2088

# Examples of error message applied to value:

2089

#

2090

# * `Malformed string`,

2091

# * `Field f not found in class C`

2092

# * `Null pointer dereference`

2093

# The message can indicate an error or informational status, and refer to

2094

# specific parts of the containing object.

2095

# For example, the `Breakpoint.status` field can indicate an error referring

2096

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2097

"isError": True or False, # Distinguishes errors from informational messages.

2098

"refersTo": "A String", # Reference to which the message applies.

2099

"description": { # Represents a message with parameters. # Status message text.

2100

"parameters": [ # Optional parameters to be embedded into the message.

2101

"A String",

2102

],

2103

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2104

# `$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

2110

# is loaded. Again, $0 is very important.`

2111

# * `Please pay $$10 to use $0 instead of $1.`

2112

},

2113

},

2114

"name": "A String", # Name of the variable, if any.

2115

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2116

# one variable can reference the same variable in the table. The

2117

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2118

"value": "A String", # Simple value of the variable.

2119

"members": [ # Members contained or pointed to by the variable.

2120

# Object with schema name: Variable

2121

],

2122

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2123

# `var_table_index`, `type` goes next to `value`. The interpretation of

2124

# a type is agent specific. It is recommended to include the dynamic type

2125

# rather than a static type of an object.

2126

},

2127

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2128

"locals": [ # Set of local variables at the stack frame location.

2129

# Note that this might not be populated for all stack frames.

2130

{ # Represents a variable or an argument possibly of a compound object type.

2131

# Note how the following variables are represented:

2132

#

2133

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2138

#

2139

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2148

# name: "x",

2149

# type: "T",

2150

# members { name: "m1", value: "3", type: "int" },

2151

# members { name: "m2", value: "7", type: "int" }

2152

# }

2153

#

2154

# 3) A pointer where the pointee was captured:

2155

#

2156

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2157

# T* p = &x;

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2158

#

2159

# { // Captured variable

2160

# name: "p",

2161

# type: "T*",

2162

# value: "0x00500500",

2163

# members { name: "m1", value: "3", type: "int" },

2164

# members { name: "m2", value: "7", type: "int" }

2165

# }

2166

#

2167

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2172

# name: "p",

2173

# type: "T*",

2174

# value: "0x00400400"

2175

# status { is_error: true, description { format: "unavailable" } }

2176

# }

2177

#

2178

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2179

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2180

#

2181

# Note that a null pointer should not have members.

2182

#

2183

# 5) An unnamed value:

2184

#

2185

# int* p = new int(7);

2186

#

2187

# { // Captured variable

2188

# name: "p",

2189

# value: "0x00500500",

2190

# type: "int*",

2191

# members { value: "7", type: "int" } }

2192

#

2193

# 6) An unnamed pointer where the pointee was not captured:

2194

#

2195

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2196

# int** pp = &p;

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2197

#

2198

# { // Captured variable

2199

# name: "pp",

2200

# value: "0x00500500",

2201

# type: "int**",

2202

# members {

2203

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2213

# repeat in the output multiple times can be stored once in a shared

2214

# variable table and be referenced using the `var_table_index` field. The

2215

# variables stored in the shared table are nameless and are essentially

2216

# a partition of the complete variable. To reconstruct the complete

2217

# variable, merge the referencing variable with the referenced variable.

2218

#

2219

# When using the shared variable table, the following variables:

2220

#

2221

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2222

# T* p = &x;

2223

# T& r = x;

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2224

#

2225

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2226

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2227

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2228

#

2229

# { // Shared variable table entry #3:

2230

# members { name: "m1", value: "3", type: "int" },

2231

# members { name: "m2", value: "7", type: "int" }

2232

# }

2233

#

2234

# Note that the pointer address is stored with the referencing variable

2235

# and not with the referenced variable. This allows the referenced variable

2236

# to be shared between pointers and references.

2237

#

2238

# The type field is optional. The debugger agent may or may not support it.

2239

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2240

# unset. A status of a single variable only applies to that variable or

2241

# expression. The rest of breakpoint data still remains valid. Variables

2242

# might be reported in error state even when breakpoint is not in final

2243

# state.

2244

#

2245

# The message may refer to variable name with `refers_to` set to

2246

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2247

# In either case variable value and members will be unset.

2248

#

2249

# Example of error message applied to name: `Invalid expression syntax`.

2250

#

2251

# Example of information message applied to value: `Not captured`.

2252

#

2253

# Examples of error message applied to value:

2254

#

2255

# * `Malformed string`,

2256

# * `Field f not found in class C`

2257

# * `Null pointer dereference`

2258

# The message can indicate an error or informational status, and refer to

2259

# specific parts of the containing object.

2260

# For example, the `Breakpoint.status` field can indicate an error referring

2261

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2262

"isError": True or False, # Distinguishes errors from informational messages.

2263

"refersTo": "A String", # Reference to which the message applies.

2264

"description": { # Represents a message with parameters. # Status message text.

2265

"parameters": [ # Optional parameters to be embedded into the message.

2266

"A String",

2267

],

2268

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2269

# `$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

2275

# is loaded. Again, $0 is very important.`

2276

# * `Please pay $$10 to use $0 instead of $1.`

2277

},

2278

},

2279

"name": "A String", # Name of the variable, if any.

2280

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2281

# one variable can reference the same variable in the table. The

2282

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2283

"value": "A String", # Simple value of the variable.

2284

"members": [ # Members contained or pointed to by the variable.

2285

# Object with schema name: Variable

2286

],

2287

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2288

# `var_table_index`, `type` goes next to `value`. The interpretation of

2289

# a type is agent specific. It is recommended to include the dynamic type

2290

# rather than a static type of an object.

2291

},

2292

],

2293

"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]

2294

"column": 42, # Column within a line. The first column in a line as the value `1`.

2295

# Agents that do not support setting breakpoints on specific columns ignore

2296

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2297

"path": "A String", # Path to the source file within the source context of the target binary.

2298

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2299

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2300

},

2301

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2302

"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]

2303

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

2304

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2305

"location": { # Represents a location in the source code. # Breakpoint source location.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

2306

"column": 42, # Column within a line. The first column in a line as the value `1`.

2307

# Agents that do not support setting breakpoints on specific columns ignore

2308

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2309

"path": "A String", # Path to the source file within the source context of the target binary.

2310

"line": 42, # Line inside the file. The first line in the file has the value `1`.

2311

},

2312

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

2313

# resolution.

2314

"action": "A String", # Action that the agent should perform when the code at the

2315

# breakpoint location is hit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

2316

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

2317

# The expressions are composed using expressions in the programming language

2318

# at the source location. If the breakpoint action is `LOG`, the evaluated

2319

# expressions are included in log statements.

2320

"A String",

2321

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2322

"isFinalState": True or False, # When true, indicates that this is a final result and the

2323

# breakpoint state will not change from here on.

2324

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

2325

# The evaluated expressions appear in exactly the same order they

2326

# are listed in the `expressions` field.

2327

# The `name` field holds the original expression text, the `value` or

2328

# `members` field holds the result of the evaluated expression.

2329

# If the expression cannot be evaluated, the `status` inside the `Variable`

2330

# will indicate an error and contain the error text.

2331

{ # Represents a variable or an argument possibly of a compound object type.

2332

# Note how the following variables are represented:

2333

#

2334

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2339

#

2340

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2349

# name: "x",

2350

# type: "T",

2351

# members { name: "m1", value: "3", type: "int" },

2352

# members { name: "m2", value: "7", type: "int" }

2353

# }

2354

#

2355

# 3) A pointer where the pointee was captured:

2356

#

2357

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2358

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2359

#

2360

# { // Captured variable

2361

# name: "p",

2362

# type: "T*",

2363

# value: "0x00500500",

2364

# members { name: "m1", value: "3", type: "int" },

2365

# members { name: "m2", value: "7", type: "int" }

2366

# }

2367

#

2368

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2373

# name: "p",

2374

# type: "T*",

2375

# value: "0x00400400"

2376

# status { is_error: true, description { format: "unavailable" } }

2377

# }

2378

#

2379

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2380

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2381

#

2382

# Note that a null pointer should not have members.

2383

#

2384

# 5) An unnamed value:

2385

#

2386

# int* p = new int(7);

2387

#

2388

# { // Captured variable

2389

# name: "p",

2390

# value: "0x00500500",

2391

# type: "int*",

2392

# members { value: "7", type: "int" } }

2393

#

2394

# 6) An unnamed pointer where the pointee was not captured:

2395

#

2396

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2397

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2398

#

2399

# { // Captured variable

2400

# name: "pp",

2401

# value: "0x00500500",

2402

# type: "int**",

2403

# members {

2404

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2414

# repeat in the output multiple times can be stored once in a shared

2415

# variable table and be referenced using the `var_table_index` field. The

2416

# variables stored in the shared table are nameless and are essentially

2417

# a partition of the complete variable. To reconstruct the complete

2418

# variable, merge the referencing variable with the referenced variable.

2419

#

2420

# When using the shared variable table, the following variables:

2421

#

2422

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2423

# T* p = &x;

2424

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2425

#

2426

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2427

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2428

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2429

#

2430

# { // Shared variable table entry #3:

2431

# members { name: "m1", value: "3", type: "int" },

2432

# members { name: "m2", value: "7", type: "int" }

2433

# }

2434

#

2435

# Note that the pointer address is stored with the referencing variable

2436

# and not with the referenced variable. This allows the referenced variable

2437

# to be shared between pointers and references.

2438

#

2439

# The type field is optional. The debugger agent may or may not support it.

2440

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2441

# unset. A status of a single variable only applies to that variable or

2442

# expression. The rest of breakpoint data still remains valid. Variables

2443

# might be reported in error state even when breakpoint is not in final

2444

# state.

2445

#

2446

# The message may refer to variable name with `refers_to` set to

2447

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2448

# In either case variable value and members will be unset.

2449

#

2450

# Example of error message applied to name: `Invalid expression syntax`.

2451

#

2452

# Example of information message applied to value: `Not captured`.

2453

#

2454

# Examples of error message applied to value:

2455

#

2456

# * `Malformed string`,

2457

# * `Field f not found in class C`

2458

# * `Null pointer dereference`

2459

# The message can indicate an error or informational status, and refer to

2460

# specific parts of the containing object.

2461

# For example, the `Breakpoint.status` field can indicate an error referring

2462

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2463

"isError": True or False, # Distinguishes errors from informational messages.

2464

"refersTo": "A String", # Reference to which the message applies.

2465

"description": { # Represents a message with parameters. # Status message text.

2466

"parameters": [ # Optional parameters to be embedded into the message.

2467

"A String",

2468

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2469

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2470

# `$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

2476

# is loaded. Again, $0 is very important.`

2477

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2478

},

2479

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2480

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2481

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2482

# one variable can reference the same variable in the table. The

2483

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2484

"value": "A String", # Simple value of the variable.

2485

"members": [ # Members contained or pointed to by the variable.

2486

# Object with schema name: Variable

2487

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2488

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2489

# `var_table_index`, `type` goes next to `value`. The interpretation of

2490

# a type is agent specific. It is recommended to include the dynamic type

2491

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2492

},

2493

],

2494

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2495

"condition": "A String", # Condition that triggers the breakpoint.

2496

# The condition is a compound boolean expression composed using expressions

2497

# in a programming language at the source location.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2498

}

2499

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2500

clientVersion: string, Required. The client version making the call.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

2501

Schema: `domain/type/version` (e.g., `google.com/intellij/v1`).

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2502

canaryOption: string, The canary option set by the user upon setting breakpoint.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2503

x__xgafv: string, V1 error format.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2504

Allowed values

2505

1 - v1 error format

2506

2 - v2 error format

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2507

2508

Returns:

2509

An object of the form:

2510

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2511

{ # Response for setting a breakpoint.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2512

"breakpoint": { # ------------------------------------------------------------------------------ # Breakpoint resource.

2513

# The field `id` is guaranteed to be set (in addition to the echoed fields).

2514

# ## Breakpoint (the resource)

2515

#

2516

# Represents the breakpoint specification, status and results.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2517

"status": { # Represents a contextual status message. # Breakpoint status.

2518

#

2519

# The status includes an error flag and a human readable message.

2520

# This field is usually unset. The message can be either

2521

# informational or an error message. Regardless, clients should always

2522

# display the text message back to the user.

2523

#

2524

# Error status indicates complete failure of the breakpoint.

2525

#

2526

# Example (non-final state): `Still loading symbols...`

2527

#

2528

# Examples (final state):

2529

#

2530

# * `Invalid line number` referring to location

2531

# * `Field f not found in class C` referring to condition

2532

# The message can indicate an error or informational status, and refer to

2533

# specific parts of the containing object.

2534

# For example, the `Breakpoint.status` field can indicate an error referring

2535

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2536

"isError": True or False, # Distinguishes errors from informational messages.

2537

"refersTo": "A String", # Reference to which the message applies.

2538

"description": { # Represents a message with parameters. # Status message text.

2539

"parameters": [ # Optional parameters to be embedded into the message.

2540

"A String",

2541

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2542

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2543

# `$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

2549

# is loaded. Again, $0 is very important.`

2550

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2551

},

2552

},

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2553

"variableTable": [ # The `variable_table` exists to aid with computation, memory and network

2554

# traffic optimization. It enables storing a variable once and reference

2555

# it from multiple variables, including variables stored in the

2556

# `variable_table` itself.

2557

# For example, the same `this` object, which may appear at many levels of

2558

# the stack, can have all of its data stored once in this table. The

2559

# stack frame variables then would hold only a reference to it.

2560

#

2561

# The variable `var_table_index` field is an index into this repeated field.

2562

# The stored objects are nameless and get their name from the referencing

2563

# variable. The effective variable is a merge of the referencing variable

2564

# and the referenced variable.

2565

{ # Represents a variable or an argument possibly of a compound object type.

2566

# Note how the following variables are represented:

2567

#

2568

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2573

#

2574

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2583

# name: "x",

2584

# type: "T",

2585

# members { name: "m1", value: "3", type: "int" },

2586

# members { name: "m2", value: "7", type: "int" }

2587

# }

2588

#

2589

# 3) A pointer where the pointee was captured:

2590

#

2591

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2592

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2593

#

2594

# { // Captured variable

2595

# name: "p",

2596

# type: "T*",

2597

# value: "0x00500500",

2598

# members { name: "m1", value: "3", type: "int" },

2599

# members { name: "m2", value: "7", type: "int" }

2600

# }

2601

#

2602

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2607

# name: "p",

2608

# type: "T*",

2609

# value: "0x00400400"

2610

# status { is_error: true, description { format: "unavailable" } }

2611

# }

2612

#

2613

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2614

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2615

#

2616

# Note that a null pointer should not have members.

2617

#

2618

# 5) An unnamed value:

2619

#

2620

# int* p = new int(7);

2621

#

2622

# { // Captured variable

2623

# name: "p",

2624

# value: "0x00500500",

2625

# type: "int*",

2626

# members { value: "7", type: "int" } }

2627

#

2628

# 6) An unnamed pointer where the pointee was not captured:

2629

#

2630

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2631

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2632

#

2633

# { // Captured variable

2634

# name: "pp",

2635

# value: "0x00500500",

2636

# type: "int**",

2637

# members {

2638

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2648

# repeat in the output multiple times can be stored once in a shared

2649

# variable table and be referenced using the `var_table_index` field. The

2650

# variables stored in the shared table are nameless and are essentially

2651

# a partition of the complete variable. To reconstruct the complete

2652

# variable, merge the referencing variable with the referenced variable.

2653

#

2654

# When using the shared variable table, the following variables:

2655

#

2656

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2657

# T* p = &x;

2658

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2659

#

2660

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2661

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2662

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2663

#

2664

# { // Shared variable table entry #3:

2665

# members { name: "m1", value: "3", type: "int" },

2666

# members { name: "m2", value: "7", type: "int" }

2667

# }

2668

#

2669

# Note that the pointer address is stored with the referencing variable

2670

# and not with the referenced variable. This allows the referenced variable

2671

# to be shared between pointers and references.

2672

#

2673

# The type field is optional. The debugger agent may or may not support it.

2674

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2675

# unset. A status of a single variable only applies to that variable or

2676

# expression. The rest of breakpoint data still remains valid. Variables

2677

# might be reported in error state even when breakpoint is not in final

2678

# state.

2679

#

2680

# The message may refer to variable name with `refers_to` set to

2681

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2682

# In either case variable value and members will be unset.

2683

#

2684

# Example of error message applied to name: `Invalid expression syntax`.

2685

#

2686

# Example of information message applied to value: `Not captured`.

2687

#

2688

# Examples of error message applied to value:

2689

#

2690

# * `Malformed string`,

2691

# * `Field f not found in class C`

2692

# * `Null pointer dereference`

2693

# The message can indicate an error or informational status, and refer to

2694

# specific parts of the containing object.

2695

# For example, the `Breakpoint.status` field can indicate an error referring

2696

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2697

"isError": True or False, # Distinguishes errors from informational messages.

2698

"refersTo": "A String", # Reference to which the message applies.

2699

"description": { # Represents a message with parameters. # Status message text.

2700

"parameters": [ # Optional parameters to be embedded into the message.

2701

"A String",

2702

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2703

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2704

# `$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

2710

# is loaded. Again, $0 is very important.`

2711

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2712

},

2713

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2714

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2715

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2716

# one variable can reference the same variable in the table. The

2717

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2718

"value": "A String", # Simple value of the variable.

2719

"members": [ # Members contained or pointed to by the variable.

2720

# Object with schema name: Variable

2721

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

2722

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2723

# `var_table_index`, `type` goes next to `value`. The interpretation of

2724

# a type is agent specific. It is recommended to include the dynamic type

2725

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2726

},

2727

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2728

"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]

2729

"logMessageFormat": "A String", # Only relevant when action is `LOG`. Defines the message to log when

2730

# the breakpoint hits. The message may include parameter placeholders `$0`,

2731

# `$1`, etc. These placeholders are replaced with the evaluated value

2732

# of the appropriate expression. Expressions not referenced in

2733

# `log_message_format` are not logged.

2734

#

2735

# Example: `Message received, id = $0, count = $1` with

2736

# `expressions` = `[ message.id, message.count ]`.

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2737

"state": "A String", # The current state of the breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2738

"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]

2739

"labels": { # A set of custom breakpoint properties, populated by the agent, to be

2740

# displayed to the user.

Jon Wayne Parrott

2016-05-19 10:54:38 -0700

[diff] [blame]

2741

"a_key": "A String",

2742

},

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

2743

"stackFrames": [ # The stack at breakpoint time, where stack_frames[0] represents the most

2744

# recently entered function.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

2745

{ # Represents a stack frame context.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

2746

"function": "A String", # Demangled function name at the call site.

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2747

"arguments": [ # Set of arguments passed to this function.

2748

# Note that this might not be populated for all stack frames.

2749

{ # Represents a variable or an argument possibly of a compound object type.

2750

# Note how the following variables are represented:

2751

#

2752

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2757

#

2758

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2767

# name: "x",

2768

# type: "T",

2769

# members { name: "m1", value: "3", type: "int" },

2770

# members { name: "m2", value: "7", type: "int" }

2771

# }

2772

#

2773

# 3) A pointer where the pointee was captured:

2774

#

2775

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2776

# T* p = &x;

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2777

#

2778

# { // Captured variable

2779

# name: "p",

2780

# type: "T*",

2781

# value: "0x00500500",

2782

# members { name: "m1", value: "3", type: "int" },

2783

# members { name: "m2", value: "7", type: "int" }

2784

# }

2785

#

2786

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2791

# name: "p",

2792

# type: "T*",

2793

# value: "0x00400400"

2794

# status { is_error: true, description { format: "unavailable" } }

2795

# }

2796

#

2797

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2798

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2799

#

2800

# Note that a null pointer should not have members.

2801

#

2802

# 5) An unnamed value:

2803

#

2804

# int* p = new int(7);

2805

#

2806

# { // Captured variable

2807

# name: "p",

2808

# value: "0x00500500",

2809

# type: "int*",

2810

# members { value: "7", type: "int" } }

2811

#

2812

# 6) An unnamed pointer where the pointee was not captured:

2813

#

2814

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2815

# int** pp = &p;

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2816

#

2817

# { // Captured variable

2818

# name: "pp",

2819

# value: "0x00500500",

2820

# type: "int**",

2821

# members {

2822

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2832

# repeat in the output multiple times can be stored once in a shared

2833

# variable table and be referenced using the `var_table_index` field. The

2834

# variables stored in the shared table are nameless and are essentially

2835

# a partition of the complete variable. To reconstruct the complete

2836

# variable, merge the referencing variable with the referenced variable.

2837

#

2838

# When using the shared variable table, the following variables:

2839

#

2840

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2841

# T* p = &x;

2842

# T& r = x;

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2843

#

2844

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

2845

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2846

# { name: "r", type="T&", var_table_index: 3 }

Thomas Coffee

2017-03-27 10:39:26 -0700

[diff] [blame]

2847

#

2848

# { // Shared variable table entry #3:

2849

# members { name: "m1", value: "3", type: "int" },

2850

# members { name: "m2", value: "7", type: "int" }

2851

# }

2852

#

2853

# Note that the pointer address is stored with the referencing variable

2854

# and not with the referenced variable. This allows the referenced variable

2855

# to be shared between pointers and references.

2856

#

2857

# The type field is optional. The debugger agent may or may not support it.

2858

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

2859

# unset. A status of a single variable only applies to that variable or

2860

# expression. The rest of breakpoint data still remains valid. Variables

2861

# might be reported in error state even when breakpoint is not in final

2862

# state.

2863

#

2864

# The message may refer to variable name with `refers_to` set to

2865

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

2866

# In either case variable value and members will be unset.

2867

#

2868

# Example of error message applied to name: `Invalid expression syntax`.

2869

#

2870

# Example of information message applied to value: `Not captured`.

2871

#

2872

# Examples of error message applied to value:

2873

#

2874

# * `Malformed string`,

2875

# * `Field f not found in class C`

2876

# * `Null pointer dereference`

2877

# The message can indicate an error or informational status, and refer to

2878

# specific parts of the containing object.

2879

# For example, the `Breakpoint.status` field can indicate an error referring

2880

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

2881

"isError": True or False, # Distinguishes errors from informational messages.

2882

"refersTo": "A String", # Reference to which the message applies.

2883

"description": { # Represents a message with parameters. # Status message text.

2884

"parameters": [ # Optional parameters to be embedded into the message.

2885

"A String",

2886

],

2887

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

2888

# `$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

2894

# is loaded. Again, $0 is very important.`

2895

# * `Please pay $$10 to use $0 instead of $1.`

2896

},

2897

},

2898

"name": "A String", # Name of the variable, if any.

2899

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

2900

# one variable can reference the same variable in the table. The

2901

# `var_table_index` field is an index into `variable_table` in Breakpoint.

2902

"value": "A String", # Simple value of the variable.

2903

"members": [ # Members contained or pointed to by the variable.

2904

# Object with schema name: Variable

2905

],

2906

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

2907

# `var_table_index`, `type` goes next to `value`. The interpretation of

2908

# a type is agent specific. It is recommended to include the dynamic type

2909

# rather than a static type of an object.

2910

},

2911

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2912

"locals": [ # Set of local variables at the stack frame location.

2913

# Note that this might not be populated for all stack frames.

2914

{ # Represents a variable or an argument possibly of a compound object type.

2915

# Note how the following variables are represented:

2916

#

2917

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

2922

#

2923

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

2932

# name: "x",

2933

# type: "T",

2934

# members { name: "m1", value: "3", type: "int" },

2935

# members { name: "m2", value: "7", type: "int" }

2936

# }

2937

#

2938

# 3) A pointer where the pointee was captured:

2939

#

2940

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2941

# T* p = &x;

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2942

#

2943

# { // Captured variable

2944

# name: "p",

2945

# type: "T*",

2946

# value: "0x00500500",

2947

# members { name: "m1", value: "3", type: "int" },

2948

# members { name: "m2", value: "7", type: "int" }

2949

# }

2950

#

2951

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

2956

# name: "p",

2957

# type: "T*",

2958

# value: "0x00400400"

2959

# status { is_error: true, description { format: "unavailable" } }

2960

# }

2961

#

2962

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2963

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2964

#

2965

# Note that a null pointer should not have members.

2966

#

2967

# 5) An unnamed value:

2968

#

2969

# int* p = new int(7);

2970

#

2971

# { // Captured variable

2972

# name: "p",

2973

# value: "0x00500500",

2974

# type: "int*",

2975

# members { value: "7", type: "int" } }

2976

#

2977

# 6) An unnamed pointer where the pointee was not captured:

2978

#

2979

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

2980

# int** pp = &p;

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

2981

#

2982

# { // Captured variable

2983

# name: "pp",

2984

# value: "0x00500500",

2985

# type: "int**",

2986

# members {

2987

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

2997

# repeat in the output multiple times can be stored once in a shared

2998

# variable table and be referenced using the `var_table_index` field. The

2999

# variables stored in the shared table are nameless and are essentially

3000

# a partition of the complete variable. To reconstruct the complete

3001

# variable, merge the referencing variable with the referenced variable.

3002

#

3003

# When using the shared variable table, the following variables:

3004

#

3005

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3006

# T* p = &x;

3007

# T& r = x;

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3008

#

3009

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

3010

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3011

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3012

#

3013

# { // Shared variable table entry #3:

3014

# members { name: "m1", value: "3", type: "int" },

3015

# members { name: "m2", value: "7", type: "int" }

3016

# }

3017

#

3018

# Note that the pointer address is stored with the referencing variable

3019

# and not with the referenced variable. This allows the referenced variable

3020

# to be shared between pointers and references.

3021

#

3022

# The type field is optional. The debugger agent may or may not support it.

3023

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

3024

# unset. A status of a single variable only applies to that variable or

3025

# expression. The rest of breakpoint data still remains valid. Variables

3026

# might be reported in error state even when breakpoint is not in final

3027

# state.

3028

#

3029

# The message may refer to variable name with `refers_to` set to

3030

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

3031

# In either case variable value and members will be unset.

3032

#

3033

# Example of error message applied to name: `Invalid expression syntax`.

3034

#

3035

# Example of information message applied to value: `Not captured`.

3036

#

3037

# Examples of error message applied to value:

3038

#

3039

# * `Malformed string`,

3040

# * `Field f not found in class C`

3041

# * `Null pointer dereference`

3042

# The message can indicate an error or informational status, and refer to

3043

# specific parts of the containing object.

3044

# For example, the `Breakpoint.status` field can indicate an error referring

3045

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

3046

"isError": True or False, # Distinguishes errors from informational messages.

3047

"refersTo": "A String", # Reference to which the message applies.

3048

"description": { # Represents a message with parameters. # Status message text.

3049

"parameters": [ # Optional parameters to be embedded into the message.

3050

"A String",

3051

],

3052

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3053

# `$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

3059

# is loaded. Again, $0 is very important.`

3060

# * `Please pay $$10 to use $0 instead of $1.`

3061

},

3062

},

3063

"name": "A String", # Name of the variable, if any.

3064

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3065

# one variable can reference the same variable in the table. The

3066

# `var_table_index` field is an index into `variable_table` in Breakpoint.

3067

"value": "A String", # Simple value of the variable.

3068

"members": [ # Members contained or pointed to by the variable.

3069

# Object with schema name: Variable

3070

],

3071

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3072

# `var_table_index`, `type` goes next to `value`. The interpretation of

3073

# a type is agent specific. It is recommended to include the dynamic type

3074

# rather than a static type of an object.

3075

},

3076

],

3077

"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]

3078

"column": 42, # Column within a line. The first column in a line as the value `1`.

3079

# Agents that do not support setting breakpoints on specific columns ignore

3080

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3081

"path": "A String", # Path to the source file within the source context of the target binary.

3082

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3083

},

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3084

},

3085

],

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3086

"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]

3087

"canaryExpireTime": "A String", # The deadline for the breakpoint to stay in CANARY_ACTIVE state. The value

3088

# is meaningless when the breakpoint is not in CANARY_ACTIVE state.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3089

"location": { # Represents a location in the source code. # Breakpoint source location.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

3090

"column": 42, # Column within a line. The first column in a line as the value `1`.

3091

# Agents that do not support setting breakpoints on specific columns ignore

3092

# this field.

Sai Cheemalapati

2017-06-06 18:46:08 -0400

[diff] [blame]

3093

"path": "A String", # Path to the source file within the source context of the target binary.

3094

"line": 42, # Line inside the file. The first line in the file has the value `1`.

3095

},

3096

"finalTime": "A String", # Time this breakpoint was finalized as seen by the server in seconds

3097

# resolution.

3098

"action": "A String", # Action that the agent should perform when the code at the

3099

# breakpoint location is hit.

Bu Sun Kim

2019-06-14 16:50:42 -0700

[diff] [blame]

3100

"expressions": [ # List of read-only expressions to evaluate at the breakpoint location.

3101

# The expressions are composed using expressions in the programming language

3102

# at the source location. If the breakpoint action is `LOG`, the evaluated

3103

# expressions are included in log statements.

3104

"A String",

3105

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3106

"isFinalState": True or False, # When true, indicates that this is a final result and the

3107

# breakpoint state will not change from here on.

3108

"evaluatedExpressions": [ # Values of evaluated expressions at breakpoint time.

3109

# The evaluated expressions appear in exactly the same order they

3110

# are listed in the `expressions` field.

3111

# The `name` field holds the original expression text, the `value` or

3112

# `members` field holds the result of the evaluated expression.

3113

# If the expression cannot be evaluated, the `status` inside the `Variable`

3114

# will indicate an error and contain the error text.

3115

{ # Represents a variable or an argument possibly of a compound object type.

3116

# Note how the following variables are represented:

3117

#

3118

# 1) A simple variable:

#

# int x = 5

#

# { name: "x", value: "5", type: "int" } // Captured variable

3123

#

3124

# 2) A compound object:

#

# struct T {

# int m1;

# int m2;

# };

# T x = { 3, 7 };

#

# { // Captured variable

3133

# name: "x",

3134

# type: "T",

3135

# members { name: "m1", value: "3", type: "int" },

3136

# members { name: "m2", value: "7", type: "int" }

3137

# }

3138

#

3139

# 3) A pointer where the pointee was captured:

3140

#

3141

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3142

# T* p = &x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3143

#

3144

# { // Captured variable

3145

# name: "p",

3146

# type: "T*",

3147

# value: "0x00500500",

3148

# members { name: "m1", value: "3", type: "int" },

3149

# members { name: "m2", value: "7", type: "int" }

3150

# }

3151

#

3152

# 4) A pointer where the pointee was not captured:

#

# T* p = new T;

#

# { // Captured variable

3157

# name: "p",

3158

# type: "T*",

3159

# value: "0x00400400"

3160

# status { is_error: true, description { format: "unavailable" } }

3161

# }

3162

#

3163

# The status should describe the reason for the missing value,

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3164

# such as `<optimized out>`, `<inaccessible>`, `<pointers limit reached>`.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3165

#

3166

# Note that a null pointer should not have members.

3167

#

3168

# 5) An unnamed value:

3169

#

3170

# int* p = new int(7);

3171

#

3172

# { // Captured variable

3173

# name: "p",

3174

# value: "0x00500500",

3175

# type: "int*",

3176

# members { value: "7", type: "int" } }

3177

#

3178

# 6) An unnamed pointer where the pointee was not captured:

3179

#

3180

# int* p = new int(7);

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3181

# int** pp = &p;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3182

#

3183

# { // Captured variable

3184

# name: "pp",

3185

# value: "0x00500500",

3186

# type: "int**",

3187

# members {

3188

# value: "0x00400400",

# type: "int*"

# status {

# is_error: true,

# description: { format: "unavailable" } }

# }

# }

# }

#

# To optimize computation, memory and network traffic, variables that

3198

# repeat in the output multiple times can be stored once in a shared

3199

# variable table and be referenced using the `var_table_index` field. The

3200

# variables stored in the shared table are nameless and are essentially

3201

# a partition of the complete variable. To reconstruct the complete

3202

# variable, merge the referencing variable with the referenced variable.

3203

#

3204

# When using the shared variable table, the following variables:

3205

#

3206

# T x = { 3, 7 };

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3207

# T* p = &x;

3208

# T& r = x;

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3209

#

3210

# { name: "x", var_table_index: 3, type: "T" } // Captured variables

3211

# { name: "p", value "0x00500500", type="T*", var_table_index: 3 }

Dan O'Meara

2020-05-01 07:42:23 -0700

[diff] [blame]

3212

# { name: "r", type="T&", var_table_index: 3 }

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3213

#

3214

# { // Shared variable table entry #3:

3215

# members { name: "m1", value: "3", type: "int" },

3216

# members { name: "m2", value: "7", type: "int" }

3217

# }

3218

#

3219

# Note that the pointer address is stored with the referencing variable

3220

# and not with the referenced variable. This allows the referenced variable

3221

# to be shared between pointers and references.

3222

#

3223

# The type field is optional. The debugger agent may or may not support it.

3224

"status": { # Represents a contextual status message. # Status associated with the variable. This field will usually stay

3225

# unset. A status of a single variable only applies to that variable or

3226

# expression. The rest of breakpoint data still remains valid. Variables

3227

# might be reported in error state even when breakpoint is not in final

3228

# state.

3229

#

3230

# The message may refer to variable name with `refers_to` set to

3231

# `VARIABLE_NAME`. Alternatively `refers_to` will be set to `VARIABLE_VALUE`.

3232

# In either case variable value and members will be unset.

3233

#

3234

# Example of error message applied to name: `Invalid expression syntax`.

3235

#

3236

# Example of information message applied to value: `Not captured`.

3237

#

3238

# Examples of error message applied to value:

3239

#

3240

# * `Malformed string`,

3241

# * `Field f not found in class C`

3242

# * `Null pointer dereference`

3243

# The message can indicate an error or informational status, and refer to

3244

# specific parts of the containing object.

3245

# For example, the `Breakpoint.status` field can indicate an error referring

3246

# to the `BREAKPOINT_SOURCE_LOCATION` with the message `Location not found`.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3247

"isError": True or False, # Distinguishes errors from informational messages.

3248

"refersTo": "A String", # Reference to which the message applies.

3249

"description": { # Represents a message with parameters. # Status message text.

3250

"parameters": [ # Optional parameters to be embedded into the message.

3251

"A String",

3252

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3253

"format": "A String", # Format template for the message. The `format` uses placeholders `$0`,

3254

# `$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

3260

# is loaded. Again, $0 is very important.`

3261

# * `Please pay $$10 to use $0 instead of $1.`

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3262

},

3263

},

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

3264

"name": "A String", # Name of the variable, if any.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3265

"varTableIndex": 42, # Reference to a variable in the shared variable table. More than

3266

# one variable can reference the same variable in the table. The

3267

# `var_table_index` field is an index into `variable_table` in Breakpoint.

Jon Wayne Parrott

2016-02-19 16:02:29 -0800

[diff] [blame]

3268

"value": "A String", # Simple value of the variable.

3269

"members": [ # Members contained or pointed to by the variable.

3270

# Object with schema name: Variable

3271

],

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3272

"type": "A String", # Variable type (e.g. `MyClass`). If the variable is split with

3273

# `var_table_index`, `type` goes next to `value`. The interpretation of

3274

# a type is agent specific. It is recommended to include the dynamic type

3275

# rather than a static type of an object.

Takashi Matsuo

2015-09-11 13:55:40 -0700

[diff] [blame]

3276

},

3277

],

3278

"id": "A String", # Breakpoint identifier, unique in the scope of the debuggee.

Sai Cheemalapati

2017-03-13 12:12:03 -0400

[diff] [blame]

3279

"condition": "A String", # Condition that triggers the breakpoint.

3280

# The condition is a compound boolean expression composed using expressions

3281

# in a programming language at the source location.

Takashi Matsuo