jim-format.c

   1 /*
   2  * Implements the internals of the format command for jim
   3  *
   4  * The FreeBSD license
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  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
  13  *    copyright notice, this list of conditions and the following
  14  *    disclaimer in the documentation and/or other materials
  15  *    provided with the distribution.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE JIM TCL PROJECT ``AS IS'' AND ANY
  18  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
  19  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  20  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
  21  * JIM TCL PROJECT OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
  22  * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
  23  * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  24  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  25  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  26  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  27  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  28  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  29  *
  30  * The views and conclusions contained in the software and documentation
  31  * are those of the authors and should not be interpreted as representing
  32  * official policies, either expressed or implied, of the Jim Tcl Project.
  33  *
  34  * Based on code originally from Tcl 8.5:
  35  *
  36  * Copyright (c) 1995-1997 Sun Microsystems, Inc.
  37  * Copyright (c) 1999 by Scriptics Corporation.
  38  *
  39  * See the file "tcl.license.terms" for information on usage and redistribution of
  40  * this file, and for a DISCLAIMER OF ALL WARRANTIES.
  41  */
  42 #include <ctype.h>
  43 #include <string.h>
  44
  45 #include <jim.h>
  46 #include "utf8.h"
  47
  48 #define JIM_UTF_MAX 3
  49 #define JIM_INTEGER_SPACE 24
  50 #define MAX_FLOAT_WIDTH 320
  51
  52 /**
  53  * Apply the printf-like format in fmtObjPtr with the given arguments.
  54  *
  55  * Returns a new object with zero reference count if OK, or NULL on error.
  56  */
  57 Jim_Obj *Jim_FormatString(Jim_Interp *interp, Jim_Obj *fmtObjPtr, int objc, Jim_Obj *const *objv)
  58 {
  59     const char *span, *format, *formatEnd, *msg;
  60     int numBytes = 0, objIndex = 0, gotXpg = 0, gotSequential = 0;
  61     static const char * const mixedXPG =
  62         "cannot mix \"%\" and \"%n$\" conversion specifiers";
  63     static const char * const badIndex[2] = {
  64     "not enough arguments for all format specifiers",
  65     "\"%n$\" argument index out of range"
  66     };
  67     int formatLen;
  68     Jim_Obj *resultPtr;
  69
  70     /* A single buffer is used to store numeric fields (with sprintf())
  71      * This buffer is allocated/reallocated as necessary
  72      */
  73     char *num_buffer = NULL;
  74     int num_buffer_size = 0;
  75
  76     span = format = Jim_GetString(fmtObjPtr, &formatLen);
  77     formatEnd = format + formatLen;
  78     resultPtr = Jim_NewEmptyStringObj(interp);
  79
  80     while (format != formatEnd) {
  81     char *end;
  82     int gotMinus, sawFlag;
  83     int gotPrecision, useShort;
  84     long width, precision;
  85     int newXpg;
  86     int ch;
  87     int step;
  88     int doubleType;
  89     char pad = ' ';
  90     char spec[2*JIM_INTEGER_SPACE + 12];
  91     char *p;
  92
  93     int formatted_chars;
  94     int formatted_bytes;
  95     const char *formatted_buf;
  96
  97     step = utf8_tounicode(format, &ch);
  98     format += step;
  99     if (ch != '%') {
 100         numBytes += step;
 101         continue;
 102     }
 103     if (numBytes) {
 104         Jim_AppendString(interp, resultPtr, span, numBytes);
 105         numBytes = 0;
 106     }
 107
 108     /*
 109      * Saw a % : process the format specifier.
 110      *
 111      * Step 0. Handle special case of escaped format marker (i.e., %%).
 112      */
 113
 114     step = utf8_tounicode(format, &ch);
 115     if (ch == '%') {
 116         span = format;
 117         numBytes = step;
 118         format += step;
 119         continue;
 120     }
 121
 122     /*
 123      * Step 1. XPG3 position specifier
 124      */
 125
 126     newXpg = 0;
 127     if (isdigit(ch)) {
 128         int position = strtoul(format, &end, 10);
 129         if (*end == '$') {
 130         newXpg = 1;
 131         objIndex = position - 1;
 132         format = end + 1;
 133         step = utf8_tounicode(format, &ch);
 134         }
 135     }
 136     if (newXpg) {
 137         if (gotSequential) {
 138         msg = mixedXPG;
 139         goto errorMsg;
 140         }
 141         gotXpg = 1;
 142     } else {
 143         if (gotXpg) {
 144         msg = mixedXPG;
 145         goto errorMsg;
 146         }
 147         gotSequential = 1;
 148     }
 149     if ((objIndex < 0) || (objIndex >= objc)) {
 150         msg = badIndex[gotXpg];
 151         goto errorMsg;
 152     }
 153
 154     /*
 155      * Step 2. Set of flags. Also build up the sprintf spec.
 156      */
 157     p = spec;
 158     *p++ = '%';
 159
 160     gotMinus = 0;
 161     sawFlag = 1;
 162     do {
 163         switch (ch) {
 164         case '-':
 165         gotMinus = 1;
 166         break;
 167         case '0':
 168         pad = ch;
 169         break;
 170         case ' ':
 171         case '+':
 172         case '#':
 173         break;
 174         default:
 175         sawFlag = 0;
 176         continue;
 177         }
 178         *p++ = ch;
 179         format += step;
 180         step = utf8_tounicode(format, &ch);
 181     } while (sawFlag);
 182
 183     /*
 184      * Step 3. Minimum field width.
 185      */
 186
 187     width = 0;
 188     if (isdigit(ch)) {
 189         width = strtoul(format, &end, 10);
 190         format = end;
 191         step = utf8_tounicode(format, &ch);
 192     } else if (ch == '*') {
 193         if (objIndex >= objc - 1) {
 194         msg = badIndex[gotXpg];
 195         goto errorMsg;
 196         }
 197         if (Jim_GetLong(interp, objv[objIndex], &width) != JIM_OK) {
 198         goto error;
 199         }
 200         if (width < 0) {
 201         width = -width;
 202         if (!gotMinus) {
 203             *p++ = '-';
 204             gotMinus = 1;
 205         }
 206         }
 207         objIndex++;
 208         format += step;
 209         step = utf8_tounicode(format, &ch);
 210     }
 211
 212     /*
 213      * Step 4. Precision.
 214      */
 215
 216     gotPrecision = precision = 0;
 217     if (ch == '.') {
 218         gotPrecision = 1;
 219         format += step;
 220         step = utf8_tounicode(format, &ch);
 221     }
 222     if (isdigit(ch)) {
 223         precision = strtoul(format, &end, 10);
 224         format = end;
 225         step = utf8_tounicode(format, &ch);
 226     } else if (ch == '*') {
 227         if (objIndex >= objc - 1) {
 228         msg = badIndex[gotXpg];
 229         goto errorMsg;
 230         }
 231         if (Jim_GetLong(interp, objv[objIndex], &precision) != JIM_OK) {
 232         goto error;
 233         }
 234
 235         /*
 236          * TODO: Check this truncation logic.
 237          */
 238
 239         if (precision < 0) {
 240         precision = 0;
 241         }
 242         objIndex++;
 243         format += step;
 244         step = utf8_tounicode(format, &ch);
 245     }
 246
 247     /*
 248      * Step 5. Length modifier.
 249      */
 250
 251     useShort = 0;
 252     if (ch == 'h') {
 253         useShort = 1;
 254         format += step;
 255         step = utf8_tounicode(format, &ch);
 256     } else if (ch == 'l') {
 257         /* Just for compatibility. All non-short integers are wide. */
 258         format += step;
 259         step = utf8_tounicode(format, &ch);
 260         if (ch == 'l') {
 261         format += step;
 262         step = utf8_tounicode(format, &ch);
 263         }
 264     }
 265
 266     format += step;
 267     span = format;
 268
 269     /*
 270      * Step 6. The actual conversion character.
 271      */
 272
 273     if (ch == 'i') {
 274         ch = 'd';
 275     }
 276
 277     doubleType = 0;
 278
 279     /* Each valid conversion will set:
 280      * formatted_buf   - the result to be added
 281      * formatted_chars - the length of formatted_buf in characters
 282      * formatted_bytes - the length of formatted_buf in bytes
 283      */
 284     switch (ch) {
 285     case '\0':
 286         msg = "format string ended in middle of field specifier";
 287         goto errorMsg;
 288     case 's': {
 289         formatted_buf = Jim_GetString(objv[objIndex], &formatted_bytes);
 290         formatted_chars = Jim_Utf8Length(interp, objv[objIndex]);
 291         if (gotPrecision && (precision < formatted_chars)) {
 292         /* Need to build a (null terminated) truncated string */
 293         formatted_chars = precision;
 294         formatted_bytes = utf8_index(formatted_buf, precision);
 295         }
 296         break;
 297     }
 298     case 'c': {
 299         jim_wide code;
 300
 301         if (Jim_GetWide(interp, objv[objIndex], &code) != JIM_OK) {
 302         goto error;
 303         }
 304         /* Just store the value in the 'spec' buffer */
 305         formatted_bytes = utf8_getchars(spec, code);
 306         formatted_buf = spec;
 307         formatted_chars = 1;
 308         break;
 309     }
 310     case 'b': {
 311         unsigned jim_wide w;
 312         int length;
 313         int i;
 314         int j;
 315
 316         if (Jim_GetWide(interp, objv[objIndex], (jim_wide *)&w) != JIM_OK) {
 317             goto error;
 318         }
 319         length = sizeof(w) * 8;
 320
 321         /* XXX: width and precision not yet implemented for binary
 322          *      also flags in 'spec', e.g. #, 0, -
 323          */
 324
 325         /* Increase the size of the buffer if needed */
 326         if (num_buffer_size < length + 1) {
 327             num_buffer_size = length + 1;
 328             num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
 329         }
 330
 331         j = 0;
 332         for (i = length; i > 0; ) {
 333             i--;
 334             if (w & ((unsigned jim_wide)1 << i)) {
 335                 num_buffer[j++] = '1';
 336             }
 337             else if (j || i == 0) {
 338                 num_buffer[j++] = '0';
 339             }
 340         }
 341         num_buffer[j] = 0;
 342         formatted_chars = formatted_bytes = j;
 343         formatted_buf = num_buffer;
 344         break;
 345     }
 346
 347     case 'e':
 348     case 'E':
 349     case 'f':
 350     case 'g':
 351     case 'G':
 352         doubleType = 1;
 353         /* fall through */
 354     case 'd':
 355     case 'u':
 356     case 'o':
 357     case 'x':
 358     case 'X': {
 359         jim_wide w;
 360         double d;
 361         int length;
 362
 363         /* Fill in the width and precision */
 364         if (width) {
 365         p += sprintf(p, "%ld", width);
 366         }
 367         if (gotPrecision) {
 368         p += sprintf(p, ".%ld", precision);
 369         }
 370
 371         /* Now the modifier, and get the actual value here */
 372         if (doubleType) {
 373         if (Jim_GetDouble(interp, objv[objIndex], &d) != JIM_OK) {
 374             goto error;
 375         }
 376         length = MAX_FLOAT_WIDTH;
 377         }
 378         else {
 379         if (Jim_GetWide(interp, objv[objIndex], &w) != JIM_OK) {
 380             goto error;
 381         }
 382         length = JIM_INTEGER_SPACE;
 383         if (useShort) {
 384             *p++ = 'h';
 385             if (ch == 'd') {
 386             w = (short)w;
 387             }
 388             else {
 389             w = (unsigned short)w;
 390             }
 391         }
 392         else {
 393             *p++ = 'l';
 394 #ifdef HAVE_LONG_LONG
 395             if (sizeof(long long) == sizeof(jim_wide)) {
 396             *p++ = 'l';
 397             }
 398 #endif
 399         }
 400         }
 401
 402         *p++ = (char) ch;
 403         *p = '\0';
 404
 405         /* Adjust length for width and precision */
 406         if (width > length) {
 407         length = width;
 408         }
 409         if (gotPrecision) {
 410         length += precision;
 411         }
 412
 413         /* Increase the size of the buffer if needed */
 414         if (num_buffer_size < length + 1) {
 415         num_buffer_size = length + 1;
 416         num_buffer = Jim_Realloc(num_buffer, num_buffer_size);
 417         }
 418
 419         if (doubleType) {
 420         snprintf(num_buffer, length + 1, spec, d);
 421         }
 422         else {
 423         formatted_bytes = snprintf(num_buffer, length + 1, spec, w);
 424         }
 425         formatted_chars = formatted_bytes = strlen(num_buffer);
 426         formatted_buf = num_buffer;
 427         break;
 428     }
 429
 430     default: {
 431         /* Just reuse the 'spec' buffer */
 432         spec[0] = ch;
 433         spec[1] = '\0';
 434         Jim_SetResultFormatted(interp, "bad field specifier \"%s\"", spec);
 435         goto error;
 436     }
 437     }
 438
 439     if (!gotMinus) {
 440         while (formatted_chars < width) {
 441         Jim_AppendString(interp, resultPtr, &pad, 1);
 442         formatted_chars++;
 443         }
 444     }
 445
 446     Jim_AppendString(interp, resultPtr, formatted_buf, formatted_bytes);
 447
 448     while (formatted_chars < width) {
 449         Jim_AppendString(interp, resultPtr, &pad, 1);
 450         formatted_chars++;
 451     }
 452
 453     objIndex += gotSequential;
 454     }
 455     if (numBytes) {
 456     Jim_AppendString(interp, resultPtr, span, numBytes);
 457     }
 458
 459     Jim_Free(num_buffer);
 460     return resultPtr;
 461
 462   errorMsg:
 463     Jim_SetResultString(interp, msg, -1);
 464   error:
 465     Jim_FreeNewObj(interp, resultPtr);
 466     Jim_Free(num_buffer);
 467     return NULL;
 468 }