Commit | Line | Data |
---|---|---|
af9a82eb JG |
1 | /* |
2 | * print.c | |
3 | * | |
4 | * Babeltrace CTF Text Output Plugin Event Printing | |
5 | * | |
6 | * Copyright 2016 Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
f504043c | 7 | * Copyright 2016 Mathieu Desnoyers <mathieu.desnoyers@efficios.com> |
af9a82eb JG |
8 | * |
9 | * Author: Jérémie Galarneau <jeremie.galarneau@efficios.com> | |
10 | * | |
11 | * Permission is hereby granted, free of charge, to any person obtaining a copy | |
12 | * of this software and associated documentation files (the "Software"), to deal | |
13 | * in the Software without restriction, including without limitation the rights | |
14 | * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell | |
15 | * copies of the Software, and to permit persons to whom the Software is | |
16 | * furnished to do so, subject to the following conditions: | |
17 | * | |
18 | * The above copyright notice and this permission notice shall be included in | |
19 | * all copies or substantial portions of the Software. | |
20 | * | |
21 | * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR | |
22 | * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, | |
23 | * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE | |
24 | * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER | |
25 | * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, | |
26 | * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
27 | * SOFTWARE. | |
28 | */ | |
29 | ||
30 | #include <babeltrace/ctf-ir/event.h> | |
31 | #include <babeltrace/ctf-ir/event-class.h> | |
6a18b281 | 32 | #include <babeltrace/ctf-ir/packet.h> |
af9a82eb JG |
33 | #include <babeltrace/ctf-ir/stream.h> |
34 | #include <babeltrace/ctf-ir/stream-class.h> | |
ac0c6bdd | 35 | #include <babeltrace/ctf-ir/clock-class.h> |
6a18b281 MD |
36 | #include <babeltrace/ctf-ir/field-types.h> |
37 | #include <babeltrace/ctf-ir/fields.h> | |
1556a1af | 38 | #include <babeltrace/ctf-ir/trace.h> |
d9f65f09 PP |
39 | #include <babeltrace/graph/notification-event.h> |
40 | #include <babeltrace/graph/clock-class-priority-map.h> | |
3d9990ac | 41 | #include <babeltrace/bitfield-internal.h> |
ad96d936 | 42 | #include <babeltrace/common-internal.h> |
6a18b281 | 43 | #include <inttypes.h> |
93a4161c | 44 | #include <ctype.h> |
3228cc1d | 45 | #include "pretty.h" |
af9a82eb | 46 | |
1556a1af JG |
47 | #define NSEC_PER_SEC 1000000000LL |
48 | ||
5280f742 | 49 | #define COLOR_NAME BT_COMMON_COLOR_BOLD |
ad96d936 | 50 | #define COLOR_FIELD_NAME BT_COMMON_COLOR_FG_CYAN |
5280f742 PP |
51 | #define COLOR_RST BT_COMMON_COLOR_RESET |
52 | #define COLOR_STRING_VALUE BT_COMMON_COLOR_BOLD | |
53 | #define COLOR_NUMBER_VALUE BT_COMMON_COLOR_BOLD | |
54 | #define COLOR_ENUM_MAPPING_NAME BT_COMMON_COLOR_BOLD | |
55 | #define COLOR_UNKNOWN BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_RED | |
ad96d936 | 56 | #define COLOR_EVENT_NAME BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_MAGENTA |
5280f742 | 57 | #define COLOR_TIMESTAMP BT_COMMON_COLOR_BOLD BT_COMMON_COLOR_FG_YELLOW |
ad96d936 | 58 | |
6a18b281 MD |
59 | static inline |
60 | const char *rem_(const char *str) | |
61 | { | |
62 | if (str[0] == '_') | |
63 | return &str[1]; | |
64 | else | |
65 | return str; | |
66 | } | |
67 | ||
af9a82eb JG |
68 | struct timestamp { |
69 | int64_t real_timestamp; /* Relative to UNIX epoch. */ | |
70 | uint64_t clock_value; /* In cycles. */ | |
71 | }; | |
72 | ||
6a18b281 | 73 | static |
3228cc1d | 74 | enum bt_component_status print_field(struct pretty_component *pretty, |
2b4c4a7c JD |
75 | struct bt_ctf_field *field, bool print_names, |
76 | GQuark *filters_fields, int filter_array_len); | |
6a18b281 | 77 | |
ad96d936 | 78 | static |
3228cc1d | 79 | void print_name_equal(struct pretty_component *pretty, const char *name) |
ad96d936 | 80 | { |
3228cc1d | 81 | if (pretty->use_colors) { |
5280f742 PP |
82 | g_string_append_printf(pretty->string, "%s%s%s = ", COLOR_NAME, |
83 | name, COLOR_RST); | |
ad96d936 | 84 | } else { |
5280f742 | 85 | g_string_append_printf(pretty->string, "%s = ", name); |
ad96d936 PP |
86 | } |
87 | } | |
88 | ||
89 | static | |
3228cc1d | 90 | void print_field_name_equal(struct pretty_component *pretty, const char *name) |
ad96d936 | 91 | { |
3228cc1d | 92 | if (pretty->use_colors) { |
5280f742 PP |
93 | g_string_append_printf(pretty->string, "%s%s%s = ", |
94 | COLOR_FIELD_NAME, name, COLOR_RST); | |
ad96d936 | 95 | } else { |
5280f742 | 96 | g_string_append_printf(pretty->string, "%s = ", name); |
ad96d936 PP |
97 | } |
98 | } | |
99 | ||
af9a82eb | 100 | static |
3228cc1d | 101 | void print_timestamp_cycles(struct pretty_component *pretty, |
ac0c6bdd | 102 | struct bt_ctf_clock_class *clock_class, |
af9a82eb JG |
103 | struct bt_ctf_event *event) |
104 | { | |
1556a1af JG |
105 | int ret; |
106 | struct bt_ctf_clock_value *clock_value; | |
107 | uint64_t cycles; | |
108 | ||
ac0c6bdd | 109 | clock_value = bt_ctf_event_get_clock_value(event, clock_class); |
1556a1af | 110 | if (!clock_value) { |
5280f742 | 111 | g_string_append(pretty->string, "????????????????????"); |
1556a1af JG |
112 | return; |
113 | } | |
114 | ||
115 | ret = bt_ctf_clock_value_get_value(clock_value, &cycles); | |
116 | bt_put(clock_value); | |
117 | if (ret) { | |
5280f742 PP |
118 | // TODO: log, this is unexpected |
119 | g_string_append(pretty->string, "Error"); | |
1556a1af JG |
120 | return; |
121 | } | |
5280f742 PP |
122 | |
123 | g_string_append_printf(pretty->string, "%020" PRIu64, cycles); | |
3af83b5a | 124 | |
3228cc1d PP |
125 | if (pretty->last_cycles_timestamp != -1ULL) { |
126 | pretty->delta_cycles = cycles - pretty->last_cycles_timestamp; | |
3af83b5a | 127 | } |
3228cc1d | 128 | pretty->last_cycles_timestamp = cycles; |
af9a82eb JG |
129 | } |
130 | ||
131 | static | |
3228cc1d | 132 | void print_timestamp_wall(struct pretty_component *pretty, |
ac0c6bdd | 133 | struct bt_ctf_clock_class *clock_class, |
af9a82eb JG |
134 | struct bt_ctf_event *event) |
135 | { | |
1556a1af JG |
136 | int ret; |
137 | struct bt_ctf_clock_value *clock_value; | |
138 | int64_t ts_nsec = 0; /* add configurable offset */ | |
139 | int64_t ts_sec = 0; /* add configurable offset */ | |
140 | uint64_t ts_sec_abs, ts_nsec_abs; | |
141 | bool is_negative; | |
af9a82eb | 142 | |
ac0c6bdd | 143 | clock_value = bt_ctf_event_get_clock_value(event, clock_class); |
1556a1af | 144 | if (!clock_value) { |
5280f742 | 145 | g_string_append(pretty->string, "??:??:??.?????????"); |
1556a1af JG |
146 | return; |
147 | } | |
148 | ||
149 | ret = bt_ctf_clock_value_get_value_ns_from_epoch(clock_value, &ts_nsec); | |
150 | bt_put(clock_value); | |
151 | if (ret) { | |
5280f742 PP |
152 | // TODO: log, this is unexpected |
153 | g_string_append(pretty->string, "Error"); | |
1556a1af JG |
154 | return; |
155 | } | |
156 | ||
3228cc1d PP |
157 | if (pretty->last_real_timestamp != -1ULL) { |
158 | pretty->delta_real_timestamp = ts_nsec - pretty->last_real_timestamp; | |
3af83b5a | 159 | } |
3af83b5a | 160 | |
5280f742 | 161 | pretty->last_real_timestamp = ts_nsec; |
1556a1af JG |
162 | ts_sec += ts_nsec / NSEC_PER_SEC; |
163 | ts_nsec = ts_nsec % NSEC_PER_SEC; | |
5280f742 | 164 | |
1556a1af JG |
165 | if (ts_sec >= 0 && ts_nsec >= 0) { |
166 | is_negative = false; | |
167 | ts_sec_abs = ts_sec; | |
168 | ts_nsec_abs = ts_nsec; | |
169 | } else if (ts_sec > 0 && ts_nsec < 0) { | |
170 | is_negative = false; | |
171 | ts_sec_abs = ts_sec - 1; | |
172 | ts_nsec_abs = NSEC_PER_SEC + ts_nsec; | |
173 | } else if (ts_sec == 0 && ts_nsec < 0) { | |
174 | is_negative = true; | |
175 | ts_sec_abs = ts_sec; | |
176 | ts_nsec_abs = -ts_nsec; | |
177 | } else if (ts_sec < 0 && ts_nsec > 0) { | |
178 | is_negative = true; | |
179 | ts_sec_abs = -(ts_sec + 1); | |
180 | ts_nsec_abs = NSEC_PER_SEC - ts_nsec; | |
181 | } else if (ts_sec < 0 && ts_nsec == 0) { | |
182 | is_negative = true; | |
183 | ts_sec_abs = -ts_sec; | |
184 | ts_nsec_abs = ts_nsec; | |
185 | } else { /* (ts_sec < 0 && ts_nsec < 0) */ | |
186 | is_negative = true; | |
187 | ts_sec_abs = -ts_sec; | |
188 | ts_nsec_abs = -ts_nsec; | |
189 | } | |
190 | ||
3228cc1d | 191 | if (!pretty->options.clock_seconds) { |
1556a1af JG |
192 | struct tm tm; |
193 | time_t time_s = (time_t) ts_sec_abs; | |
194 | ||
195 | if (is_negative) { | |
5280f742 | 196 | // TODO: log instead |
1556a1af JG |
197 | fprintf(stderr, "[warning] Fallback to [sec.ns] to print negative time value. Use --clock-seconds.\n"); |
198 | goto seconds; | |
199 | } | |
200 | ||
3228cc1d | 201 | if (!pretty->options.clock_gmt) { |
1556a1af JG |
202 | struct tm *res; |
203 | ||
204 | res = localtime_r(&time_s, &tm); | |
205 | if (!res) { | |
5280f742 | 206 | // TODO: log instead |
1556a1af JG |
207 | fprintf(stderr, "[warning] Unable to get localtime.\n"); |
208 | goto seconds; | |
209 | } | |
210 | } else { | |
211 | struct tm *res; | |
212 | ||
213 | res = gmtime_r(&time_s, &tm); | |
214 | if (!res) { | |
5280f742 | 215 | // TODO: log instead |
1556a1af JG |
216 | fprintf(stderr, "[warning] Unable to get gmtime.\n"); |
217 | goto seconds; | |
218 | } | |
219 | } | |
3228cc1d | 220 | if (pretty->options.clock_date) { |
1556a1af JG |
221 | char timestr[26]; |
222 | size_t res; | |
223 | ||
224 | /* Print date and time */ | |
225 | res = strftime(timestr, sizeof(timestr), | |
226 | "%F ", &tm); | |
227 | if (!res) { | |
5280f742 | 228 | // TODO: log instead |
1556a1af JG |
229 | fprintf(stderr, "[warning] Unable to print ascii time.\n"); |
230 | goto seconds; | |
231 | } | |
5280f742 PP |
232 | |
233 | g_string_append(pretty->string, timestr); | |
1556a1af | 234 | } |
5280f742 | 235 | |
1556a1af | 236 | /* Print time in HH:MM:SS.ns */ |
5280f742 PP |
237 | g_string_append_printf(pretty->string, |
238 | "%02d:%02d:%02d.%09" PRIu64, tm.tm_hour, tm.tm_min, | |
239 | tm.tm_sec, ts_nsec_abs); | |
1556a1af JG |
240 | goto end; |
241 | } | |
242 | seconds: | |
5280f742 PP |
243 | g_string_append_printf(pretty->string, "%s%" PRId64 ".%09" PRIu64, |
244 | is_negative ? "-" : "", ts_sec_abs, ts_nsec_abs); | |
1556a1af JG |
245 | end: |
246 | return; | |
af9a82eb JG |
247 | } |
248 | ||
249 | static | |
3228cc1d | 250 | enum bt_component_status print_event_timestamp(struct pretty_component *pretty, |
d9f65f09 PP |
251 | struct bt_ctf_event *event, |
252 | struct bt_clock_class_priority_map *cc_prio_map, | |
253 | bool *start_line) | |
af9a82eb | 254 | { |
3228cc1d | 255 | bool print_names = pretty->options.print_header_field_names; |
af9a82eb | 256 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; |
6a18b281 | 257 | struct bt_ctf_stream *stream = NULL; |
1556a1af JG |
258 | struct bt_ctf_stream_class *stream_class = NULL; |
259 | struct bt_ctf_trace *trace = NULL; | |
ac0c6bdd | 260 | struct bt_ctf_clock_class *clock_class = NULL; |
af9a82eb JG |
261 | |
262 | stream = bt_ctf_event_get_stream(event); | |
263 | if (!stream) { | |
264 | ret = BT_COMPONENT_STATUS_ERROR; | |
265 | goto end; | |
266 | } | |
267 | ||
1556a1af | 268 | stream_class = bt_ctf_stream_get_class(stream); |
f504043c MD |
269 | if (!stream_class) { |
270 | ret = BT_COMPONENT_STATUS_ERROR; | |
271 | goto end; | |
272 | } | |
1556a1af | 273 | trace = bt_ctf_stream_class_get_trace(stream_class); |
f504043c MD |
274 | if (!trace) { |
275 | ret = BT_COMPONENT_STATUS_ERROR; | |
276 | goto end; | |
277 | } | |
d9f65f09 PP |
278 | |
279 | if (bt_clock_class_priority_map_get_clock_class_count(cc_prio_map) == 0) { | |
280 | /* No clock class: skip the timestamp without an error */ | |
281 | goto end; | |
282 | } | |
283 | ||
284 | clock_class = | |
285 | bt_clock_class_priority_map_get_highest_priority_clock_class( | |
286 | cc_prio_map); | |
ac0c6bdd | 287 | if (!clock_class) { |
f504043c MD |
288 | ret = BT_COMPONENT_STATUS_ERROR; |
289 | goto end; | |
290 | } | |
af9a82eb | 291 | |
ad96d936 | 292 | if (print_names) { |
3228cc1d | 293 | print_name_equal(pretty, "timestamp"); |
ad96d936 | 294 | } else { |
5280f742 | 295 | g_string_append(pretty->string, "["); |
ad96d936 | 296 | } |
3228cc1d | 297 | if (pretty->use_colors) { |
5280f742 | 298 | g_string_append(pretty->string, COLOR_TIMESTAMP); |
ad96d936 | 299 | } |
3228cc1d PP |
300 | if (pretty->options.print_timestamp_cycles) { |
301 | print_timestamp_cycles(pretty, clock_class, event); | |
af9a82eb | 302 | } else { |
3228cc1d | 303 | print_timestamp_wall(pretty, clock_class, event); |
af9a82eb | 304 | } |
3228cc1d | 305 | if (pretty->use_colors) { |
5280f742 | 306 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 307 | } |
af9a82eb | 308 | |
c3c30b08 | 309 | if (!print_names) |
5280f742 | 310 | g_string_append(pretty->string, "] "); |
c3c30b08 | 311 | |
3228cc1d | 312 | if (pretty->options.print_delta_field) { |
ad96d936 | 313 | if (print_names) { |
5280f742 | 314 | g_string_append(pretty->string, ", "); |
3228cc1d | 315 | print_name_equal(pretty, "delta"); |
ad96d936 | 316 | } else { |
5280f742 | 317 | g_string_append(pretty->string, "("); |
ad96d936 | 318 | } |
3228cc1d PP |
319 | if (pretty->options.print_timestamp_cycles) { |
320 | if (pretty->delta_cycles == -1ULL) { | |
5280f742 PP |
321 | g_string_append(pretty->string, |
322 | "+??????????\?\?) "); /* Not a trigraph. */ | |
3af83b5a | 323 | } else { |
5280f742 PP |
324 | g_string_append_printf(pretty->string, |
325 | "+%012" PRIu64, pretty->delta_cycles); | |
3af83b5a MD |
326 | } |
327 | } else { | |
3228cc1d | 328 | if (pretty->delta_real_timestamp != -1ULL) { |
3af83b5a | 329 | uint64_t delta_sec, delta_nsec, delta; |
f504043c | 330 | |
3228cc1d | 331 | delta = pretty->delta_real_timestamp; |
3af83b5a MD |
332 | delta_sec = delta / NSEC_PER_SEC; |
333 | delta_nsec = delta % NSEC_PER_SEC; | |
5280f742 PP |
334 | g_string_append_printf(pretty->string, |
335 | "+%" PRIu64 ".%09" PRIu64, | |
3af83b5a MD |
336 | delta_sec, delta_nsec); |
337 | } else { | |
5280f742 | 338 | g_string_append(pretty->string, "+?.?????????"); |
3af83b5a MD |
339 | } |
340 | } | |
341 | if (!print_names) { | |
5280f742 | 342 | g_string_append(pretty->string, ") "); |
3af83b5a MD |
343 | } |
344 | } | |
345 | *start_line = !print_names; | |
f504043c | 346 | |
af9a82eb JG |
347 | end: |
348 | bt_put(stream); | |
ac0c6bdd | 349 | bt_put(clock_class); |
1556a1af JG |
350 | bt_put(stream_class); |
351 | bt_put(trace); | |
af9a82eb JG |
352 | return ret; |
353 | } | |
354 | ||
6a18b281 | 355 | static |
3228cc1d | 356 | enum bt_component_status print_event_header(struct pretty_component *pretty, |
d9f65f09 PP |
357 | struct bt_ctf_event *event, |
358 | struct bt_clock_class_priority_map *cc_prio_map) | |
af9a82eb | 359 | { |
3228cc1d | 360 | bool print_names = pretty->options.print_header_field_names; |
6a18b281 MD |
361 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; |
362 | struct bt_ctf_event_class *event_class = NULL; | |
c3c30b08 MD |
363 | struct bt_ctf_stream_class *stream_class = NULL; |
364 | struct bt_ctf_trace *trace_class = NULL; | |
60535549 | 365 | int dom_print = 0; |
af9a82eb | 366 | |
6a18b281 MD |
367 | event_class = bt_ctf_event_get_class(event); |
368 | if (!event_class) { | |
369 | ret = BT_COMPONENT_STATUS_ERROR; | |
370 | goto end; | |
371 | } | |
c3c30b08 MD |
372 | stream_class = bt_ctf_event_class_get_stream_class(event_class); |
373 | if (!stream_class) { | |
374 | ret = BT_COMPONENT_STATUS_ERROR; | |
375 | goto end; | |
376 | } | |
377 | trace_class = bt_ctf_stream_class_get_trace(stream_class); | |
378 | if (!trace_class) { | |
379 | ret = BT_COMPONENT_STATUS_ERROR; | |
380 | goto end; | |
381 | } | |
d9f65f09 PP |
382 | ret = print_event_timestamp(pretty, event, cc_prio_map, |
383 | &pretty->start_line); | |
af9a82eb JG |
384 | if (ret != BT_COMPONENT_STATUS_OK) { |
385 | goto end; | |
386 | } | |
3228cc1d | 387 | if (pretty->options.print_trace_field) { |
c3c30b08 MD |
388 | const char *name; |
389 | ||
390 | name = bt_ctf_trace_get_name(trace_class); | |
391 | if (name) { | |
3228cc1d | 392 | if (!pretty->start_line) { |
5280f742 | 393 | g_string_append(pretty->string, ", "); |
c3c30b08 | 394 | } |
c3c30b08 | 395 | if (print_names) { |
3228cc1d | 396 | print_name_equal(pretty, "trace"); |
c3c30b08 | 397 | } |
5280f742 PP |
398 | |
399 | g_string_append(pretty->string, name); | |
400 | ||
60535549 | 401 | if (!print_names) { |
5280f742 | 402 | g_string_append(pretty->string, " "); |
60535549 | 403 | } |
c3c30b08 MD |
404 | } |
405 | } | |
3228cc1d | 406 | if (pretty->options.print_trace_hostname_field) { |
c3c30b08 MD |
407 | struct bt_value *hostname_str; |
408 | ||
409 | hostname_str = bt_ctf_trace_get_environment_field_value_by_name(trace_class, | |
410 | "hostname"); | |
411 | if (hostname_str) { | |
412 | const char *str; | |
413 | ||
3228cc1d | 414 | if (!pretty->start_line) { |
5280f742 | 415 | g_string_append(pretty->string, ", "); |
c3c30b08 | 416 | } |
c3c30b08 | 417 | if (print_names) { |
3228cc1d | 418 | print_name_equal(pretty, "trace:hostname"); |
c3c30b08 MD |
419 | } |
420 | if (bt_value_string_get(hostname_str, &str) | |
421 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 422 | g_string_append(pretty->string, str); |
c3c30b08 MD |
423 | } |
424 | bt_put(hostname_str); | |
60535549 | 425 | dom_print = 1; |
c3c30b08 MD |
426 | } |
427 | } | |
3228cc1d | 428 | if (pretty->options.print_trace_domain_field) { |
c3c30b08 MD |
429 | struct bt_value *domain_str; |
430 | ||
431 | domain_str = bt_ctf_trace_get_environment_field_value_by_name(trace_class, | |
432 | "domain"); | |
433 | if (domain_str) { | |
434 | const char *str; | |
435 | ||
3228cc1d | 436 | if (!pretty->start_line) { |
5280f742 | 437 | g_string_append(pretty->string, ", "); |
c3c30b08 | 438 | } |
c3c30b08 | 439 | if (print_names) { |
3228cc1d | 440 | print_name_equal(pretty, "trace:domain"); |
60535549 | 441 | } else if (dom_print) { |
5280f742 | 442 | g_string_append(pretty->string, ":"); |
c3c30b08 MD |
443 | } |
444 | if (bt_value_string_get(domain_str, &str) | |
445 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 446 | g_string_append(pretty->string, str); |
c3c30b08 MD |
447 | } |
448 | bt_put(domain_str); | |
60535549 | 449 | dom_print = 1; |
c3c30b08 MD |
450 | } |
451 | } | |
3228cc1d | 452 | if (pretty->options.print_trace_procname_field) { |
c3c30b08 MD |
453 | struct bt_value *procname_str; |
454 | ||
455 | procname_str = bt_ctf_trace_get_environment_field_value_by_name(trace_class, | |
456 | "procname"); | |
457 | if (procname_str) { | |
458 | const char *str; | |
459 | ||
3228cc1d | 460 | if (!pretty->start_line) { |
5280f742 | 461 | g_string_append(pretty->string, ", "); |
c3c30b08 | 462 | } |
c3c30b08 | 463 | if (print_names) { |
3228cc1d | 464 | print_name_equal(pretty, "trace:procname"); |
60535549 | 465 | } else if (dom_print) { |
5280f742 | 466 | g_string_append(pretty->string, ":"); |
c3c30b08 MD |
467 | } |
468 | if (bt_value_string_get(procname_str, &str) | |
469 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 470 | g_string_append(pretty->string, str); |
c3c30b08 MD |
471 | } |
472 | bt_put(procname_str); | |
60535549 | 473 | dom_print = 1; |
c3c30b08 MD |
474 | } |
475 | } | |
3228cc1d | 476 | if (pretty->options.print_trace_vpid_field) { |
c3c30b08 MD |
477 | struct bt_value *vpid_value; |
478 | ||
479 | vpid_value = bt_ctf_trace_get_environment_field_value_by_name(trace_class, | |
480 | "vpid"); | |
481 | if (vpid_value) { | |
482 | int64_t value; | |
483 | ||
3228cc1d | 484 | if (!pretty->start_line) { |
5280f742 | 485 | g_string_append(pretty->string, ", "); |
c3c30b08 | 486 | } |
c3c30b08 | 487 | if (print_names) { |
3228cc1d | 488 | print_name_equal(pretty, "trace:vpid"); |
60535549 | 489 | } else if (dom_print) { |
5280f742 | 490 | g_string_append(pretty->string, ":"); |
c3c30b08 MD |
491 | } |
492 | if (bt_value_integer_get(vpid_value, &value) | |
493 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 494 | g_string_append_printf(pretty->string, "(%" PRId64 ")", value); |
c3c30b08 MD |
495 | } |
496 | bt_put(vpid_value); | |
60535549 | 497 | dom_print = 1; |
c3c30b08 MD |
498 | } |
499 | } | |
3228cc1d | 500 | if (pretty->options.print_loglevel_field) { |
c3c30b08 MD |
501 | struct bt_value *loglevel_str, *loglevel_value; |
502 | ||
503 | loglevel_str = bt_ctf_event_class_get_attribute_value_by_name(event_class, | |
504 | "loglevel_string"); | |
505 | loglevel_value = bt_ctf_event_class_get_attribute_value_by_name(event_class, | |
506 | "loglevel"); | |
507 | if (loglevel_str || loglevel_value) { | |
508 | bool has_str = false; | |
509 | ||
3228cc1d | 510 | if (!pretty->start_line) { |
5280f742 | 511 | g_string_append(pretty->string, ", "); |
c3c30b08 | 512 | } |
c3c30b08 | 513 | if (print_names) { |
3228cc1d | 514 | print_name_equal(pretty, "loglevel"); |
60535549 | 515 | } else if (dom_print) { |
5280f742 | 516 | g_string_append(pretty->string, ":"); |
c3c30b08 MD |
517 | } |
518 | if (loglevel_str) { | |
519 | const char *str; | |
520 | ||
521 | if (bt_value_string_get(loglevel_str, &str) | |
522 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 523 | g_string_append(pretty->string, str); |
c3c30b08 MD |
524 | has_str = true; |
525 | } | |
526 | } | |
527 | if (loglevel_value) { | |
528 | int64_t value; | |
529 | ||
530 | if (bt_value_integer_get(loglevel_value, &value) | |
531 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 532 | g_string_append_printf(pretty->string, "%s(%" PRId64 ")", |
c3c30b08 MD |
533 | has_str ? " " : "", value); |
534 | } | |
535 | } | |
536 | bt_put(loglevel_str); | |
537 | bt_put(loglevel_value); | |
60535549 | 538 | dom_print = 1; |
c3c30b08 MD |
539 | } |
540 | } | |
3228cc1d | 541 | if (pretty->options.print_emf_field) { |
c3c30b08 MD |
542 | struct bt_value *uri_str; |
543 | ||
544 | uri_str = bt_ctf_event_class_get_attribute_value_by_name(event_class, | |
545 | "model.emf.uri"); | |
546 | if (uri_str) { | |
3228cc1d | 547 | if (!pretty->start_line) { |
5280f742 | 548 | g_string_append(pretty->string, ", "); |
c3c30b08 | 549 | } |
c3c30b08 | 550 | if (print_names) { |
3228cc1d | 551 | print_name_equal(pretty, "model.emf.uri"); |
60535549 | 552 | } else if (dom_print) { |
5280f742 | 553 | g_string_append(pretty->string, ":"); |
c3c30b08 MD |
554 | } |
555 | if (uri_str) { | |
556 | const char *str; | |
557 | ||
558 | if (bt_value_string_get(uri_str, &str) | |
559 | == BT_VALUE_STATUS_OK) { | |
5280f742 | 560 | g_string_append(pretty->string, str); |
c3c30b08 MD |
561 | } |
562 | } | |
563 | bt_put(uri_str); | |
60535549 | 564 | dom_print = 1; |
c3c30b08 MD |
565 | } |
566 | } | |
60535549 | 567 | if (dom_print && !print_names) { |
5280f742 | 568 | g_string_append(pretty->string, " "); |
60535549 | 569 | } |
3228cc1d | 570 | if (!pretty->start_line) { |
5280f742 | 571 | g_string_append(pretty->string, ", "); |
c3c30b08 | 572 | } |
3228cc1d | 573 | pretty->start_line = true; |
6a18b281 | 574 | if (print_names) { |
3228cc1d | 575 | print_name_equal(pretty, "name"); |
ad96d936 | 576 | } |
3228cc1d | 577 | if (pretty->use_colors) { |
5280f742 | 578 | g_string_append(pretty->string, COLOR_EVENT_NAME); |
6a18b281 | 579 | } |
5280f742 | 580 | g_string_append(pretty->string, bt_ctf_event_class_get_name(event_class)); |
3228cc1d | 581 | if (pretty->use_colors) { |
5280f742 | 582 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 583 | } |
60535549 | 584 | if (!print_names) { |
5280f742 | 585 | g_string_append(pretty->string, ": "); |
60535549 | 586 | } else { |
5280f742 | 587 | g_string_append(pretty->string, ", "); |
60535549 | 588 | } |
af9a82eb | 589 | end: |
c3c30b08 MD |
590 | bt_put(trace_class); |
591 | bt_put(stream_class); | |
6a18b281 MD |
592 | bt_put(event_class); |
593 | return ret; | |
594 | } | |
595 | ||
596 | static | |
3228cc1d | 597 | enum bt_component_status print_integer(struct pretty_component *pretty, |
6a18b281 MD |
598 | struct bt_ctf_field *field) |
599 | { | |
600 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
601 | struct bt_ctf_field_type *field_type = NULL; | |
602 | enum bt_ctf_integer_base base; | |
603 | enum bt_ctf_string_encoding encoding; | |
604 | int signedness; | |
605 | union { | |
606 | uint64_t u; | |
607 | int64_t s; | |
608 | } v; | |
ad96d936 | 609 | bool rst_color = false; |
6a18b281 MD |
610 | |
611 | field_type = bt_ctf_field_get_type(field); | |
612 | if (!field_type) { | |
613 | ret = BT_COMPONENT_STATUS_ERROR; | |
614 | goto end; | |
615 | } | |
616 | signedness = bt_ctf_field_type_integer_get_signed(field_type); | |
617 | if (signedness < 0) { | |
618 | ret = BT_COMPONENT_STATUS_ERROR; | |
619 | goto end; | |
620 | } | |
621 | if (!signedness) { | |
622 | if (bt_ctf_field_unsigned_integer_get_value(field, &v.u) < 0) { | |
623 | ret = BT_COMPONENT_STATUS_ERROR; | |
624 | goto end; | |
625 | } | |
626 | } else { | |
627 | if (bt_ctf_field_signed_integer_get_value(field, &v.s) < 0) { | |
628 | ret = BT_COMPONENT_STATUS_ERROR; | |
629 | goto end; | |
630 | } | |
631 | } | |
632 | ||
633 | encoding = bt_ctf_field_type_integer_get_encoding(field_type); | |
634 | switch (encoding) { | |
635 | case BT_CTF_STRING_ENCODING_UTF8: | |
636 | case BT_CTF_STRING_ENCODING_ASCII: | |
5280f742 | 637 | g_string_append_c(pretty->tmp_string, (int) v.u); |
6a18b281 MD |
638 | goto end; |
639 | case BT_CTF_STRING_ENCODING_NONE: | |
640 | case BT_CTF_STRING_ENCODING_UNKNOWN: | |
641 | break; | |
642 | default: | |
643 | ret = BT_COMPONENT_STATUS_ERROR; | |
644 | goto end; | |
645 | } | |
646 | ||
3228cc1d | 647 | if (pretty->use_colors) { |
5280f742 | 648 | g_string_append(pretty->string, COLOR_NUMBER_VALUE); |
ad96d936 PP |
649 | rst_color = true; |
650 | } | |
651 | ||
6a18b281 MD |
652 | base = bt_ctf_field_type_integer_get_base(field_type); |
653 | switch (base) { | |
654 | case BT_CTF_INTEGER_BASE_BINARY: | |
655 | { | |
656 | int bitnr, len; | |
657 | ||
658 | len = bt_ctf_field_type_integer_get_size(field_type); | |
659 | if (len < 0) { | |
660 | ret = BT_COMPONENT_STATUS_ERROR; | |
661 | goto end; | |
662 | } | |
5280f742 | 663 | g_string_append(pretty->string, "0b"); |
6a18b281 MD |
664 | v.u = _bt_piecewise_lshift(v.u, 64 - len); |
665 | for (bitnr = 0; bitnr < len; bitnr++) { | |
5280f742 | 666 | g_string_append_printf(pretty->string, "%u", (v.u & (1ULL << 63)) ? 1 : 0); |
6a18b281 MD |
667 | v.u = _bt_piecewise_lshift(v.u, 1); |
668 | } | |
669 | break; | |
670 | } | |
671 | case BT_CTF_INTEGER_BASE_OCTAL: | |
672 | { | |
673 | if (signedness) { | |
674 | int len; | |
675 | ||
676 | len = bt_ctf_field_type_integer_get_size(field_type); | |
677 | if (len < 0) { | |
678 | ret = BT_COMPONENT_STATUS_ERROR; | |
679 | goto end; | |
680 | } | |
681 | if (len < 64) { | |
682 | size_t rounded_len; | |
683 | ||
684 | assert(len != 0); | |
685 | /* Round length to the nearest 3-bit */ | |
686 | rounded_len = (((len - 1) / 3) + 1) * 3; | |
687 | v.u &= ((uint64_t) 1 << rounded_len) - 1; | |
688 | } | |
689 | } | |
690 | ||
5280f742 | 691 | g_string_append_printf(pretty->string, "0%" PRIo64, v.u); |
6a18b281 MD |
692 | break; |
693 | } | |
694 | case BT_CTF_INTEGER_BASE_DECIMAL: | |
695 | if (!signedness) { | |
5280f742 | 696 | g_string_append_printf(pretty->string, "%" PRIu64, v.u); |
6a18b281 | 697 | } else { |
5280f742 | 698 | g_string_append_printf(pretty->string, "%" PRId64, v.s); |
6a18b281 MD |
699 | } |
700 | break; | |
701 | case BT_CTF_INTEGER_BASE_HEXADECIMAL: | |
702 | { | |
703 | int len; | |
704 | ||
705 | len = bt_ctf_field_type_integer_get_size(field_type); | |
706 | if (len < 0) { | |
707 | ret = BT_COMPONENT_STATUS_ERROR; | |
708 | goto end; | |
709 | } | |
710 | if (len < 64) { | |
711 | /* Round length to the nearest nibble */ | |
712 | uint8_t rounded_len = ((len + 3) & ~0x3); | |
713 | ||
714 | v.u &= ((uint64_t) 1 << rounded_len) - 1; | |
715 | } | |
716 | ||
5280f742 | 717 | g_string_append_printf(pretty->string, "0x%" PRIX64, v.u); |
6a18b281 MD |
718 | break; |
719 | } | |
720 | default: | |
721 | ret = BT_COMPONENT_STATUS_ERROR; | |
722 | goto end; | |
723 | } | |
724 | end: | |
ad96d936 | 725 | if (rst_color) { |
5280f742 | 726 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 727 | } |
6a18b281 MD |
728 | bt_put(field_type); |
729 | return ret; | |
730 | } | |
731 | ||
93a4161c | 732 | static |
3228cc1d | 733 | void print_escape_string(struct pretty_component *pretty, const char *str) |
93a4161c JD |
734 | { |
735 | int i; | |
736 | ||
5280f742 PP |
737 | g_string_append_c(pretty->string, '"'); |
738 | ||
93a4161c JD |
739 | for (i = 0; i < strlen(str); i++) { |
740 | /* Escape sequences not recognized by iscntrl(). */ | |
741 | switch (str[i]) { | |
742 | case '\\': | |
5280f742 | 743 | g_string_append(pretty->string, "\\\\"); |
93a4161c JD |
744 | continue; |
745 | case '\'': | |
5280f742 | 746 | g_string_append(pretty->string, "\\\'"); |
93a4161c JD |
747 | continue; |
748 | case '\"': | |
5280f742 | 749 | g_string_append(pretty->string, "\\\""); |
93a4161c JD |
750 | continue; |
751 | case '\?': | |
5280f742 | 752 | g_string_append(pretty->string, "\\\?"); |
93a4161c JD |
753 | continue; |
754 | } | |
755 | ||
756 | /* Standard characters. */ | |
757 | if (!iscntrl(str[i])) { | |
5280f742 | 758 | g_string_append_c(pretty->string, str[i]); |
93a4161c JD |
759 | continue; |
760 | } | |
761 | ||
762 | switch (str[i]) { | |
763 | case '\0': | |
5280f742 | 764 | g_string_append(pretty->string, "\\0"); |
93a4161c JD |
765 | break; |
766 | case '\a': | |
5280f742 | 767 | g_string_append(pretty->string, "\\a"); |
93a4161c JD |
768 | break; |
769 | case '\b': | |
5280f742 | 770 | g_string_append(pretty->string, "\\b"); |
93a4161c JD |
771 | break; |
772 | case '\e': | |
5280f742 | 773 | g_string_append(pretty->string, "\\e"); |
93a4161c JD |
774 | break; |
775 | case '\f': | |
5280f742 | 776 | g_string_append(pretty->string, "\\f"); |
93a4161c JD |
777 | break; |
778 | case '\n': | |
5280f742 | 779 | g_string_append(pretty->string, "\\n"); |
93a4161c JD |
780 | break; |
781 | case '\r': | |
5280f742 | 782 | g_string_append(pretty->string, "\\r"); |
93a4161c JD |
783 | break; |
784 | case '\t': | |
5280f742 | 785 | g_string_append(pretty->string, "\\t"); |
93a4161c JD |
786 | break; |
787 | case '\v': | |
5280f742 | 788 | g_string_append(pretty->string, "\\v"); |
93a4161c JD |
789 | break; |
790 | default: | |
791 | /* Unhandled control-sequence, print as hex. */ | |
5280f742 | 792 | g_string_append_printf(pretty->string, "\\x%02x", str[i]); |
93a4161c JD |
793 | break; |
794 | } | |
795 | } | |
5280f742 PP |
796 | |
797 | g_string_append_c(pretty->string, '"'); | |
93a4161c JD |
798 | } |
799 | ||
6a18b281 | 800 | static |
3228cc1d | 801 | enum bt_component_status print_enum(struct pretty_component *pretty, |
6a18b281 MD |
802 | struct bt_ctf_field *field) |
803 | { | |
804 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
805 | struct bt_ctf_field *container_field = NULL; | |
96e8f959 MD |
806 | struct bt_ctf_field_type *enumeration_field_type = NULL; |
807 | struct bt_ctf_field_type *container_field_type = NULL; | |
808 | struct bt_ctf_field_type_enumeration_mapping_iterator *iter = NULL; | |
809 | int nr_mappings = 0; | |
810 | int is_signed; | |
811 | ||
812 | enumeration_field_type = bt_ctf_field_get_type(field); | |
813 | if (!enumeration_field_type) { | |
814 | ret = BT_COMPONENT_STATUS_ERROR; | |
815 | goto end; | |
816 | } | |
6a18b281 MD |
817 | container_field = bt_ctf_field_enumeration_get_container(field); |
818 | if (!container_field) { | |
819 | ret = BT_COMPONENT_STATUS_ERROR; | |
820 | goto end; | |
821 | } | |
96e8f959 MD |
822 | container_field_type = bt_ctf_field_get_type(container_field); |
823 | if (!container_field_type) { | |
824 | ret = BT_COMPONENT_STATUS_ERROR; | |
825 | goto end; | |
826 | } | |
827 | is_signed = bt_ctf_field_type_integer_get_signed(container_field_type); | |
828 | if (is_signed < 0) { | |
829 | ret = BT_COMPONENT_STATUS_ERROR; | |
830 | goto end; | |
831 | } | |
832 | if (is_signed) { | |
833 | int64_t value; | |
834 | ||
835 | if (bt_ctf_field_signed_integer_get_value(container_field, | |
836 | &value)) { | |
837 | ret = BT_COMPONENT_STATUS_ERROR; | |
838 | goto end; | |
839 | } | |
840 | iter = bt_ctf_field_type_enumeration_find_mappings_by_signed_value( | |
841 | enumeration_field_type, value); | |
6a18b281 | 842 | } else { |
96e8f959 MD |
843 | uint64_t value; |
844 | ||
845 | if (bt_ctf_field_unsigned_integer_get_value(container_field, | |
846 | &value)) { | |
847 | ret = BT_COMPONENT_STATUS_ERROR; | |
848 | goto end; | |
849 | } | |
850 | iter = bt_ctf_field_type_enumeration_find_mappings_by_unsigned_value( | |
851 | enumeration_field_type, value); | |
852 | } | |
853 | if (!iter) { | |
854 | ret = BT_COMPONENT_STATUS_ERROR; | |
855 | goto end; | |
856 | } | |
5280f742 | 857 | g_string_append(pretty->string, "( "); |
96e8f959 MD |
858 | for (;;) { |
859 | const char *mapping_name; | |
860 | ||
861 | if (bt_ctf_field_type_enumeration_mapping_iterator_get_signed( | |
862 | iter, &mapping_name, NULL, NULL) < 0) { | |
863 | ret = BT_COMPONENT_STATUS_ERROR; | |
864 | goto end; | |
865 | } | |
866 | if (nr_mappings++) | |
5280f742 | 867 | g_string_append(pretty->string, ", "); |
3228cc1d | 868 | if (pretty->use_colors) { |
5280f742 | 869 | g_string_append(pretty->string, COLOR_ENUM_MAPPING_NAME); |
ad96d936 | 870 | } |
3228cc1d PP |
871 | print_escape_string(pretty, mapping_name); |
872 | if (pretty->use_colors) { | |
5280f742 | 873 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 874 | } |
96e8f959 MD |
875 | if (bt_ctf_field_type_enumeration_mapping_iterator_next(iter) < 0) { |
876 | break; | |
877 | } | |
878 | } | |
879 | if (!nr_mappings) { | |
3228cc1d | 880 | if (pretty->use_colors) { |
5280f742 | 881 | g_string_append(pretty->string, COLOR_UNKNOWN); |
ad96d936 | 882 | } |
5280f742 | 883 | g_string_append(pretty->string, "<unknown>"); |
3228cc1d | 884 | if (pretty->use_colors) { |
5280f742 | 885 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 886 | } |
6a18b281 | 887 | } |
5280f742 | 888 | g_string_append(pretty->string, " : container = "); |
3228cc1d | 889 | ret = print_integer(pretty, container_field); |
6a18b281 MD |
890 | if (ret != BT_COMPONENT_STATUS_OK) { |
891 | goto end; | |
892 | } | |
5280f742 | 893 | g_string_append(pretty->string, " )"); |
6a18b281 | 894 | end: |
96e8f959 MD |
895 | bt_put(iter); |
896 | bt_put(container_field_type); | |
6a18b281 | 897 | bt_put(container_field); |
96e8f959 | 898 | bt_put(enumeration_field_type); |
6a18b281 MD |
899 | return ret; |
900 | } | |
901 | ||
2b4c4a7c | 902 | static |
3228cc1d | 903 | int filter_field_name(struct pretty_component *pretty, const char *field_name, |
2b4c4a7c JD |
904 | GQuark *filter_fields, int filter_array_len) |
905 | { | |
906 | int i; | |
907 | GQuark field_quark = g_quark_try_string(field_name); | |
908 | ||
3228cc1d | 909 | if (!field_quark || pretty->options.verbose) { |
2b4c4a7c JD |
910 | return 1; |
911 | } | |
912 | ||
913 | for (i = 0; i < filter_array_len; i++) { | |
914 | if (field_quark == filter_fields[i]) { | |
915 | return 0; | |
916 | } | |
917 | } | |
918 | return 1; | |
919 | } | |
920 | ||
6a18b281 | 921 | static |
3228cc1d | 922 | enum bt_component_status print_struct_field(struct pretty_component *pretty, |
6a18b281 MD |
923 | struct bt_ctf_field *_struct, |
924 | struct bt_ctf_field_type *struct_type, | |
2b4c4a7c JD |
925 | int i, bool print_names, int *nr_printed_fields, |
926 | GQuark *filter_fields, int filter_array_len) | |
6a18b281 MD |
927 | { |
928 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
929 | const char *field_name; | |
930 | struct bt_ctf_field *field = NULL; | |
931 | struct bt_ctf_field_type *field_type = NULL;; | |
932 | ||
933 | field = bt_ctf_field_structure_get_field_by_index(_struct, i); | |
934 | if (!field) { | |
935 | ret = BT_COMPONENT_STATUS_ERROR; | |
936 | goto end; | |
937 | } | |
938 | if (bt_ctf_field_type_structure_get_field(struct_type, | |
939 | &field_name, &field_type, i) < 0) { | |
940 | ret = BT_COMPONENT_STATUS_ERROR; | |
941 | goto end; | |
942 | } | |
943 | ||
3228cc1d | 944 | if (filter_fields && !filter_field_name(pretty, field_name, |
2b4c4a7c JD |
945 | filter_fields, filter_array_len)) { |
946 | ret = BT_COMPONENT_STATUS_OK; | |
947 | goto end; | |
948 | } | |
949 | ||
950 | if (*nr_printed_fields > 0) { | |
5280f742 | 951 | g_string_append(pretty->string, ", "); |
6a18b281 | 952 | } else { |
5280f742 | 953 | g_string_append(pretty->string, " "); |
6a18b281 MD |
954 | } |
955 | if (print_names) { | |
3228cc1d | 956 | print_field_name_equal(pretty, rem_(field_name)); |
6a18b281 | 957 | } |
3228cc1d | 958 | ret = print_field(pretty, field, print_names, NULL, 0); |
2b4c4a7c | 959 | *nr_printed_fields += 1; |
6a18b281 MD |
960 | end: |
961 | bt_put(field_type); | |
962 | bt_put(field); | |
963 | return ret; | |
964 | } | |
965 | ||
966 | static | |
3228cc1d | 967 | enum bt_component_status print_struct(struct pretty_component *pretty, |
2b4c4a7c JD |
968 | struct bt_ctf_field *_struct, bool print_names, |
969 | GQuark *filter_fields, int filter_array_len) | |
6a18b281 MD |
970 | { |
971 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
972 | struct bt_ctf_field_type *struct_type = NULL; | |
2b4c4a7c | 973 | int nr_fields, i, nr_printed_fields; |
6a18b281 MD |
974 | |
975 | struct_type = bt_ctf_field_get_type(_struct); | |
976 | if (!struct_type) { | |
977 | ret = BT_COMPONENT_STATUS_ERROR; | |
978 | goto end; | |
979 | } | |
980 | nr_fields = bt_ctf_field_type_structure_get_field_count(struct_type); | |
981 | if (nr_fields < 0) { | |
982 | ret = BT_COMPONENT_STATUS_ERROR; | |
983 | goto end; | |
984 | } | |
5280f742 | 985 | g_string_append(pretty->string, "{"); |
3228cc1d | 986 | pretty->depth++; |
2b4c4a7c | 987 | nr_printed_fields = 0; |
6a18b281 | 988 | for (i = 0; i < nr_fields; i++) { |
3228cc1d | 989 | ret = print_struct_field(pretty, _struct, struct_type, i, |
2b4c4a7c JD |
990 | print_names, &nr_printed_fields, filter_fields, |
991 | filter_array_len); | |
6a18b281 MD |
992 | if (ret != BT_COMPONENT_STATUS_OK) { |
993 | goto end; | |
994 | } | |
995 | } | |
3228cc1d | 996 | pretty->depth--; |
5280f742 | 997 | g_string_append(pretty->string, " }"); |
6a18b281 MD |
998 | end: |
999 | bt_put(struct_type); | |
1000 | return ret; | |
1001 | } | |
1002 | ||
1003 | static | |
3228cc1d | 1004 | enum bt_component_status print_array_field(struct pretty_component *pretty, |
6a18b281 MD |
1005 | struct bt_ctf_field *array, uint64_t i, |
1006 | bool is_string, bool print_names) | |
1007 | { | |
1008 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1009 | struct bt_ctf_field *field = NULL; | |
1010 | ||
1011 | if (!is_string) { | |
1012 | if (i != 0) { | |
5280f742 | 1013 | g_string_append(pretty->string, ", "); |
6a18b281 | 1014 | } else { |
5280f742 | 1015 | g_string_append(pretty->string, " "); |
6a18b281 | 1016 | } |
60535549 | 1017 | if (print_names) { |
5280f742 | 1018 | g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i); |
60535549 | 1019 | } |
6a18b281 MD |
1020 | } |
1021 | field = bt_ctf_field_array_get_field(array, i); | |
1022 | if (!field) { | |
1023 | ret = BT_COMPONENT_STATUS_ERROR; | |
1024 | goto end; | |
1025 | } | |
3228cc1d | 1026 | ret = print_field(pretty, field, print_names, NULL, 0); |
6a18b281 MD |
1027 | end: |
1028 | bt_put(field); | |
1029 | return ret; | |
1030 | } | |
1031 | ||
1032 | static | |
3228cc1d | 1033 | enum bt_component_status print_array(struct pretty_component *pretty, |
6a18b281 MD |
1034 | struct bt_ctf_field *array, bool print_names) |
1035 | { | |
1036 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1037 | struct bt_ctf_field_type *array_type = NULL, *field_type = NULL; | |
1487a16a | 1038 | enum bt_ctf_field_type_id type_id; |
6a18b281 MD |
1039 | int64_t len; |
1040 | uint64_t i; | |
1041 | bool is_string = false; | |
1042 | ||
1043 | array_type = bt_ctf_field_get_type(array); | |
1044 | if (!array_type) { | |
1045 | ret = BT_COMPONENT_STATUS_ERROR; | |
1046 | goto end; | |
1047 | } | |
1048 | field_type = bt_ctf_field_type_array_get_element_type(array_type); | |
1049 | if (!field_type) { | |
1050 | ret = BT_COMPONENT_STATUS_ERROR; | |
1051 | goto end; | |
1052 | } | |
1053 | len = bt_ctf_field_type_array_get_length(array_type); | |
1054 | if (len < 0) { | |
1055 | ret = BT_COMPONENT_STATUS_ERROR; | |
1056 | goto end; | |
1057 | } | |
1058 | type_id = bt_ctf_field_type_get_type_id(field_type); | |
1487a16a | 1059 | if (type_id == BT_CTF_FIELD_TYPE_ID_INTEGER) { |
6a18b281 MD |
1060 | enum bt_ctf_string_encoding encoding; |
1061 | ||
1062 | encoding = bt_ctf_field_type_integer_get_encoding(field_type); | |
1063 | if (encoding == BT_CTF_STRING_ENCODING_UTF8 | |
1064 | || encoding == BT_CTF_STRING_ENCODING_ASCII) { | |
1065 | int integer_len, integer_alignment; | |
1066 | ||
1067 | integer_len = bt_ctf_field_type_integer_get_size(field_type); | |
1068 | if (integer_len < 0) { | |
1069 | return BT_COMPONENT_STATUS_ERROR; | |
1070 | } | |
1071 | integer_alignment = bt_ctf_field_type_get_alignment(field_type); | |
1072 | if (integer_alignment < 0) { | |
1073 | return BT_COMPONENT_STATUS_ERROR; | |
1074 | } | |
1075 | if (integer_len == CHAR_BIT | |
1076 | && integer_alignment == CHAR_BIT) { | |
1077 | is_string = true; | |
1078 | } | |
1079 | } | |
1080 | } | |
1081 | ||
1082 | if (is_string) { | |
5280f742 | 1083 | g_string_assign(pretty->tmp_string, ""); |
6a18b281 | 1084 | } else { |
5280f742 | 1085 | g_string_append(pretty->string, "["); |
6a18b281 MD |
1086 | } |
1087 | ||
3228cc1d | 1088 | pretty->depth++; |
6a18b281 | 1089 | for (i = 0; i < len; i++) { |
3228cc1d | 1090 | ret = print_array_field(pretty, array, i, is_string, print_names); |
6a18b281 MD |
1091 | if (ret != BT_COMPONENT_STATUS_OK) { |
1092 | goto end; | |
1093 | } | |
1094 | } | |
3228cc1d | 1095 | pretty->depth--; |
6a18b281 MD |
1096 | |
1097 | if (is_string) { | |
3228cc1d | 1098 | if (pretty->use_colors) { |
5280f742 | 1099 | g_string_append(pretty->string, COLOR_STRING_VALUE); |
ad96d936 | 1100 | } |
5280f742 | 1101 | print_escape_string(pretty, pretty->tmp_string->str); |
3228cc1d | 1102 | if (pretty->use_colors) { |
5280f742 | 1103 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 1104 | } |
6a18b281 | 1105 | } else { |
5280f742 | 1106 | g_string_append(pretty->string, " ]"); |
6a18b281 MD |
1107 | } |
1108 | end: | |
1109 | bt_put(field_type); | |
1110 | bt_put(array_type); | |
1111 | return ret; | |
1112 | } | |
1113 | ||
1114 | static | |
3228cc1d | 1115 | enum bt_component_status print_sequence_field(struct pretty_component *pretty, |
6a18b281 MD |
1116 | struct bt_ctf_field *seq, uint64_t i, |
1117 | bool is_string, bool print_names) | |
1118 | { | |
1119 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1120 | struct bt_ctf_field *field = NULL; | |
1121 | ||
1122 | if (!is_string) { | |
1123 | if (i != 0) { | |
5280f742 | 1124 | g_string_append(pretty->string, ", "); |
6a18b281 | 1125 | } else { |
5280f742 | 1126 | g_string_append(pretty->string, " "); |
6a18b281 | 1127 | } |
60535549 | 1128 | if (print_names) { |
5280f742 | 1129 | g_string_append_printf(pretty->string, "[%" PRIu64 "] = ", i); |
60535549 | 1130 | } |
6a18b281 MD |
1131 | } |
1132 | field = bt_ctf_field_sequence_get_field(seq, i); | |
1133 | if (!field) { | |
1134 | ret = BT_COMPONENT_STATUS_ERROR; | |
1135 | goto end; | |
1136 | } | |
3228cc1d | 1137 | ret = print_field(pretty, field, print_names, NULL, 0); |
6a18b281 MD |
1138 | end: |
1139 | bt_put(field); | |
1140 | return ret; | |
1141 | } | |
1142 | ||
1143 | static | |
3228cc1d | 1144 | enum bt_component_status print_sequence(struct pretty_component *pretty, |
6a18b281 MD |
1145 | struct bt_ctf_field *seq, bool print_names) |
1146 | { | |
1147 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1148 | struct bt_ctf_field_type *seq_type = NULL, *field_type = NULL; | |
1149 | struct bt_ctf_field *length_field = NULL; | |
1487a16a | 1150 | enum bt_ctf_field_type_id type_id; |
6a18b281 MD |
1151 | uint64_t len; |
1152 | uint64_t i; | |
1153 | bool is_string = false; | |
1154 | ||
1155 | seq_type = bt_ctf_field_get_type(seq); | |
1156 | if (!seq_type) { | |
1157 | ret = BT_COMPONENT_STATUS_ERROR; | |
1158 | goto end; | |
1159 | } | |
1160 | length_field = bt_ctf_field_sequence_get_length(seq); | |
1161 | if (!length_field) { | |
1162 | ret = BT_COMPONENT_STATUS_ERROR; | |
1163 | goto end; | |
1164 | } | |
1165 | if (bt_ctf_field_unsigned_integer_get_value(length_field, &len) < 0) { | |
1166 | ret = BT_COMPONENT_STATUS_ERROR; | |
1167 | goto end; | |
1168 | } | |
1169 | field_type = bt_ctf_field_type_sequence_get_element_type(seq_type); | |
1170 | if (!field_type) { | |
1171 | ret = BT_COMPONENT_STATUS_ERROR; | |
1172 | goto end; | |
1173 | } | |
1174 | type_id = bt_ctf_field_type_get_type_id(field_type); | |
1487a16a | 1175 | if (type_id == BT_CTF_FIELD_TYPE_ID_INTEGER) { |
6a18b281 MD |
1176 | enum bt_ctf_string_encoding encoding; |
1177 | ||
1178 | encoding = bt_ctf_field_type_integer_get_encoding(field_type); | |
1179 | if (encoding == BT_CTF_STRING_ENCODING_UTF8 | |
1180 | || encoding == BT_CTF_STRING_ENCODING_ASCII) { | |
1181 | int integer_len, integer_alignment; | |
1182 | ||
1183 | integer_len = bt_ctf_field_type_integer_get_size(field_type); | |
1184 | if (integer_len < 0) { | |
1185 | ret = BT_COMPONENT_STATUS_ERROR; | |
1186 | goto end; | |
1187 | } | |
1188 | integer_alignment = bt_ctf_field_type_get_alignment(field_type); | |
1189 | if (integer_alignment < 0) { | |
1190 | ret = BT_COMPONENT_STATUS_ERROR; | |
1191 | goto end; | |
1192 | } | |
1193 | if (integer_len == CHAR_BIT | |
1194 | && integer_alignment == CHAR_BIT) { | |
1195 | is_string = true; | |
1196 | } | |
1197 | } | |
1198 | } | |
1199 | ||
1200 | if (is_string) { | |
5280f742 | 1201 | g_string_assign(pretty->tmp_string, ""); |
6a18b281 | 1202 | } else { |
5280f742 | 1203 | g_string_append(pretty->string, "["); |
6a18b281 MD |
1204 | } |
1205 | ||
3228cc1d | 1206 | pretty->depth++; |
6a18b281 | 1207 | for (i = 0; i < len; i++) { |
3228cc1d | 1208 | ret = print_sequence_field(pretty, seq, i, |
6a18b281 MD |
1209 | is_string, print_names); |
1210 | if (ret != BT_COMPONENT_STATUS_OK) { | |
1211 | goto end; | |
1212 | } | |
1213 | } | |
3228cc1d | 1214 | pretty->depth--; |
6a18b281 MD |
1215 | |
1216 | if (is_string) { | |
3228cc1d | 1217 | if (pretty->use_colors) { |
5280f742 | 1218 | g_string_append(pretty->string, COLOR_STRING_VALUE); |
ad96d936 | 1219 | } |
5280f742 | 1220 | print_escape_string(pretty, pretty->tmp_string->str); |
3228cc1d | 1221 | if (pretty->use_colors) { |
5280f742 | 1222 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 1223 | } |
6a18b281 | 1224 | } else { |
5280f742 | 1225 | g_string_append(pretty->string, " ]"); |
6a18b281 MD |
1226 | } |
1227 | end: | |
1228 | bt_put(length_field); | |
1229 | bt_put(field_type); | |
1230 | bt_put(seq_type); | |
1231 | return ret; | |
1232 | } | |
1233 | ||
1234 | static | |
3228cc1d | 1235 | enum bt_component_status print_variant(struct pretty_component *pretty, |
6a18b281 MD |
1236 | struct bt_ctf_field *variant, bool print_names) |
1237 | { | |
1238 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1239 | struct bt_ctf_field *field = NULL; | |
1240 | ||
1241 | field = bt_ctf_field_variant_get_current_field(variant); | |
1242 | if (!field) { | |
1243 | ret = BT_COMPONENT_STATUS_ERROR; | |
1244 | goto end; | |
1245 | } | |
5280f742 | 1246 | g_string_append(pretty->string, "{ "); |
3228cc1d | 1247 | pretty->depth++; |
6a18b281 | 1248 | if (print_names) { |
e0f15669 | 1249 | int iter_ret; |
6a18b281 MD |
1250 | struct bt_ctf_field *tag_field = NULL; |
1251 | const char *tag_choice; | |
e0f15669 | 1252 | struct bt_ctf_field_type_enumeration_mapping_iterator *iter; |
6a18b281 MD |
1253 | |
1254 | tag_field = bt_ctf_field_variant_get_tag(variant); | |
1255 | if (!tag_field) { | |
1256 | ret = BT_COMPONENT_STATUS_ERROR; | |
1257 | goto end; | |
1258 | } | |
e0f15669 JG |
1259 | |
1260 | iter = bt_ctf_field_enumeration_get_mappings(tag_field); | |
1261 | if (!iter) { | |
1262 | bt_put(tag_field); | |
1263 | ret = BT_COMPONENT_STATUS_ERROR; | |
1264 | goto end; | |
1265 | } | |
1266 | ||
1267 | iter_ret = | |
8803be2a JG |
1268 | bt_ctf_field_type_enumeration_mapping_iterator_get_signed( |
1269 | iter, &tag_choice, NULL, NULL); | |
e0f15669 JG |
1270 | if (iter_ret) { |
1271 | bt_put(iter); | |
6a18b281 MD |
1272 | bt_put(tag_field); |
1273 | ret = BT_COMPONENT_STATUS_ERROR; | |
1274 | goto end; | |
1275 | } | |
3228cc1d | 1276 | print_field_name_equal(pretty, rem_(tag_choice)); |
6a18b281 | 1277 | bt_put(tag_field); |
e0f15669 | 1278 | bt_put(iter); |
6a18b281 | 1279 | } |
3228cc1d | 1280 | ret = print_field(pretty, field, print_names, NULL, 0); |
6a18b281 MD |
1281 | if (ret != BT_COMPONENT_STATUS_OK) { |
1282 | goto end; | |
1283 | } | |
3228cc1d | 1284 | pretty->depth--; |
5280f742 | 1285 | g_string_append(pretty->string, " }"); |
6a18b281 MD |
1286 | end: |
1287 | bt_put(field); | |
1288 | return ret; | |
1289 | } | |
1290 | ||
1291 | static | |
3228cc1d | 1292 | enum bt_component_status print_field(struct pretty_component *pretty, |
2b4c4a7c JD |
1293 | struct bt_ctf_field *field, bool print_names, |
1294 | GQuark *filter_fields, int filter_array_len) | |
6a18b281 | 1295 | { |
1487a16a | 1296 | enum bt_ctf_field_type_id type_id; |
6a18b281 MD |
1297 | |
1298 | type_id = bt_ctf_field_get_type_id(field); | |
1299 | switch (type_id) { | |
1300 | case CTF_TYPE_INTEGER: | |
3228cc1d | 1301 | return print_integer(pretty, field); |
6a18b281 MD |
1302 | case CTF_TYPE_FLOAT: |
1303 | { | |
1304 | double v; | |
1305 | ||
1306 | if (bt_ctf_field_floating_point_get_value(field, &v)) { | |
1307 | return BT_COMPONENT_STATUS_ERROR; | |
1308 | } | |
3228cc1d | 1309 | if (pretty->use_colors) { |
5280f742 | 1310 | g_string_append(pretty->string, COLOR_NUMBER_VALUE); |
ad96d936 | 1311 | } |
5280f742 | 1312 | g_string_append_printf(pretty->string, "%g", v); |
3228cc1d | 1313 | if (pretty->use_colors) { |
5280f742 | 1314 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 1315 | } |
6a18b281 MD |
1316 | return BT_COMPONENT_STATUS_OK; |
1317 | } | |
1318 | case CTF_TYPE_ENUM: | |
3228cc1d | 1319 | return print_enum(pretty, field); |
6a18b281 | 1320 | case CTF_TYPE_STRING: |
3228cc1d | 1321 | if (pretty->use_colors) { |
5280f742 | 1322 | g_string_append(pretty->string, COLOR_STRING_VALUE); |
ad96d936 | 1323 | } |
3228cc1d PP |
1324 | print_escape_string(pretty, bt_ctf_field_string_get_value(field)); |
1325 | if (pretty->use_colors) { | |
5280f742 | 1326 | g_string_append(pretty->string, COLOR_RST); |
ad96d936 | 1327 | } |
6a18b281 MD |
1328 | return BT_COMPONENT_STATUS_OK; |
1329 | case CTF_TYPE_STRUCT: | |
3228cc1d | 1330 | return print_struct(pretty, field, print_names, filter_fields, |
2b4c4a7c | 1331 | filter_array_len); |
6a18b281 | 1332 | case CTF_TYPE_VARIANT: |
3228cc1d | 1333 | return print_variant(pretty, field, print_names); |
6a18b281 | 1334 | case CTF_TYPE_ARRAY: |
3228cc1d | 1335 | return print_array(pretty, field, print_names); |
6a18b281 | 1336 | case CTF_TYPE_SEQUENCE: |
3228cc1d | 1337 | return print_sequence(pretty, field, print_names); |
6a18b281 | 1338 | default: |
5280f742 | 1339 | // TODO: log instead |
3228cc1d | 1340 | fprintf(pretty->err, "[error] Unknown type id: %d\n", (int) type_id); |
6a18b281 MD |
1341 | return BT_COMPONENT_STATUS_ERROR; |
1342 | } | |
1343 | } | |
1344 | ||
1345 | static | |
3228cc1d | 1346 | enum bt_component_status print_stream_packet_context(struct pretty_component *pretty, |
6a18b281 MD |
1347 | struct bt_ctf_event *event) |
1348 | { | |
1349 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1350 | struct bt_ctf_packet *packet = NULL; | |
1351 | struct bt_ctf_field *main_field = NULL; | |
1352 | ||
1353 | packet = bt_ctf_event_get_packet(event); | |
1354 | if (!packet) { | |
1355 | ret = BT_COMPONENT_STATUS_ERROR; | |
1356 | goto end; | |
1357 | } | |
1358 | main_field = bt_ctf_packet_get_context(packet); | |
1359 | if (!main_field) { | |
6a18b281 MD |
1360 | goto end; |
1361 | } | |
3228cc1d | 1362 | if (!pretty->start_line) { |
5280f742 | 1363 | g_string_append(pretty->string, ", "); |
6e1bc0df | 1364 | } |
3228cc1d PP |
1365 | pretty->start_line = false; |
1366 | if (pretty->options.print_scope_field_names) { | |
1367 | print_name_equal(pretty, "stream.packet.context"); | |
6a18b281 | 1368 | } |
3228cc1d PP |
1369 | ret = print_field(pretty, main_field, |
1370 | pretty->options.print_context_field_names, | |
2b4c4a7c JD |
1371 | stream_packet_context_quarks, |
1372 | STREAM_PACKET_CONTEXT_QUARKS_LEN); | |
6a18b281 MD |
1373 | end: |
1374 | bt_put(main_field); | |
1375 | bt_put(packet); | |
1376 | return ret; | |
1377 | } | |
1378 | ||
1379 | static | |
3228cc1d | 1380 | enum bt_component_status print_event_header_raw(struct pretty_component *pretty, |
6a18b281 MD |
1381 | struct bt_ctf_event *event) |
1382 | { | |
1383 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1384 | struct bt_ctf_field *main_field = NULL; | |
1385 | ||
1386 | main_field = bt_ctf_event_get_header(event); | |
1387 | if (!main_field) { | |
6a18b281 MD |
1388 | goto end; |
1389 | } | |
3228cc1d | 1390 | if (!pretty->start_line) { |
5280f742 | 1391 | g_string_append(pretty->string, ", "); |
6e1bc0df | 1392 | } |
3228cc1d PP |
1393 | pretty->start_line = false; |
1394 | if (pretty->options.print_scope_field_names) { | |
1395 | print_name_equal(pretty, "stream.event.header"); | |
6a18b281 | 1396 | } |
3228cc1d PP |
1397 | ret = print_field(pretty, main_field, |
1398 | pretty->options.print_header_field_names, NULL, 0); | |
6a18b281 MD |
1399 | end: |
1400 | bt_put(main_field); | |
1401 | return ret; | |
1402 | } | |
1403 | ||
1404 | static | |
3228cc1d | 1405 | enum bt_component_status print_stream_event_context(struct pretty_component *pretty, |
6a18b281 MD |
1406 | struct bt_ctf_event *event) |
1407 | { | |
1408 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1409 | struct bt_ctf_field *main_field = NULL; | |
1410 | ||
1411 | main_field = bt_ctf_event_get_stream_event_context(event); | |
1412 | if (!main_field) { | |
6a18b281 MD |
1413 | goto end; |
1414 | } | |
3228cc1d | 1415 | if (!pretty->start_line) { |
5280f742 | 1416 | g_string_append(pretty->string, ", "); |
6e1bc0df | 1417 | } |
3228cc1d PP |
1418 | pretty->start_line = false; |
1419 | if (pretty->options.print_scope_field_names) { | |
1420 | print_name_equal(pretty, "stream.event.context"); | |
6a18b281 | 1421 | } |
3228cc1d PP |
1422 | ret = print_field(pretty, main_field, |
1423 | pretty->options.print_context_field_names, NULL, 0); | |
6a18b281 MD |
1424 | end: |
1425 | bt_put(main_field); | |
1426 | return ret; | |
1427 | } | |
1428 | ||
1429 | static | |
3228cc1d | 1430 | enum bt_component_status print_event_context(struct pretty_component *pretty, |
6a18b281 MD |
1431 | struct bt_ctf_event *event) |
1432 | { | |
1433 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1434 | struct bt_ctf_field *main_field = NULL; | |
1435 | ||
1436 | main_field = bt_ctf_event_get_event_context(event); | |
1437 | if (!main_field) { | |
6a18b281 MD |
1438 | goto end; |
1439 | } | |
3228cc1d | 1440 | if (!pretty->start_line) { |
5280f742 | 1441 | g_string_append(pretty->string, ", "); |
6e1bc0df | 1442 | } |
3228cc1d PP |
1443 | pretty->start_line = false; |
1444 | if (pretty->options.print_scope_field_names) { | |
1445 | print_name_equal(pretty, "event.context"); | |
6a18b281 | 1446 | } |
3228cc1d PP |
1447 | ret = print_field(pretty, main_field, |
1448 | pretty->options.print_context_field_names, NULL, 0); | |
6a18b281 MD |
1449 | end: |
1450 | bt_put(main_field); | |
1451 | return ret; | |
1452 | } | |
1453 | ||
1454 | static | |
3228cc1d | 1455 | enum bt_component_status print_event_payload(struct pretty_component *pretty, |
6a18b281 MD |
1456 | struct bt_ctf_event *event) |
1457 | { | |
1458 | enum bt_component_status ret = BT_COMPONENT_STATUS_OK; | |
1459 | struct bt_ctf_field *main_field = NULL; | |
1460 | ||
9ac68eb1 | 1461 | main_field = bt_ctf_event_get_event_payload(event); |
6a18b281 | 1462 | if (!main_field) { |
6a18b281 MD |
1463 | goto end; |
1464 | } | |
3228cc1d | 1465 | if (!pretty->start_line) { |
5280f742 | 1466 | g_string_append(pretty->string, ", "); |
6e1bc0df | 1467 | } |
3228cc1d PP |
1468 | pretty->start_line = false; |
1469 | if (pretty->options.print_scope_field_names) { | |
1470 | print_name_equal(pretty, "event.fields"); | |
6a18b281 | 1471 | } |
3228cc1d PP |
1472 | ret = print_field(pretty, main_field, |
1473 | pretty->options.print_payload_field_names, NULL, 0); | |
6a18b281 MD |
1474 | end: |
1475 | bt_put(main_field); | |
af9a82eb JG |
1476 | return ret; |
1477 | } | |
1478 | ||
1479 | BT_HIDDEN | |
3228cc1d | 1480 | enum bt_component_status pretty_print_event(struct pretty_component *pretty, |
d9f65f09 | 1481 | struct bt_notification *event_notif) |
af9a82eb JG |
1482 | { |
1483 | enum bt_component_status ret; | |
d9f65f09 PP |
1484 | struct bt_ctf_event *event = |
1485 | bt_notification_event_get_event(event_notif); | |
1486 | struct bt_clock_class_priority_map *cc_prio_map = | |
1487 | bt_notification_event_get_clock_class_priority_map(event_notif); | |
af9a82eb | 1488 | |
d9f65f09 PP |
1489 | assert(event); |
1490 | assert(cc_prio_map); | |
3228cc1d | 1491 | pretty->start_line = true; |
5280f742 | 1492 | g_string_assign(pretty->string, ""); |
d9f65f09 | 1493 | ret = print_event_header(pretty, event, cc_prio_map); |
af9a82eb JG |
1494 | if (ret != BT_COMPONENT_STATUS_OK) { |
1495 | goto end; | |
1496 | } | |
6a18b281 | 1497 | |
3228cc1d | 1498 | ret = print_stream_packet_context(pretty, event); |
6a18b281 MD |
1499 | if (ret != BT_COMPONENT_STATUS_OK) { |
1500 | goto end; | |
1501 | } | |
6a18b281 | 1502 | |
3228cc1d PP |
1503 | if (pretty->options.verbose) { |
1504 | ret = print_event_header_raw(pretty, event); | |
60535549 JD |
1505 | if (ret != BT_COMPONENT_STATUS_OK) { |
1506 | goto end; | |
1507 | } | |
6a18b281 | 1508 | } |
6a18b281 | 1509 | |
3228cc1d | 1510 | ret = print_stream_event_context(pretty, event); |
6a18b281 MD |
1511 | if (ret != BT_COMPONENT_STATUS_OK) { |
1512 | goto end; | |
1513 | } | |
6a18b281 | 1514 | |
3228cc1d | 1515 | ret = print_event_context(pretty, event); |
6a18b281 MD |
1516 | if (ret != BT_COMPONENT_STATUS_OK) { |
1517 | goto end; | |
1518 | } | |
6a18b281 | 1519 | |
3228cc1d | 1520 | ret = print_event_payload(pretty, event); |
6a18b281 MD |
1521 | if (ret != BT_COMPONENT_STATUS_OK) { |
1522 | goto end; | |
1523 | } | |
af9a82eb | 1524 | |
5280f742 PP |
1525 | g_string_append_c(pretty->string, '\n'); |
1526 | if (fwrite(pretty->string->str, pretty->string->len, 1, pretty->out) != 1) { | |
1527 | ret = BT_COMPONENT_STATUS_ERROR; | |
1528 | goto end; | |
1529 | } | |
1530 | ||
af9a82eb | 1531 | end: |
d9f65f09 PP |
1532 | bt_put(event); |
1533 | bt_put(cc_prio_map); | |
af9a82eb JG |
1534 | return ret; |
1535 | } |