1 /* C declarator syntax glue. 2 Copyright (C) 2019-2024 Free Software Foundation, Inc. 3 4 This file is part of libctf. 5 6 libctf is free software; you can redistribute it and/or modify it under 7 the terms of the GNU General Public License as published by the Free 8 Software Foundation; either version 3, or (at your option) any later 9 version. 10 11 This program is distributed in the hope that it will be useful, but 12 WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. 14 See the GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program; see the file COPYING. If not see 18 <http://www.gnu.org/licenses/>. */ 19 20 /* CTF Declaration Stack 21 22 In order to implement ctf_type_name(), we must convert a type graph back 23 into a C type declaration. Unfortunately, a type graph represents a storage 24 class ordering of the type whereas a type declaration must obey the C rules 25 for operator precedence, and the two orderings are frequently in conflict. 26 For example, consider these CTF type graphs and their C declarations: 27 28 CTF_K_POINTER -> CTF_K_FUNCTION -> CTF_K_INTEGER : int (*)() 29 CTF_K_POINTER -> CTF_K_ARRAY -> CTF_K_INTEGER : int (*)[] 30 31 In each case, parentheses are used to raise operator * to higher lexical 32 precedence, so the string form of the C declaration cannot be constructed by 33 walking the type graph links and forming the string from left to right. 34 35 The functions in this file build a set of stacks from the type graph nodes 36 corresponding to the C operator precedence levels in the appropriate order. 37 The code in ctf_type_name() can then iterate over the levels and nodes in 38 lexical precedence order and construct the final C declaration string. */ 39 40 #include <ctf-impl.h> 41 #include <string.h> 42 43 void 44 ctf_decl_init (ctf_decl_t *cd) 45 { 46 int i; 47 48 memset (cd, 0, sizeof (ctf_decl_t)); 49 50 for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++) 51 cd->cd_order[i] = CTF_PREC_BASE - 1; 52 53 cd->cd_qualp = CTF_PREC_BASE; 54 cd->cd_ordp = CTF_PREC_BASE; 55 } 56 57 void 58 ctf_decl_fini (ctf_decl_t *cd) 59 { 60 ctf_decl_node_t *cdp, *ndp; 61 int i; 62 63 for (i = CTF_PREC_BASE; i < CTF_PREC_MAX; i++) 64 { 65 for (cdp = ctf_list_next (&cd->cd_nodes[i]); cdp != NULL; cdp = ndp) 66 { 67 ndp = ctf_list_next (cdp); 68 free (cdp); 69 } 70 } 71 free (cd->cd_buf); 72 } 73 74 void 75 ctf_decl_push (ctf_decl_t *cd, ctf_dict_t *fp, ctf_id_t type) 76 { 77 ctf_decl_node_t *cdp; 78 ctf_decl_prec_t prec; 79 uint32_t kind, n = 1; 80 int is_qual = 0; 81 82 const ctf_type_t *tp; 83 ctf_arinfo_t ar; 84 85 if ((tp = ctf_lookup_by_id (&fp, type)) == NULL) 86 { 87 cd->cd_err = fp->ctf_errno; 88 return; 89 } 90 91 switch (kind = LCTF_INFO_KIND (fp, tp->ctt_info)) 92 { 93 case CTF_K_ARRAY: 94 (void) ctf_array_info (fp, type, &ar); 95 ctf_decl_push (cd, fp, ar.ctr_contents); 96 n = ar.ctr_nelems; 97 prec = CTF_PREC_ARRAY; 98 break; 99 100 case CTF_K_TYPEDEF: 101 if (ctf_strptr (fp, tp->ctt_name)[0] == '\0') 102 { 103 ctf_decl_push (cd, fp, tp->ctt_type); 104 return; 105 } 106 prec = CTF_PREC_BASE; 107 break; 108 109 case CTF_K_FUNCTION: 110 ctf_decl_push (cd, fp, tp->ctt_type); 111 prec = CTF_PREC_FUNCTION; 112 break; 113 114 case CTF_K_POINTER: 115 ctf_decl_push (cd, fp, tp->ctt_type); 116 prec = CTF_PREC_POINTER; 117 break; 118 119 case CTF_K_SLICE: 120 /* Slices themselves have no print representation and should not appear in 121 the decl stack. */ 122 ctf_decl_push (cd, fp, ctf_type_reference (fp, type)); 123 return; 124 125 case CTF_K_VOLATILE: 126 case CTF_K_CONST: 127 case CTF_K_RESTRICT: 128 ctf_decl_push (cd, fp, tp->ctt_type); 129 prec = cd->cd_qualp; 130 is_qual++; 131 break; 132 133 default: 134 prec = CTF_PREC_BASE; 135 } 136 137 if ((cdp = malloc (sizeof (ctf_decl_node_t))) == NULL) 138 { 139 cd->cd_err = EAGAIN; 140 return; 141 } 142 143 cdp->cd_type = type; 144 cdp->cd_kind = kind; 145 cdp->cd_n = n; 146 147 if (ctf_list_next (&cd->cd_nodes[prec]) == NULL) 148 cd->cd_order[prec] = cd->cd_ordp++; 149 150 /* Reset cd_qualp to the highest precedence level that we've seen so 151 far that can be qualified (CTF_PREC_BASE or CTF_PREC_POINTER). */ 152 153 if (prec > cd->cd_qualp && prec < CTF_PREC_ARRAY) 154 cd->cd_qualp = prec; 155 156 /* By convention qualifiers of base types precede the type specifier (e.g. 157 const int vs. int const) even though the two forms are equivalent. */ 158 159 if (is_qual && prec == CTF_PREC_BASE) 160 ctf_list_prepend (&cd->cd_nodes[prec], cdp); 161 else 162 ctf_list_append (&cd->cd_nodes[prec], cdp); 163 } 164 165 _libctf_printflike_ (2, 3) 166 void ctf_decl_sprintf (ctf_decl_t *cd, const char *format, ...) 167 { 168 va_list ap; 169 char *str; 170 int n; 171 172 if (cd->cd_enomem) 173 return; 174 175 va_start (ap, format); 176 n = vasprintf (&str, format, ap); 177 va_end (ap); 178 179 if (n > 0) 180 { 181 char *newbuf; 182 if ((newbuf = ctf_str_append (cd->cd_buf, str)) != NULL) 183 cd->cd_buf = newbuf; 184 } 185 186 /* Sticky error condition. */ 187 if (n < 0 || cd->cd_buf == NULL) 188 { 189 free (cd->cd_buf); 190 cd->cd_buf = NULL; 191 cd->cd_enomem = 1; 192 } 193 194 free (str); 195 } 196 197 char *ctf_decl_buf (ctf_decl_t *cd) 198 { 199 char *buf = cd->cd_buf; 200 cd->cd_buf = NULL; 201 return buf; 202 } 203