workbench/libs/locale/formatstring.c

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