workbench/libs/locale/formatstring.c

   1 /*
   2     Copyright © 1995-2007, The AROS Development Team. All rights reserved.
   3     $Id$
   4
   5     Desc:
   6     Lang: english
   7 */
   8
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <exec/types.h>
  12 #include <utility/hooks.h>
  13 #include <proto/utility.h>
  14 #include <libraries/locale.h>
  15 #include <aros/asmcall.h>
  16 #include "locale_intern.h"
  17
  18 #include <aros/debug.h>
  19
  20 #if USE_QUADFMT
  21 typedef QUAD  FMTLARGESTTYPE;
  22 typedef UQUAD UFMTLARGESTTYPE;
  23 #else  /* USE_QUADFMT */
  24 typedef LONG  FMTLARGESTTYPE;
  25 typedef ULONG UFMTLARGESTTYPE;
  26 #endif /* USE_QUADFMT */
  27
  28 static const UBYTE hexarray [] = "0123456789abcdef";
  29 static const UBYTE HEXarray [] = "0123456789ABCDEF";
  30
  31 /*****************************************************************************
  32
  33     NAME */
  34 #include <proto/locale.h>
  35
  36         AROS_LH4(APTR, FormatString,
  37
  38 /*  SYNOPSIS */
  39         AROS_LHA(struct Locale *, locale, A0),
  40         AROS_LHA(STRPTR         , fmtTemplate, A1),
  41         AROS_LHA(APTR           , dataStream, A2),
  42         AROS_LHA(struct Hook   *, putCharFunc, A3),
  43
  44 /*  LOCATION */
  45         struct LocaleBase *, LocaleBase, 11, Locale)
  46
  47 /*  FUNCTION
  48
  49     INPUTS
  50
  51     RESULT
  52
  53     NOTES
  54
  55     EXAMPLE
  56
  57     BUGS
  58
  59     SEE ALSO
  60
  61     INTERNALS
  62
  63     HISTORY
  64         27-11-96    digulla automatically created from
  65                             locale_lib.fd and clib/locale_protos.h
  66
  67 *****************************************************************************/
  68 {
  69   AROS_LIBFUNC_INIT
  70
  71   enum {OUTPUT = 0,
  72         FOUND_FORMAT} state;
  73
  74   ULONG template_pos;
  75   BOOL  end;
  76   ULONG max_argpos;
  77   ULONG arg_counter;
  78   ULONG *stream;
  79   BOOL  scanning;
  80
  81 #define INDICES 256
  82   UWORD indices[INDICES];
  83
  84   if (!fmtTemplate)
  85     return dataStream;
  86
  87   template_pos = 0;      /* Current position in the template string */
  88   state        = OUTPUT; /* current state of parsing */
  89   end          = FALSE;
  90   max_argpos   = 0;
  91   arg_counter  = 0;
  92   stream       = (ULONG *) dataStream;
  93   scanning     = TRUE;   /* The first time I will go through
  94                                   and determine the width of the data in the dataStream */
  95
  96 #ifdef __MORPHOS__
  97   memclr(indices, sizeof(indices));
  98 #else
  99   memset(indices, 0, sizeof(indices));
 100 #endif
 101
 102   while (!end)
 103   {
 104     /*
 105     ** A format description starts here?
 106     */
 107     if (fmtTemplate[template_pos] == '%')
 108     {
 109       arg_counter++;
 110       state = FOUND_FORMAT;
 111     }
 112
 113     switch (state)
 114     {
 115       case OUTPUT:
 116         /*
 117         ** Call the hook for this character
 118         */
 119         if (!scanning)
 120         {
 121           AROS_UFC3(VOID, putCharFunc->h_Entry,
 122             AROS_UFCA(struct Hook *,   putCharFunc,                A0),
 123             AROS_UFCA(struct Locale *, locale,                     A2),
 124             AROS_UFCA(UBYTE,           fmtTemplate[template_pos],  A1));
 125         }
 126
 127         /*
 128         ** End of template string? -> End of this function.
 129         */
 130         if (fmtTemplate[template_pos] == '\0')
 131         {
 132           if (scanning)
 133           {
 134             /*
 135             ** The scanning phase is over. Next time we do the output.
 136             */
 137             int i, sum;
 138             scanning = FALSE;
 139             template_pos = 0;
 140             arg_counter = 0;
 141             /*
 142             ** prepare the indices array
 143             */
 144             sum = indices[0];
 145             indices[0] = 0;
 146
 147             i = 1;
 148
 149             while (i <= max_argpos)
 150             {
 151               int _sum;
 152               if (indices[i] != 0)
 153                 _sum =  sum + indices[i];
 154               else
 155                 _sum =  sum + 4;
 156
 157               indices[i] =  sum;
 158               sum        = _sum;
 159               i++;
 160             }
 161           }
 162           else
 163           {
 164             /*
 165             ** We already went through the output phase. So this is
 166             ** the end of it.
 167             */
 168             end = TRUE;
 169           }
 170         }
 171         else
 172           template_pos++;
 173
 174         //kprintf("OUTPUT: template_pos: %d\n",template_pos);
 175
 176       break;
 177
 178       case FOUND_FORMAT:
 179         /*
 180         ** The '%' was found in the template string
 181         */
 182         template_pos++;
 183
 184         //kprintf("FOUND_FORMAT: template_pos: %d\n",template_pos);
 185         /*
 186         ** Does the user want the '%' to be printed?
 187         */
 188         if (fmtTemplate[template_pos] == '%')
 189         {
 190           if (!scanning)
 191           {
 192             AROS_UFC3(VOID, putCharFunc->h_Entry,
 193               AROS_UFCA(struct Hook *  , putCharFunc,                A0),
 194               AROS_UFCA(struct Locale *, locale,                     A2),
 195               AROS_UFCA(UBYTE,           fmtTemplate[template_pos],  A1));
 196           }
 197           template_pos++;
 198           arg_counter--; //stegerg
 199         }
 200         else
 201         {
 202           /*
 203           ** Now parsing...
 204           ** Template format: %[arg_pos$][flags][width][.limit][length]type
 205           **
 206           ** arg_pos specifies the position of the argument in the dataStream
 207           ** flags   only '-' is allowd
 208           ** width
 209           ** .limit
 210           ** datasize size of the datatype
 211           ** type    b,d,D,u,U,x,X,s,c
 212           */
 213           ULONG arg_pos      = 1;
 214           BOOL  left         = FALSE;  // no flag was found
 215           UBYTE fill         = ' ';
 216           ULONG minus;
 217           ULONG width        = 0;
 218           ULONG limit        = ~0;
 219           ULONG buflen        = 0;
 220           ULONG datasize;
 221           UFMTLARGESTTYPE tmp= 0;
 222 #define BUFFERSIZE 128
 223           UBYTE buf[BUFFERSIZE];
 224           UBYTE *buffer      = buf;
 225
 226           /*
 227           ** arg_pos
 228           */
 229
 230           //kprintf("next char: %c\n",fmtTemplate[template_pos]);
 231
 232           if (fmtTemplate[template_pos] >= '0' &&
 233               fmtTemplate[template_pos] <= '9')
 234           {
 235             ULONG old_template_pos = template_pos;
 236
 237             for (arg_pos = 0; (fmtTemplate[template_pos] >= '0' &&
 238                                fmtTemplate[template_pos] <= '9'); template_pos++)
 239             {
 240               arg_pos = arg_pos * 10 + fmtTemplate[template_pos] - '0';
 241             }
 242
 243             if (fmtTemplate[template_pos] == '$')
 244               template_pos++;
 245             else
 246             {
 247               arg_pos = arg_counter;
 248               template_pos = old_template_pos;
 249             }
 250           }
 251           else
 252             arg_pos = arg_counter;
 253
 254           /*
 255           ** flags
 256           */
 257           if (fmtTemplate[template_pos] == '-')
 258           {
 259             template_pos++;
 260             left = TRUE;
 261           }
 262
 263           /*
 264           ** fill character a '0'?
 265           */
 266           if (fmtTemplate[template_pos] == '0')
 267           {
 268             template_pos++;
 269             fill = '0';
 270           }
 271
 272           /*
 273           ** width
 274           */
 275           if (fmtTemplate[template_pos] >= '0' &&
 276               fmtTemplate[template_pos] <= '9')
 277           {
 278             for (width = 0; (fmtTemplate[template_pos] >= '0' &&
 279                                 fmtTemplate[template_pos] <= '9'); template_pos++)
 280             {
 281               width = width * 10 + fmtTemplate[template_pos] - '0';
 282             }
 283           }
 284
 285           /*
 286           ** limit
 287           */
 288           if (fmtTemplate[template_pos] == '.')
 289           {
 290             template_pos++;
 291
 292             if (fmtTemplate[template_pos] >= '0' &&
 293                 fmtTemplate[template_pos] <= '9')
 294             {
 295               for (limit = 0; (fmtTemplate[template_pos] >= '0' &&
 296                                   fmtTemplate[template_pos] <= '9'); template_pos++)
 297               {
 298                 limit = limit * 10 + fmtTemplate[template_pos] - '0';
 299               }
 300             }
 301           }
 302
 303           /*
 304           ** Length
 305           */
 306           switch (fmtTemplate[template_pos])
 307           {
 308 #if USE_QUADFMT
 309             case 'L':
 310               datasize = 8;
 311               template_pos++;
 312               break;
 313 #endif /* USE_QUADFMT */
 314
 315             case 'l':
 316               template_pos++;
 317 #if USE_QUADFMT
 318               if (fmtTemplate[template_pos] == 'l')
 319               {
 320                 datasize = 8;
 321                 template_pos++;
 322               }
 323               else
 324 #endif /* USE_QUADFMT */
 325                 datasize = 4;
 326               break;
 327
 328             default:
 329               datasize = 2;
 330               break;
 331           }
 332
 333           /*
 334           ** Print it according to the given type info.
 335           */
 336           switch (fmtTemplate[template_pos])
 337           {
 338             case 'b': /* BSTR, see autodocs */
 339               /*
 340               ** Important parameters:
 341               ** arg_pos, left, buflen, limit
 342               */
 343               if (!scanning)
 344               {
 345                 BSTR s = (BSTR)*(UBYTE **)(((IPTR)stream)+indices[arg_pos-1]);
 346
 347                 buffer = AROS_BSTR_ADDR(s);
 348                 buflen = AROS_BSTR_strlen(s);
 349
 350 #if !USE_GLOBALLIMIT
 351                 if (buflen > limit)
 352                   buflen = limit;
 353 #endif /* !USE_GLOBALLIMIT */
 354               }
 355               else
 356                 indices[arg_pos-1] = sizeof(BPTR);
 357             break;
 358
 359             case 'd': /* signed decimal */
 360             case 'u': /* unsigned decimal */
 361
 362               minus = fmtTemplate[template_pos] == 'd';
 363
 364               if (!scanning)
 365               {
 366                 switch (datasize)
 367                 {
 368 #if USE_QUADFMT
 369                   case 8:
 370                     tmp = *(UQUAD *)(((IPTR)stream)+indices[arg_pos-1]);
 371                     //buffer = &buf[16+1];
 372                     minus *= (FMTLARGESTTYPE) tmp < 0;
 373                     if (minus)
 374                       tmp = -tmp;
 375                     break;
 376 #endif /* USE_QUADFMT */
 377
 378                   case 4:
 379                     tmp = *(ULONG *)(((IPTR)stream)+indices[arg_pos-1]);
 380                     //buffer = &buf[8+1];
 381                     minus *= (LONG) tmp < 0;
 382                     if (minus)
 383                       tmp = (ULONG) -tmp;
 384                     break;
 385
 386                   default: /* 2 */
 387                     tmp = *(UWORD *)(((IPTR)stream)+indices[arg_pos-1]);
 388                     //buffer = &buf[4+1];
 389                     minus *= (WORD) tmp < 0;
 390                     if (minus)
 391                       tmp = (UWORD) -tmp;
 392                     break;
 393                 }
 394
 395                 buffer = &buf[BUFFERSIZE];
 396                 do
 397                 {
 398                   *--buffer = (tmp % 10) + '0';
 399                   tmp /= 10;
 400                   buflen++;
 401                 }
 402                 while (tmp);
 403
 404                 if (minus)
 405                 {
 406                   *--buffer = '-';
 407                   buflen++;
 408                 }
 409
 410               }
 411               else
 412                 indices[arg_pos-1] = datasize;
 413             break;
 414
 415             case 'D': /* signed decimal with locale's formatting conventions */
 416             case 'U': /* unsigned decimal with locale's formatting conventions */
 417               if (!scanning)
 418               {
 419                 UBYTE groupsize;
 420                 ULONG group_index = 0;
 421
 422                 minus = fmtTemplate[template_pos] == 'D';
 423
 424                 switch (datasize)
 425                 {
 426 #if USE_QUADFMT
 427                   case 8:
 428                     tmp = *(UQUAD *)(((IPTR)stream)+indices[arg_pos-1]);
 429                     minus *= (FMTLARGESTTYPE) tmp < 0;
 430                     if (minus)
 431                       tmp = -tmp;
 432                     break;
 433 #endif /* USE_QUADFMT */
 434
 435                   case 4:
 436                     tmp = *(ULONG *)(((IPTR)stream)+indices[arg_pos-1]);
 437                     minus *= (LONG) tmp < 0;
 438                     if (minus)
 439                       tmp = (ULONG) -tmp;
 440                     break;
 441
 442                   default: /* 2 */
 443                     tmp = *(UWORD *)(((IPTR)stream)+indices[arg_pos-1]);
 444                     minus *= (WORD) tmp < 0;
 445                     if (minus)
 446                       tmp = (UWORD) -tmp;
 447                     break;
 448                 }
 449
 450                 /* BUFFERSIZE should be big enough to format a string
 451                 ** according to locale's formatting conventions
 452                 */
 453                 buffer = &buf[BUFFERSIZE];
 454                 groupsize = locale ? locale->loc_Grouping[group_index] : 255;
 455
 456                 do
 457                 {
 458                   *--buffer = (tmp % 10) + '0';
 459                   tmp /= 10;
 460                   buflen++;
 461
 462                   groupsize--;
 463
 464                   if (groupsize == 0 && tmp != 0)
 465                   {
 466                     /*
 467                     ** Write the separator
 468                     */
 469
 470                     *--buffer = locale->loc_GroupSeparator[group_index];
 471
 472                     groupsize = locale->loc_Grouping[group_index+1];
 473
 474                     if (groupsize == 0)
 475                     {
 476                       /*
 477                       ** Supposed to use the previous element
 478                       */
 479                       groupsize = locale->loc_Grouping[group_index];
 480                     }
 481                     else
 482                       group_index++;
 483
 484                     buflen++;
 485                   }
 486                 }
 487                 while (tmp);
 488
 489                 if (minus)
 490                 {
 491                   *--buffer = '-';
 492                   buflen++;
 493                 }
 494               }
 495               else
 496                 indices[arg_pos-1] = datasize;
 497             break;
 498
 499             case 'x': /* upper case hexadecimal string */
 500             case 'X': /* lower case hexadecimal string */
 501             case 'p': /* lower case pointer string */
 502             case 'P': /* upper case pointer string */
 503
 504               if (!scanning)
 505               {
 506                 const UBYTE *hexa;
 507
 508                 /* %p is always at least natural pointer size (32bit) */
 509                 if (datasize < sizeof(void *) && (fmtTemplate[template_pos] == 'p' ||
 510                                                   fmtTemplate[template_pos] == 'P'))
 511                 {
 512                   datasize = sizeof(void *);
 513                 }
 514
 515                 switch (datasize)
 516                 {
 517 #if USE_QUADFMT
 518                   case 8:
 519                     tmp = *(UQUAD *)(((IPTR)stream)+indices[arg_pos-1]);
 520                     //buffer = &buf[16+1];
 521                     break;
 522 #endif /* USE_QUADFMT */
 523
 524                   case 4:
 525                     tmp = *(ULONG *)(((IPTR)stream)+indices[arg_pos-1]);
 526                     //buffer = &buf[8+1];
 527                     break;
 528
 529                   default: /* 2 */
 530                     tmp = *(UWORD *)(((IPTR)stream)+indices[arg_pos-1]);
 531                     //buffer = &buf[4+1];
 532                     break;
 533                 }
 534
 535                 buffer = &buf[BUFFERSIZE];
 536
 537                 /* NOTE: x/X is reverse to printf, coz orig RawDoFmt %lx for uppercase. */
 538                 hexa = (fmtTemplate[template_pos] == 'X' ||
 539                         fmtTemplate[template_pos] == 'p') ? hexarray : HEXarray;
 540                 do
 541                 {
 542                   *--buffer = hexa[tmp&0x0f];
 543                   tmp >>= 4;
 544                   buflen++;
 545                 }
 546                 while (tmp);
 547               }
 548               else
 549                 indices[arg_pos-1] = datasize;
 550             break;
 551
 552             case 's': /* NULL terminated string */
 553             {
 554               if (!scanning)
 555               {
 556                 buffer = *(UBYTE **)(((IPTR)stream)+indices[arg_pos-1]);
 557                 if (!buffer)
 558                 {
 559                     buffer = "(null)";
 560                     buflen = 7;
 561                 }
 562                 else
 563                     buflen = strlen(buffer);
 564
 565 #if !USE_GLOBALLIMIT
 566                 if (buflen > limit)
 567                   buflen = limit;
 568 #endif /* !USE_GLOBALLIMIT */
 569               }
 570               else
 571                 indices[arg_pos-1] = sizeof(UBYTE *); /* the pointer has 4 bytes */
 572             }
 573             break;
 574
 575             case 'c': /* Character */
 576               if (!scanning)
 577               {
 578                 switch (datasize)
 579                 {
 580 #if USE_QUADFMT
 581                   case 8:
 582                     buf[0] = (UBYTE)*(UQUAD *)(((IPTR)stream)+indices[arg_pos-1]);
 583                     break;
 584 #endif /* USE_QUADFMT */
 585
 586                   case 4:
 587                     buf[0] = (UBYTE)*(ULONG *)(((IPTR)stream)+indices[arg_pos-1]);
 588                     break;
 589
 590                   default: /* 2 */
 591                     buf[0] = (UBYTE)*(WORD  *)(((IPTR)stream)+indices[arg_pos-1]);
 592                     break;
 593                 }
 594
 595                 buflen = 1;
 596               }
 597               else
 598                 indices[arg_pos-1] = datasize;
 599             break;
 600
 601             default:
 602               /* Ignore the faulty '%' */
 603
 604               if (!scanning)
 605               {
 606                 buf[0] = fmtTemplate[template_pos];
 607                 width = 1;
 608                 buflen = 1;
 609               }
 610
 611               arg_pos = --arg_counter;
 612             break;
 613           }
 614
 615
 616           if (!scanning)
 617           {
 618             int i;
 619
 620             /*
 621                Now everything I need is known:
 622                buffer  - contains the string to be printed
 623                buflen  - size of the string
 624                fill    - the pad character
 625                left    - is 1 if the string should be left aligned
 626                width   - is the minimal width of the field
 627                limit   - maximum number of characters to output from a string, default ~0
 628             */
 629
 630 #if USE_GLOBALLIMIT
 631             if (buflen > limit)
 632                buflen = limit;
 633 #endif /* USE_GLOBALLIMIT */
 634
 635             /* Print padding if right aligned */
 636             if (!left)
 637               for (i = buflen; i < width; i++)
 638                 AROS_UFC3(VOID, putCharFunc->h_Entry,
 639                   AROS_UFCA(struct Hook *,   putCharFunc         , A0),
 640                   AROS_UFCA(struct Locale *, locale              , A2),
 641                   AROS_UFCA(UBYTE,           fill                , A1)
 642                 );
 643
 644             /* Print body up to buflen */
 645             for (i = 0; i < buflen; i++)
 646             {
 647               AROS_UFC3(VOID, putCharFunc->h_Entry,
 648                 AROS_UFCA(struct Hook *,   putCharFunc         , A0),
 649                 AROS_UFCA(struct Locale *, locale              , A2),
 650                 AROS_UFCA(UBYTE,           *buffer++           , A1)
 651               );
 652             }
 653
 654             /* Pad right if left aligned */
 655             if (left)
 656               for (i = buflen; i < width; i++)
 657                 AROS_UFC3(VOID, putCharFunc->h_Entry,
 658                   AROS_UFCA(struct Hook *,   putCharFunc         , A0),
 659                   AROS_UFCA(struct Locale *, locale              , A2),
 660                   AROS_UFCA(UBYTE,           fill                , A1)
 661                 );
 662           }
 663
 664           template_pos++;
 665
 666           if (arg_pos > max_argpos)
 667             max_argpos = arg_pos;
 668
 669         }
 670         state = OUTPUT;
 671       break;
 672     }
 673   }
 674
 675   return (APTR) (((IPTR)stream) + indices[max_argpos]);
 676
 677   AROS_LIBFUNC_EXIT
 678 } /* FormatString */