lib/libc/gen/fmtcheck.c

   1 /*-
   2  * Copyright (c) 2000 The NetBSD Foundation, Inc.
   3  * All rights reserved.
   4  *
   5  * This code was contributed to The NetBSD Foundation by Allen Briggs.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions
   9  * are met:
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  * 2. Redistributions in binary form must reproduce the above copyright
  13  *    notice, this list of conditions and the following disclaimer in the
  14  *    documentation and/or other materials provided with the distribution.
  15  * 3. All advertising materials mentioning features or use of this software
  16  *    must display the following acknowledgement:
  17  *        This product includes software developed by the NetBSD
  18  *        Foundation, Inc. and its contributors.
  19  * 4. Neither the name of The NetBSD Foundation nor the names of its
  20  *    contributors may be used to endorse or promote products derived
  21  *    from this software without specific prior written permission.
  22  *
  23  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  24  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  25  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  26  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  27  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  28  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  29  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  30  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  31  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  32  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  33  * POSSIBILITY OF SUCH DAMAGE.
  34  *
  35  * $NetBSD: fmtcheck.c,v 1.2 2000/11/01 01:17:20 briggs Exp $
  36  * $FreeBSD: src/lib/libc/gen/fmtcheck.c,v 1.9 2008/08/02 06:02:42 das Exp $
  37  * $DragonFly: src/lib/libc/gen/fmtcheck.c,v 1.3 2003/08/22 19:31:21 asmodai Exp $
  38  */
  39
  40 #include <stdio.h>
  41 #include <string.h>
  42 #include <ctype.h>
  43
  44 __weak_reference(__fmtcheck, fmtcheck);
  45
  46 enum __e_fmtcheck_types {
  47         FMTCHECK_START,
  48         FMTCHECK_SHORT,
  49         FMTCHECK_INT,
  50         FMTCHECK_WINTT,
  51         FMTCHECK_LONG,
  52         FMTCHECK_QUAD,
  53         FMTCHECK_INTMAXT,
  54         FMTCHECK_PTRDIFFT,
  55         FMTCHECK_SIZET,
  56         FMTCHECK_CHARPOINTER,
  57         FMTCHECK_SHORTPOINTER,
  58         FMTCHECK_INTPOINTER,
  59         FMTCHECK_LONGPOINTER,
  60         FMTCHECK_QUADPOINTER,
  61         FMTCHECK_INTMAXTPOINTER,
  62         FMTCHECK_PTRDIFFTPOINTER,
  63         FMTCHECK_SIZETPOINTER,
  64 #ifndef NO_FLOATING_POINT
  65         FMTCHECK_DOUBLE,
  66         FMTCHECK_LONGDOUBLE,
  67 #endif
  68         FMTCHECK_STRING,
  69         FMTCHECK_WSTRING,
  70         FMTCHECK_WIDTH,
  71         FMTCHECK_PRECISION,
  72         FMTCHECK_DONE,
  73         FMTCHECK_UNKNOWN
  74 };
  75 typedef enum __e_fmtcheck_types EFT;
  76
  77 enum e_modifier {
  78         MOD_NONE,
  79         MOD_CHAR,
  80         MOD_SHORT,
  81         MOD_LONG,
  82         MOD_QUAD,
  83         MOD_INTMAXT,
  84         MOD_LONGDOUBLE,
  85         MOD_PTRDIFFT,
  86         MOD_SIZET,
  87 };
  88
  89 #define RETURN(pf,f,r) do { \
  90                         *(pf) = (f); \
  91                         return r; \
  92                        } /*NOTREACHED*/ /*CONSTCOND*/ while (0)
  93
  94 static EFT
  95 get_next_format_from_precision(const char **pf)
  96 {
  97         enum e_modifier modifier;
  98         const char      *f;
  99
 100         f = *pf;
 101         switch (*f) {
 102         case 'h':
 103                 f++;
 104                 if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
 105                 if (*f == 'h') {
 106                         f++;
 107                         modifier = MOD_CHAR;
 108                 } else {
 109                         modifier = MOD_SHORT;
 110                 }
 111                 break;
 112         case 'j':
 113                 f++;
 114                 modifier = MOD_INTMAXT;
 115                 break;
 116         case 'l':
 117                 f++;
 118                 if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
 119                 if (*f == 'l') {
 120                         f++;
 121                         modifier = MOD_QUAD;
 122                 } else {
 123                         modifier = MOD_LONG;
 124                 }
 125                 break;
 126         case 'q':
 127                 f++;
 128                 modifier = MOD_QUAD;
 129                 break;
 130         case 't':
 131                 f++;
 132                 modifier = MOD_PTRDIFFT;
 133                 break;
 134         case 'z':
 135                 f++;
 136                 modifier = MOD_SIZET;
 137                 break;
 138         case 'L':
 139                 f++;
 140                 modifier = MOD_LONGDOUBLE;
 141                 break;
 142         default:
 143                 modifier = MOD_NONE;
 144                 break;
 145         }
 146         if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
 147         if (strchr("diouxX", *f)) {
 148                 switch (modifier) {
 149                 case MOD_LONG:
 150                         RETURN(pf,f,FMTCHECK_LONG);
 151                 case MOD_QUAD:
 152                         RETURN(pf,f,FMTCHECK_QUAD);
 153                 case MOD_INTMAXT:
 154                         RETURN(pf,f,FMTCHECK_INTMAXT);
 155                 case MOD_PTRDIFFT:
 156                         RETURN(pf,f,FMTCHECK_PTRDIFFT);
 157                 case MOD_SIZET:
 158                         RETURN(pf,f,FMTCHECK_SIZET);
 159                 case MOD_CHAR:
 160                 case MOD_SHORT:
 161                 case MOD_NONE:
 162                         RETURN(pf,f,FMTCHECK_INT);
 163                 default:
 164                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 165                 }
 166         }
 167         if (*f == 'n') {
 168                 switch (modifier) {
 169                 case MOD_CHAR:
 170                         RETURN(pf,f,FMTCHECK_CHARPOINTER);
 171                 case MOD_SHORT:
 172                         RETURN(pf,f,FMTCHECK_SHORTPOINTER);
 173                 case MOD_LONG:
 174                         RETURN(pf,f,FMTCHECK_LONGPOINTER);
 175                 case MOD_QUAD:
 176                         RETURN(pf,f,FMTCHECK_QUADPOINTER);
 177                 case MOD_INTMAXT:
 178                         RETURN(pf,f,FMTCHECK_INTMAXTPOINTER);
 179                 case MOD_PTRDIFFT:
 180                         RETURN(pf,f,FMTCHECK_PTRDIFFTPOINTER);
 181                 case MOD_SIZET:
 182                         RETURN(pf,f,FMTCHECK_SIZETPOINTER);
 183                 case MOD_NONE:
 184                         RETURN(pf,f,FMTCHECK_INTPOINTER);
 185                 default:
 186                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 187                 }
 188         }
 189         if (strchr("DOU", *f)) {
 190                 if (modifier != MOD_NONE)
 191                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 192                 RETURN(pf,f,FMTCHECK_LONG);
 193         }
 194 #ifndef NO_FLOATING_POINT
 195         if (strchr("aAeEfFgG", *f)) {
 196                 switch (modifier) {
 197                 case MOD_LONGDOUBLE:
 198                         RETURN(pf,f,FMTCHECK_LONGDOUBLE);
 199                 case MOD_LONG:
 200                 case MOD_NONE:
 201                         RETURN(pf,f,FMTCHECK_DOUBLE);
 202                 default:
 203                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 204                 }
 205         }
 206 #endif
 207         if (*f == 'c') {
 208                 switch (modifier) {
 209                 case MOD_LONG:
 210                         RETURN(pf,f,FMTCHECK_WINTT);
 211                 case MOD_NONE:
 212                         RETURN(pf,f,FMTCHECK_INT);
 213                 default:
 214                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 215                 }
 216         }
 217         if (*f == 'C') {
 218                 if (modifier != MOD_NONE)
 219                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 220                 RETURN(pf,f,FMTCHECK_WINTT);
 221         }
 222         if (*f == 's') {
 223                 switch (modifier) {
 224                 case MOD_LONG:
 225                         RETURN(pf,f,FMTCHECK_WSTRING);
 226                 case MOD_NONE:
 227                         RETURN(pf,f,FMTCHECK_STRING);
 228                 default:
 229                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 230                 }
 231         }
 232         if (*f == 'S') {
 233                 if (modifier != MOD_NONE)
 234                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 235                 RETURN(pf,f,FMTCHECK_WSTRING);
 236         }
 237         if (*f == 'p') {
 238                 if (modifier != MOD_NONE)
 239                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 240                 RETURN(pf,f,FMTCHECK_LONG);
 241         }
 242         RETURN(pf,f,FMTCHECK_UNKNOWN);
 243         /*NOTREACHED*/
 244 }
 245
 246 static EFT
 247 get_next_format_from_width(const char **pf)
 248 {
 249         const char      *f;
 250
 251         f = *pf;
 252         if (*f == '.') {
 253                 f++;
 254                 if (*f == '*') {
 255                         RETURN(pf,f,FMTCHECK_PRECISION);
 256                 }
 257                 /* eat any precision (empty is allowed) */
 258                 while (isdigit(*f)) f++;
 259                 if (!*f) RETURN(pf,f,FMTCHECK_UNKNOWN);
 260         }
 261         RETURN(pf,f,get_next_format_from_precision(pf));
 262         /*NOTREACHED*/
 263 }
 264
 265 static EFT
 266 get_next_format(const char **pf, EFT eft)
 267 {
 268         int             infmt;
 269         const char      *f;
 270
 271         if (eft == FMTCHECK_WIDTH) {
 272                 (*pf)++;
 273                 return get_next_format_from_width(pf);
 274         } else if (eft == FMTCHECK_PRECISION) {
 275                 (*pf)++;
 276                 return get_next_format_from_precision(pf);
 277         }
 278
 279         f = *pf;
 280         infmt = 0;
 281         while (!infmt) {
 282                 f = strchr(f, '%');
 283                 if (f == NULL)
 284                         RETURN(pf,f,FMTCHECK_DONE);
 285                 f++;
 286                 if (!*f)
 287                         RETURN(pf,f,FMTCHECK_UNKNOWN);
 288                 if (*f != '%')
 289                         infmt = 1;
 290                 else
 291                         f++;
 292         }
 293
 294         /* Eat any of the flags */
 295         while (*f && (strchr("#'0- +", *f)))
 296                 f++;
 297
 298         if (*f == '*') {
 299                 RETURN(pf,f,FMTCHECK_WIDTH);
 300         }
 301         /* eat any width */
 302         while (isdigit(*f)) f++;
 303         if (!*f) {
 304                 RETURN(pf,f,FMTCHECK_UNKNOWN);
 305         }
 306
 307         RETURN(pf,f,get_next_format_from_width(pf));
 308         /*NOTREACHED*/
 309 }
 310
 311 const char *
 312 __fmtcheck(const char *f1, const char *f2)
 313 {
 314         const char      *f1p, *f2p;
 315         EFT             f1t, f2t;
 316
 317         if (!f1) return f2;
 318
 319         f1p = f1;
 320         f1t = FMTCHECK_START;
 321         f2p = f2;
 322         f2t = FMTCHECK_START;
 323         while ((f1t = get_next_format(&f1p, f1t)) != FMTCHECK_DONE) {
 324                 if (f1t == FMTCHECK_UNKNOWN)
 325                         return f2;
 326                 f2t = get_next_format(&f2p, f2t);
 327                 if (f1t != f2t)
 328                         return f2;
 329         }
 330         return f1;
 331 }