1 /* Support for printing Ada types for GDB, the GNU debugger.
2 Copyright (C) 1986, 1988, 1989, 1991, 1997, 1998, 1999, 2000, 2001, 2002,
3 2003, 2004, 2007, 2008, 2009 Free Software Foundation, Inc.
5 This file is part of GDB.
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 #include "gdb_obstack.h"
22 #include "bfd.h" /* Binary File Description */
25 #include "expression.h"
34 #include "typeprint.h"
38 #include "gdb_string.h"
41 static int print_record_field_types (struct type
*, struct type
*,
42 struct ui_file
*, int, int);
44 static void print_array_type (struct type
*, struct ui_file
*, int, int);
46 static void print_choices (struct type
*, int, struct ui_file
*,
49 static void print_range (struct type
*, struct ui_file
*);
51 static void print_range_bound (struct type
*, char *, int *,
55 print_dynamic_range_bound (struct type
*, const char *, int,
56 const char *, struct ui_file
*);
58 static void print_range_type_named (char *, struct ui_file
*);
62 static char *name_buffer
;
63 static int name_buffer_len
;
65 /* The (decoded) Ada name of TYPE. This value persists until the
69 decoded_type_name (struct type
*type
)
71 if (ada_type_name (type
) == NULL
)
75 char *raw_name
= ada_type_name (type
);
78 if (name_buffer
== NULL
|| name_buffer_len
<= strlen (raw_name
))
80 name_buffer_len
= 16 + 2 * strlen (raw_name
);
81 name_buffer
= xrealloc (name_buffer
, name_buffer_len
);
83 strcpy (name_buffer
, raw_name
);
85 s
= (char *) strstr (name_buffer
, "___");
89 s
= name_buffer
+ strlen (name_buffer
) - 1;
90 while (s
> name_buffer
&& (s
[0] != '_' || s
[-1] != '_'))
99 for (s
= q
= name_buffer
; *s
!= '\0'; q
+= 1)
101 if (s
[0] == '_' && s
[1] == '_')
118 /* Print a description of a type in the format of a
119 typedef for the current language.
120 NEW is the new name for a type TYPE. */
123 ada_typedef_print (struct type
*type
, struct symbol
*new,
124 struct ui_file
*stream
)
126 /* XXX: type_sprint */
127 fprintf_filtered (stream
, "type %.*s is ",
128 ada_name_prefix_len (SYMBOL_PRINT_NAME (new)),
129 SYMBOL_PRINT_NAME (new));
130 type_print (type
, "", stream
, 1);
133 /* Print range type TYPE on STREAM. */
136 print_range (struct type
*type
, struct ui_file
*stream
)
138 struct type
*target_type
;
139 target_type
= TYPE_TARGET_TYPE (type
);
140 if (target_type
== NULL
)
143 switch (TYPE_CODE (target_type
))
145 case TYPE_CODE_RANGE
:
152 target_type
= builtin_type_int32
;
156 if (TYPE_NFIELDS (type
) < 2)
158 /* A range needs at least 2 bounds to be printed. If there are less
159 than 2, just print the type name instead of the range itself.
160 This check handles cases such as characters, for example.
162 If the name is not defined, then we don't print anything.
164 fprintf_filtered (stream
, "%.*s",
165 ada_name_prefix_len (TYPE_NAME (type
)),
170 /* We extract the range type bounds respectively from the first element
171 and the last element of the type->fields array */
172 const LONGEST lower_bound
= (LONGEST
) TYPE_LOW_BOUND (type
);
173 const LONGEST upper_bound
= (TYPE_CODE (type
) == TYPE_CODE_RANGE
174 ? (LONGEST
) TYPE_HIGH_BOUND (type
)
175 : (LONGEST
) TYPE_FIELD_BITPOS (type
, TYPE_NFIELDS (type
) - 1));
177 ada_print_scalar (target_type
, lower_bound
, stream
);
178 fprintf_filtered (stream
, " .. ");
179 ada_print_scalar (target_type
, upper_bound
, stream
);
183 /* Print the number or discriminant bound at BOUNDS+*N on STREAM, and
184 set *N past the bound and its delimiter, if any. */
187 print_range_bound (struct type
*type
, char *bounds
, int *n
,
188 struct ui_file
*stream
)
191 if (ada_scan_number (bounds
, *n
, &B
, n
))
193 /* STABS decodes all range types which bounds are 0 .. -1 as
194 unsigned integers (ie. the type code is TYPE_CODE_INT, not
195 TYPE_CODE_RANGE). Unfortunately, ada_print_scalar() relies
196 on the unsigned flag to determine whether the bound should
197 be printed as a signed or an unsigned value. This causes
198 the upper bound of the 0 .. -1 range types to be printed as
199 a very large unsigned number instead of -1.
200 To workaround this stabs deficiency, we replace the TYPE by
201 builtin_type_int32 when we detect that the bound is negative,
202 and the type is a TYPE_CODE_INT. The bound is negative when
203 'm' is the last character of the number scanned in BOUNDS. */
204 if (bounds
[*n
- 1] == 'm' && TYPE_CODE (type
) == TYPE_CODE_INT
)
205 type
= builtin_type_int32
;
206 ada_print_scalar (type
, B
, stream
);
207 if (bounds
[*n
] == '_')
213 char *bound
= bounds
+ *n
;
216 pend
= strstr (bound
, "__");
218 *n
+= bound_len
= strlen (bound
);
221 bound_len
= pend
- bound
;
224 fprintf_filtered (stream
, "%.*s", bound_len
, bound
);
228 /* Assuming NAME[0 .. NAME_LEN-1] is the name of a range type, print
229 the value (if found) of the bound indicated by SUFFIX ("___L" or
230 "___U") according to the ___XD conventions. */
233 print_dynamic_range_bound (struct type
*type
, const char *name
, int name_len
,
234 const char *suffix
, struct ui_file
*stream
)
236 static char *name_buf
= NULL
;
237 static size_t name_buf_len
= 0;
241 GROW_VECT (name_buf
, name_buf_len
, name_len
+ strlen (suffix
) + 1);
242 strncpy (name_buf
, name
, name_len
);
243 strcpy (name_buf
+ name_len
, suffix
);
245 B
= get_int_var_value (name_buf
, &OK
);
247 ada_print_scalar (type
, B
, stream
);
249 fprintf_filtered (stream
, "?");
252 /* Print the range type named NAME. */
255 print_range_type_named (char *name
, struct ui_file
*stream
)
257 struct type
*raw_type
= ada_find_any_type (name
);
258 struct type
*base_type
;
261 if (raw_type
== NULL
)
262 base_type
= builtin_type_int32
;
263 else if (TYPE_CODE (raw_type
) == TYPE_CODE_RANGE
)
264 base_type
= TYPE_TARGET_TYPE (raw_type
);
266 base_type
= raw_type
;
268 subtype_info
= strstr (name
, "___XD");
269 if (subtype_info
== NULL
&& raw_type
== NULL
)
270 fprintf_filtered (stream
, "? .. ?");
271 else if (subtype_info
== NULL
)
272 print_range (raw_type
, stream
);
275 int prefix_len
= subtype_info
- name
;
280 bounds_str
= strchr (subtype_info
, '_');
283 if (*subtype_info
== 'L')
285 print_range_bound (base_type
, bounds_str
, &n
, stream
);
289 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___L",
292 fprintf_filtered (stream
, " .. ");
294 if (*subtype_info
== 'U')
295 print_range_bound (base_type
, bounds_str
, &n
, stream
);
297 print_dynamic_range_bound (base_type
, name
, prefix_len
, "___U",
302 /* Print enumerated type TYPE on STREAM. */
305 print_enum_type (struct type
*type
, struct ui_file
*stream
)
307 int len
= TYPE_NFIELDS (type
);
310 fprintf_filtered (stream
, "(");
314 for (i
= 0; i
< len
; i
++)
318 fprintf_filtered (stream
, ", ");
320 fputs_filtered (ada_enum_name (TYPE_FIELD_NAME (type
, i
)), stream
);
321 if (lastval
!= TYPE_FIELD_BITPOS (type
, i
))
323 fprintf_filtered (stream
, " => %d", TYPE_FIELD_BITPOS (type
, i
));
324 lastval
= TYPE_FIELD_BITPOS (type
, i
);
328 fprintf_filtered (stream
, ")");
331 /* Print representation of Ada fixed-point type TYPE on STREAM. */
334 print_fixed_point_type (struct type
*type
, struct ui_file
*stream
)
336 DOUBLEST delta
= ada_delta (type
);
337 DOUBLEST small
= ada_fixed_to_float (type
, 1.0);
340 fprintf_filtered (stream
, "delta ??");
343 fprintf_filtered (stream
, "delta %g", (double) delta
);
345 fprintf_filtered (stream
, " <'small = %g>", (double) small
);
349 /* Print representation of special VAX floating-point type TYPE on STREAM. */
352 print_vax_floating_point_type (struct type
*type
, struct ui_file
*stream
)
354 fprintf_filtered (stream
, "<float format %c>",
355 ada_vax_float_type_suffix (type
));
358 /* Print simple (constrained) array type TYPE on STREAM. LEVEL is the
359 recursion (indentation) level, in case the element type itself has
360 nested structure, and SHOW is the number of levels of internal
361 structure to show (see ada_print_type). */
364 print_array_type (struct type
*type
, struct ui_file
*stream
, int show
,
370 if (ada_is_packed_array_type (type
))
371 type
= ada_coerce_to_simple_array_type (type
);
374 fprintf_filtered (stream
, "array (");
378 fprintf_filtered (stream
, "...");
383 fprintf_filtered (stream
, _("<undecipherable array type>"));
386 if (ada_is_simple_array_type (type
))
388 struct type
*range_desc_type
=
389 ada_find_parallel_type (type
, "___XA");
390 struct type
*arr_type
;
393 if (range_desc_type
== NULL
)
395 for (arr_type
= type
; TYPE_CODE (arr_type
) == TYPE_CODE_ARRAY
;
396 arr_type
= TYPE_TARGET_TYPE (arr_type
))
398 if (arr_type
!= type
)
399 fprintf_filtered (stream
, ", ");
400 print_range (TYPE_INDEX_TYPE (arr_type
), stream
);
401 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
402 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
408 n_indices
= TYPE_NFIELDS (range_desc_type
);
409 for (k
= 0, arr_type
= type
;
411 k
+= 1, arr_type
= TYPE_TARGET_TYPE (arr_type
))
414 fprintf_filtered (stream
, ", ");
415 print_range_type_named (TYPE_FIELD_NAME
416 (range_desc_type
, k
), stream
);
417 if (TYPE_FIELD_BITSIZE (arr_type
, 0) > 0)
418 bitsize
= TYPE_FIELD_BITSIZE (arr_type
, 0);
425 for (i
= i0
= ada_array_arity (type
); i
> 0; i
-= 1)
426 fprintf_filtered (stream
, "%s<>", i
== i0
? "" : ", ");
430 fprintf_filtered (stream
, ") of ");
432 ada_print_type (ada_array_element_type (type
, n_indices
), "", stream
,
433 show
== 0 ? 0 : show
- 1, level
+ 1);
435 fprintf_filtered (stream
, " <packed: %d-bit elements>", bitsize
);
438 /* Print the choices encoded by field FIELD_NUM of variant-part TYPE on
439 STREAM, assuming the VAL_TYPE is the type of the values. */
442 print_choices (struct type
*type
, int field_num
, struct ui_file
*stream
,
443 struct type
*val_type
)
447 const char *name
= TYPE_FIELD_NAME (type
, field_num
);
451 /* Skip over leading 'V': NOTE soon to be obsolete. */
454 if (!ada_scan_number (name
, 1, NULL
, &p
))
470 fprintf_filtered (stream
, " | ");
480 if (!ada_scan_number (name
, p
+ 1, &W
, &p
))
482 ada_print_scalar (val_type
, W
, stream
);
488 if (!ada_scan_number (name
, p
+ 1, &L
, &p
)
489 || name
[p
] != 'T' || !ada_scan_number (name
, p
+ 1, &U
, &p
))
491 ada_print_scalar (val_type
, L
, stream
);
492 fprintf_filtered (stream
, " .. ");
493 ada_print_scalar (val_type
, U
, stream
);
497 fprintf_filtered (stream
, "others");
504 fprintf_filtered (stream
, "??");
508 /* Assuming that field FIELD_NUM of TYPE is a VARIANTS field whose
509 discriminant is contained in OUTER_TYPE, print its variants on STREAM.
510 LEVEL is the recursion
511 (indentation) level, in case any of the fields themselves have
512 nested structure, and SHOW is the number of levels of internal structure
513 to show (see ada_print_type). For this purpose, fields nested in a
514 variant part are taken to be at the same level as the fields
515 immediately outside the variant part. */
518 print_variant_clauses (struct type
*type
, int field_num
,
519 struct type
*outer_type
, struct ui_file
*stream
,
523 struct type
*var_type
, *par_type
;
524 struct type
*discr_type
;
526 var_type
= TYPE_FIELD_TYPE (type
, field_num
);
527 discr_type
= ada_variant_discrim_type (var_type
, outer_type
);
529 if (TYPE_CODE (var_type
) == TYPE_CODE_PTR
)
531 var_type
= TYPE_TARGET_TYPE (var_type
);
532 if (var_type
== NULL
|| TYPE_CODE (var_type
) != TYPE_CODE_UNION
)
536 par_type
= ada_find_parallel_type (var_type
, "___XVU");
537 if (par_type
!= NULL
)
540 for (i
= 0; i
< TYPE_NFIELDS (var_type
); i
+= 1)
542 fprintf_filtered (stream
, "\n%*swhen ", level
+ 4, "");
543 print_choices (var_type
, i
, stream
, discr_type
);
544 fprintf_filtered (stream
, " =>");
545 if (print_record_field_types (TYPE_FIELD_TYPE (var_type
, i
),
546 outer_type
, stream
, show
, level
+ 4) <= 0)
547 fprintf_filtered (stream
, " null;");
551 /* Assuming that field FIELD_NUM of TYPE is a variant part whose
552 discriminants are contained in OUTER_TYPE, print a description of it
553 on STREAM. LEVEL is the recursion (indentation) level, in case any of
554 the fields themselves have nested structure, and SHOW is the number of
555 levels of internal structure to show (see ada_print_type). For this
556 purpose, fields nested in a variant part are taken to be at the same
557 level as the fields immediately outside the variant part. */
560 print_variant_part (struct type
*type
, int field_num
, struct type
*outer_type
,
561 struct ui_file
*stream
, int show
, int level
)
563 fprintf_filtered (stream
, "\n%*scase %s is", level
+ 4, "",
564 ada_variant_discrim_name
565 (TYPE_FIELD_TYPE (type
, field_num
)));
566 print_variant_clauses (type
, field_num
, outer_type
, stream
, show
,
568 fprintf_filtered (stream
, "\n%*send case;", level
+ 4, "");
571 /* Print a description on STREAM of the fields in record type TYPE, whose
572 discriminants are in OUTER_TYPE. LEVEL is the recursion (indentation)
573 level, in case any of the fields themselves have nested structure,
574 and SHOW is the number of levels of internal structure to show
575 (see ada_print_type). Does not print parent type information of TYPE.
576 Returns 0 if no fields printed, -1 for an incomplete type, else > 0.
577 Prints each field beginning on a new line, but does not put a new line at
581 print_record_field_types (struct type
*type
, struct type
*outer_type
,
582 struct ui_file
*stream
, int show
, int level
)
587 len
= TYPE_NFIELDS (type
);
589 if (len
== 0 && TYPE_STUB (type
))
592 for (i
= 0; i
< len
; i
+= 1)
596 if (ada_is_parent_field (type
, i
) || ada_is_ignored_field (type
, i
))
598 else if (ada_is_wrapper_field (type
, i
))
599 flds
+= print_record_field_types (TYPE_FIELD_TYPE (type
, i
), type
,
600 stream
, show
, level
);
601 else if (ada_is_variant_part (type
, i
))
603 print_variant_part (type
, i
, outer_type
, stream
, show
, level
);
609 fprintf_filtered (stream
, "\n%*s", level
+ 4, "");
610 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
611 TYPE_FIELD_NAME (type
, i
),
612 stream
, show
- 1, level
+ 4);
613 fprintf_filtered (stream
, ";");
620 /* Print record type TYPE on STREAM. LEVEL is the recursion (indentation)
621 level, in case the element type itself has nested structure, and SHOW is
622 the number of levels of internal structure to show (see ada_print_type). */
625 print_record_type (struct type
*type0
, struct ui_file
*stream
, int show
,
628 struct type
*parent_type
;
631 type
= ada_find_parallel_type (type0
, "___XVE");
635 parent_type
= ada_parent_type (type
);
636 if (ada_type_name (parent_type
) != NULL
)
637 fprintf_filtered (stream
, "new %s with record",
638 decoded_type_name (parent_type
));
639 else if (parent_type
== NULL
&& ada_is_tagged_type (type
, 0))
640 fprintf_filtered (stream
, "tagged record");
642 fprintf_filtered (stream
, "record");
645 fprintf_filtered (stream
, " ... end record");
651 if (parent_type
!= NULL
&& ada_type_name (parent_type
) == NULL
)
652 flds
+= print_record_field_types (parent_type
, parent_type
,
653 stream
, show
, level
);
654 flds
+= print_record_field_types (type
, type
, stream
, show
, level
);
657 fprintf_filtered (stream
, "\n%*send record", level
, "");
659 fprintf_filtered (stream
, _(" <incomplete type> end record"));
661 fprintf_filtered (stream
, " null; end record");
665 /* Print the unchecked union type TYPE in something resembling Ada
666 format on STREAM. LEVEL is the recursion (indentation) level
667 in case the element type itself has nested structure, and SHOW is the
668 number of levels of internal structure to show (see ada_print_type). */
670 print_unchecked_union_type (struct type
*type
, struct ui_file
*stream
,
674 fprintf_filtered (stream
, "record (?) is ... end record");
675 else if (TYPE_NFIELDS (type
) == 0)
676 fprintf_filtered (stream
, "record (?) is null; end record");
681 fprintf_filtered (stream
, "record (?) is\n%*scase ? is", level
+ 4, "");
683 for (i
= 0; i
< TYPE_NFIELDS (type
); i
+= 1)
685 fprintf_filtered (stream
, "\n%*swhen ? =>\n%*s", level
+ 8, "",
687 ada_print_type (TYPE_FIELD_TYPE (type
, i
),
688 TYPE_FIELD_NAME (type
, i
),
689 stream
, show
- 1, level
+ 12);
690 fprintf_filtered (stream
, ";");
693 fprintf_filtered (stream
, "\n%*send case;\n%*send record",
694 level
+ 4, "", level
, "");
700 /* Print function or procedure type TYPE on STREAM. Make it a header
701 for function or procedure NAME if NAME is not null. */
704 print_func_type (struct type
*type
, struct ui_file
*stream
, char *name
)
706 int i
, len
= TYPE_NFIELDS (type
);
708 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) == TYPE_CODE_VOID
)
709 fprintf_filtered (stream
, "procedure");
711 fprintf_filtered (stream
, "function");
713 if (name
!= NULL
&& name
[0] != '\0')
714 fprintf_filtered (stream
, " %s", name
);
718 fprintf_filtered (stream
, " (");
719 for (i
= 0; i
< len
; i
+= 1)
723 fputs_filtered ("; ", stream
);
726 fprintf_filtered (stream
, "a%d: ", i
+ 1);
727 ada_print_type (TYPE_FIELD_TYPE (type
, i
), "", stream
, -1, 0);
729 fprintf_filtered (stream
, ")");
732 if (TYPE_CODE (TYPE_TARGET_TYPE (type
)) != TYPE_CODE_VOID
)
734 fprintf_filtered (stream
, " return ");
735 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, 0, 0);
740 /* Print a description of a type TYPE0.
741 Output goes to STREAM (via stdio).
742 If VARSTRING is a non-empty string, print as an Ada variable/field
744 SHOW+1 is the maximum number of levels of internal type structure
745 to show (this applies to record types, enumerated types, and
747 SHOW is the number of levels of internal type structure to show
748 when there is a type name for the SHOWth deepest level (0th is
750 When SHOW<0, no inner structure is shown.
751 LEVEL indicates level of recursion (for nested definitions). */
754 ada_print_type (struct type
*type0
, char *varstring
, struct ui_file
*stream
,
757 struct type
*type
= ada_check_typedef (ada_get_base_type (type0
));
758 char *type_name
= decoded_type_name (type0
);
759 int is_var_decl
= (varstring
!= NULL
&& varstring
[0] != '\0');
764 fprintf_filtered (stream
, "%.*s: ",
765 ada_name_prefix_len (varstring
), varstring
);
766 fprintf_filtered (stream
, "<null type?>");
771 type
= ada_check_typedef (type
);
773 if (is_var_decl
&& TYPE_CODE (type
) != TYPE_CODE_FUNC
)
774 fprintf_filtered (stream
, "%.*s: ",
775 ada_name_prefix_len (varstring
), varstring
);
777 if (type_name
!= NULL
&& show
<= 0)
779 fprintf_filtered (stream
, "%.*s",
780 ada_name_prefix_len (type_name
), type_name
);
784 if (ada_is_aligner_type (type
))
785 ada_print_type (ada_aligned_type (type
), "", stream
, show
, level
);
786 else if (ada_is_packed_array_type (type
))
788 if (TYPE_CODE (type
) == TYPE_CODE_PTR
)
790 fprintf_filtered (stream
, "access ");
791 print_array_type (TYPE_TARGET_TYPE (type
), stream
, show
, level
);
795 print_array_type (type
, stream
, show
, level
);
799 switch (TYPE_CODE (type
))
802 fprintf_filtered (stream
, "<");
803 c_print_type (type
, "", stream
, show
, level
);
804 fprintf_filtered (stream
, ">");
807 fprintf_filtered (stream
, "access ");
808 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
811 fprintf_filtered (stream
, "<ref> ");
812 ada_print_type (TYPE_TARGET_TYPE (type
), "", stream
, show
, level
);
814 case TYPE_CODE_ARRAY
:
815 print_array_type (type
, stream
, show
, level
);
818 fprintf_filtered (stream
, "(false, true)");
821 if (ada_is_fixed_point_type (type
))
822 print_fixed_point_type (type
, stream
);
823 else if (ada_is_vax_floating_type (type
))
824 print_vax_floating_point_type (type
, stream
);
827 char *name
= ada_type_name (type
);
828 if (!ada_is_range_type_name (name
))
829 fprintf_filtered (stream
, _("<%d-byte integer>"),
833 fprintf_filtered (stream
, "range ");
834 print_range_type_named (name
, stream
);
838 case TYPE_CODE_RANGE
:
839 if (ada_is_fixed_point_type (type
))
840 print_fixed_point_type (type
, stream
);
841 else if (ada_is_vax_floating_type (type
))
842 print_vax_floating_point_type (type
, stream
);
843 else if (ada_is_modular_type (type
))
844 fprintf_filtered (stream
, "mod %s",
845 int_string (ada_modulus (type
), 10, 0, 0, 1));
848 fprintf_filtered (stream
, "range ");
849 print_range (type
, stream
);
853 fprintf_filtered (stream
, _("<%d-byte float>"), TYPE_LENGTH (type
));
857 fprintf_filtered (stream
, "(...)");
859 print_enum_type (type
, stream
);
861 case TYPE_CODE_STRUCT
:
862 if (ada_is_array_descriptor_type (type
))
863 print_array_type (type
, stream
, show
, level
);
864 else if (ada_is_bogus_array_descriptor (type
))
865 fprintf_filtered (stream
,
866 _("array (?) of ? (<mal-formed descriptor>)"));
868 print_record_type (type
, stream
, show
, level
);
870 case TYPE_CODE_UNION
:
871 print_unchecked_union_type (type
, stream
, show
, level
);
874 print_func_type (type
, stream
, varstring
);
This page took 0.051 seconds and 4 git commands to generate.