1 /* Parse a printf-style format string. 2 3 Copyright (C) 1986-2024 Free Software Foundation, Inc. 4 5 This file is part of GDB. 6 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. 11 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. 16 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/>. */ 19 20 #include "format.h" 21 22 format_pieces::format_pieces (const char **arg, bool gdb_extensions, 23 bool value_extension) 24 { 25 const char *s; 26 const char *string; 27 const char *prev_start; 28 const char *percent_loc; 29 char *sub_start, *current_substring; 30 enum argclass this_argclass; 31 32 s = *arg; 33 34 if (gdb_extensions) 35 { 36 string = *arg; 37 *arg += strlen (*arg); 38 } 39 else 40 { 41 /* Parse the format-control string and copy it into the string STRING, 42 processing some kinds of escape sequence. */ 43 44 char *f = (char *) alloca (strlen (s) + 1); 45 string = f; 46 47 while (*s != '"' && *s != '\0') 48 { 49 int c = *s++; 50 switch (c) 51 { 52 case '\0': 53 continue; 54 55 case '\\': 56 switch (c = *s++) 57 { 58 case '\\': 59 *f++ = '\\'; 60 break; 61 case 'a': 62 *f++ = '\a'; 63 break; 64 case 'b': 65 *f++ = '\b'; 66 break; 67 case 'e': 68 *f++ = '\e'; 69 break; 70 case 'f': 71 *f++ = '\f'; 72 break; 73 case 'n': 74 *f++ = '\n'; 75 break; 76 case 'r': 77 *f++ = '\r'; 78 break; 79 case 't': 80 *f++ = '\t'; 81 break; 82 case 'v': 83 *f++ = '\v'; 84 break; 85 case '"': 86 *f++ = '"'; 87 break; 88 default: 89 /* ??? TODO: handle other escape sequences. */ 90 error (_("Unrecognized escape character \\%c in format string."), 91 c); 92 } 93 break; 94 95 default: 96 *f++ = c; 97 } 98 } 99 100 /* Terminate our escape-processed copy. */ 101 *f++ = '\0'; 102 103 /* Whether the format string ended with double-quote or zero, we're 104 done with it; it's up to callers to complain about syntax. */ 105 *arg = s; 106 } 107 108 /* Need extra space for the '\0's. Doubling the size is sufficient. */ 109 110 current_substring = (char *) xmalloc (strlen (string) * 2 + 1000); 111 m_storage.reset (current_substring); 112 113 /* Now scan the string for %-specs and see what kinds of args they want. 114 argclass classifies the %-specs so we can give printf-type functions 115 something of the right size. */ 116 117 const char *f = string; 118 prev_start = string; 119 while (*f) 120 if (*f++ == '%') 121 { 122 int seen_hash = 0, seen_zero = 0, lcount = 0, seen_prec = 0; 123 int seen_space = 0, seen_plus = 0; 124 int seen_big_l = 0, seen_h = 0, seen_big_h = 0; 125 int seen_big_d = 0, seen_double_big_d = 0; 126 int seen_size_t = 0; 127 int bad = 0; 128 int n_int_args = 0; 129 bool seen_i64 = false; 130 131 /* Skip over "%%", it will become part of a literal piece. */ 132 if (*f == '%') 133 { 134 f++; 135 continue; 136 } 137 138 sub_start = current_substring; 139 140 strncpy (current_substring, prev_start, f - 1 - prev_start); 141 current_substring += f - 1 - prev_start; 142 *current_substring++ = '\0'; 143 144 if (*sub_start != '\0') 145 m_pieces.emplace_back (sub_start, literal_piece, 0); 146 147 percent_loc = f - 1; 148 149 /* Check the validity of the format specifier, and work 150 out what argument it expects. We only accept C89 151 format strings, with the exception of long long (which 152 we autoconf for). */ 153 154 /* The first part of a format specifier is a set of flag 155 characters. */ 156 while (*f != '\0' && strchr ("0-+ #", *f)) 157 { 158 if (*f == '#') 159 seen_hash = 1; 160 else if (*f == '0') 161 seen_zero = 1; 162 else if (*f == ' ') 163 seen_space = 1; 164 else if (*f == '+') 165 seen_plus = 1; 166 f++; 167 } 168 169 /* The next part of a format specifier is a width. */ 170 if (gdb_extensions && *f == '*') 171 { 172 ++f; 173 ++n_int_args; 174 } 175 else 176 { 177 while (*f != '\0' && strchr ("0123456789", *f)) 178 f++; 179 } 180 181 /* The next part of a format specifier is a precision. */ 182 if (*f == '.') 183 { 184 seen_prec = 1; 185 f++; 186 if (gdb_extensions && *f == '*') 187 { 188 ++f; 189 ++n_int_args; 190 } 191 else 192 { 193 while (*f != '\0' && strchr ("0123456789", *f)) 194 f++; 195 } 196 } 197 198 /* The next part of a format specifier is a length modifier. */ 199 switch (*f) 200 { 201 case 'h': 202 seen_h = 1; 203 f++; 204 break; 205 case 'l': 206 f++; 207 lcount++; 208 if (*f == 'l') 209 { 210 f++; 211 lcount++; 212 } 213 break; 214 case 'L': 215 seen_big_l = 1; 216 f++; 217 break; 218 case 'H': 219 /* Decimal32 modifier. */ 220 seen_big_h = 1; 221 f++; 222 break; 223 case 'D': 224 /* Decimal64 and Decimal128 modifiers. */ 225 f++; 226 227 /* Check for a Decimal128. */ 228 if (*f == 'D') 229 { 230 f++; 231 seen_double_big_d = 1; 232 } 233 else 234 seen_big_d = 1; 235 break; 236 case 'z': 237 /* For size_t or ssize_t. */ 238 seen_size_t = 1; 239 f++; 240 break; 241 case 'I': 242 /* Support the Windows '%I64' extension, because an 243 earlier call to format_pieces might have converted %lld 244 to %I64d. */ 245 if (f[1] == '6' && f[2] == '4') 246 { 247 f += 3; 248 lcount = 2; 249 seen_i64 = true; 250 } 251 break; 252 } 253 254 switch (*f) 255 { 256 case 'u': 257 if (seen_hash) 258 bad = 1; 259 [[fallthrough]]; 260 261 case 'o': 262 case 'x': 263 case 'X': 264 if (seen_space || seen_plus) 265 bad = 1; 266 [[fallthrough]]; 267 268 case 'd': 269 case 'i': 270 if (seen_size_t) 271 this_argclass = size_t_arg; 272 else if (lcount == 0) 273 this_argclass = int_arg; 274 else if (lcount == 1) 275 this_argclass = long_arg; 276 else 277 this_argclass = long_long_arg; 278 279 if (seen_big_l) 280 bad = 1; 281 break; 282 283 case 'c': 284 this_argclass = lcount == 0 ? int_arg : wide_char_arg; 285 if (lcount > 1 || seen_h || seen_big_l) 286 bad = 1; 287 if (seen_prec || seen_zero || seen_space || seen_plus) 288 bad = 1; 289 break; 290 291 case 'p': 292 this_argclass = ptr_arg; 293 if (lcount || seen_h || seen_big_l) 294 bad = 1; 295 if (seen_prec) 296 bad = 1; 297 if (seen_hash || seen_zero || seen_space || seen_plus) 298 bad = 1; 299 300 if (gdb_extensions) 301 { 302 switch (f[1]) 303 { 304 case 's': 305 case 'F': 306 case '[': 307 case ']': 308 f++; 309 break; 310 } 311 } 312 313 break; 314 315 case 's': 316 this_argclass = lcount == 0 ? string_arg : wide_string_arg; 317 if (lcount > 1 || seen_h || seen_big_l) 318 bad = 1; 319 if (seen_zero || seen_space || seen_plus) 320 bad = 1; 321 break; 322 323 case 'e': 324 case 'f': 325 case 'g': 326 case 'E': 327 case 'G': 328 if (seen_double_big_d) 329 this_argclass = dec128float_arg; 330 else if (seen_big_d) 331 this_argclass = dec64float_arg; 332 else if (seen_big_h) 333 this_argclass = dec32float_arg; 334 else if (seen_big_l) 335 this_argclass = long_double_arg; 336 else 337 this_argclass = double_arg; 338 339 if (lcount || seen_h) 340 bad = 1; 341 break; 342 343 case 'V': 344 if (!value_extension) 345 error (_("Unrecognized format specifier '%c' in printf"), *f); 346 347 if (lcount > 1 || seen_h || seen_big_h || seen_big_h 348 || seen_big_d || seen_double_big_d || seen_size_t 349 || seen_prec || seen_zero || seen_space || seen_plus) 350 bad = 1; 351 352 this_argclass = value_arg; 353 354 if (f[1] == '[') 355 { 356 /* Move F forward to the next ']' character if such a 357 character exists, otherwise leave F unchanged. */ 358 const char *tmp = strchr (f, ']'); 359 if (tmp != nullptr) 360 f = tmp; 361 } 362 break; 363 364 case '*': 365 error (_("`*' not supported for precision or width in printf")); 366 367 case 'n': 368 error (_("Format specifier `n' not supported in printf")); 369 370 case '\0': 371 error (_("Incomplete format specifier at end of format string")); 372 373 default: 374 error (_("Unrecognized format specifier '%c' in printf"), *f); 375 } 376 377 if (bad) 378 error (_("Inappropriate modifiers to " 379 "format specifier '%c' in printf"), 380 *f); 381 382 f++; 383 384 sub_start = current_substring; 385 386 if (lcount > 1 && !seen_i64 && USE_PRINTF_I64) 387 { 388 /* Windows' printf does support long long, but not the usual way. 389 Convert %lld to %I64d. */ 390 int length_before_ll = f - percent_loc - 1 - lcount; 391 392 strncpy (current_substring, percent_loc, length_before_ll); 393 strcpy (current_substring + length_before_ll, "I64"); 394 current_substring[length_before_ll + 3] = 395 percent_loc[length_before_ll + lcount]; 396 current_substring += length_before_ll + 4; 397 } 398 else if (this_argclass == wide_string_arg 399 || this_argclass == wide_char_arg) 400 { 401 /* Convert %ls or %lc to %s. */ 402 int length_before_ls = f - percent_loc - 2; 403 404 strncpy (current_substring, percent_loc, length_before_ls); 405 strcpy (current_substring + length_before_ls, "s"); 406 current_substring += length_before_ls + 2; 407 } 408 else 409 { 410 strncpy (current_substring, percent_loc, f - percent_loc); 411 current_substring += f - percent_loc; 412 } 413 414 *current_substring++ = '\0'; 415 416 prev_start = f; 417 418 m_pieces.emplace_back (sub_start, this_argclass, n_int_args); 419 } 420 421 /* Record the remainder of the string. */ 422 423 if (f > prev_start) 424 { 425 sub_start = current_substring; 426 427 strncpy (current_substring, prev_start, f - prev_start); 428 current_substring += f - prev_start; 429 *current_substring++ = '\0'; 430 431 m_pieces.emplace_back (sub_start, literal_piece, 0); 432 } 433 } 434
Indexes created Sun Mar 01 05:31:48 UTC 2026