libchill/format.c

   1 /* Implement Input/Output runtime actions for CHILL.
   2    Copyright (C) 1992,1993 Free Software Foundation, Inc.
   3    Author: Wilfried Moser, et al
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC 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 2, or (at your option)
  10 any later version.
  11
  12 GNU CC 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 GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 /* As a special exception, if you link this library with other files,
  23    some of which are compiled with GCC, to produce an executable,
  24    this library does not by itself cause the resulting executable
  25    to be covered by the GNU General Public License.
  26    This exception does not however invalidate any other reasons why
  27    the executable file might be covered by the GNU General Public License.  */
  28
  29 #include <limits.h>
  30 #include <string.h>
  31 #include <ctype.h>
  32 #include <setjmp.h>
  33 #include <float.h>
  34 #include <math.h>
  35 #include <stdlib.h>
  36 #if _TEXTIO_DEBUG_
  37 #include <stdio.h>
  38 #endif
  39
  40 #include "bitstring.h"
  41 #include "auxtypes.h"
  42 #include "iomodes.h"
  43 #include "format.h"
  44 #include "fileio.h"
  45 #include "ioerror.h"
  46
  47 #define CH_BYTE_MIN   0xffffff80L
  48 #define CH_BYTE_MAX   0x0000007fL
  49 #define CH_UBYTE_MAX  0x000000ffUL
  50 #define CH_INT_MIN    0xffff8000L
  51 #define CH_INT_MAX    0x00007fffL
  52 #define CH_UINT_MAX   0x0000ffffUL
  53 #define CH_LONG_MIN   0x80000000L
  54 #define CH_LONG_MAX   0x7fffffffL
  55 #define CH_ULONG_MAX  0xffffffffUL
  56
  57 #ifndef M_LN2
  58 #define M_LN2   0.69314718055994530942
  59 #endif
  60 #ifndef M_LN10
  61 #define M_LN10          2.30258509299404568402
  62 #endif
  63
  64 #define DMANTDIGS  (1 + (int)(DBL_MANT_DIG * M_LN2 / M_LN10))
  65 #define FMANTDIGS  (1 + (int)(FLT_MANT_DIG * M_LN2 / M_LN10))
  66
  67 /* float register length */
  68 #define MAXPREC 40
  69
  70 #define LET 0x0001
  71 #define BIN 0x0002
  72 #define DEC 0x0004
  73 #define OCT 0x0008
  74 #define HEX 0x0010
  75 #define USC 0x0020
  76 #define BIL 0x0040
  77 #define SPC 0x0080
  78 #define SCS 0x0100
  79 #define IOC 0x0200
  80 #define EDC 0x0400
  81 #define CVC 0x0800
  82
  83 #define isDEC(c)  ( chartab[(c)] & DEC )
  84 #define isCVC(c)  ( chartab[(c)] & CVC )
  85 #define isEDC(c)  ( chartab[(c)] & EDC )
  86 #define isIOC(c)  ( chartab[(c)] & IOC )
  87 #define isUSC(c)
  88 #define isXXX(c,XXX)  ( chartab[(c)] & XXX )
  89
  90 /*
  91  *  local definitions
  92  */
  93
  94 static
  95 short int chartab[256] = {
  96   0, 0, 0, 0, 0, 0, 0, 0,
  97   0, SPC, SPC, SPC, SPC, SPC, 0, 0,
  98
  99   0, 0, 0, 0, 0, 0, 0, 0,
 100   0, 0, 0, 0, 0, 0, 0, 0,
 101
 102   SPC, IOC, 0, 0, 0, 0, 0, 0,
 103   SCS, SCS, SCS, SCS+IOC, SCS, SCS+IOC, SCS, SCS+IOC,
 104   BIN+OCT+DEC+HEX, BIN+OCT+DEC+HEX, OCT+DEC+HEX, OCT+DEC+HEX, OCT+DEC+HEX,
 105      OCT+DEC+HEX, OCT+DEC+HEX, OCT+DEC+HEX,
 106   DEC+HEX, DEC+HEX, SCS, SCS, SCS+EDC, SCS+IOC, SCS+EDC, IOC,
 107
 108   0, LET+HEX+BIL, LET+HEX+BIL+CVC, LET+HEX+BIL+CVC, LET+HEX+BIL, LET+HEX,
 109      LET+HEX+CVC, LET,
 110   LET+BIL+CVC, LET, LET, LET, LET, LET, LET, LET+CVC,
 111
 112   LET, LET, LET, LET, LET+EDC, LET, LET, LET,
 113   LET+EDC, LET, LET, SCS, 0, SCS, 0, USC,
 114
 115   0, LET+HEX, LET+HEX, LET+HEX, LET+HEX, LET+HEX, LET+HEX, LET,
 116   LET, LET, LET, LET, LET, LET, LET, LET,
 117
 118   LET, LET, LET, LET, LET, LET, LET, LET,
 119   LET, LET, LET, 0, 0, 0, 0, 0
 120 };
 121
 122 typedef enum {
 123   FormatText, FirstPercent, RepFact, ConvClause, EditClause, ClauseEnd,
 124   AfterWidth, FractWidth, FractWidthCont, ExpoWidth, ExpoWidthCont,
 125   ClauseWidth, CatchPadding, LastPercent
 126 } fcsstate_t;
 127
 128 #define CONVERSIONCODES "CHOBF"
 129 typedef enum {
 130   DefaultConv, HexConv, OctalConv, BinaryConv, ScientConv
 131 } convcode_t;
 132
 133 static
 134 short int base[4] = { 10, 16, 8, 2 };
 135
 136 static
 137 short int dset[4] = { DEC, HEX, OCT, BIN };
 138
 139 #define EDITCODES "X<>T"
 140 typedef enum {
 141   SpaceSkip, SkipLeft, SkipRight, Tabulation
 142 } editcode_t;
 143
 144 #define IOCODES "/+-?!="
 145 typedef enum {
 146   NextRecord, NextPage, CurrentLine, Prompt, Emit, EndPage
 147 } iocode_t;
 148
 149 typedef enum {
 150   ConvAct, EditAct, IOAct
 151 } acttype_t;
 152
 153 typedef enum {
 154   NormalEnd, EndAtParen, TextFailEnd
 155 } formatexit_t;
 156
 157 static
 158 double ep_1[10] = {
 159   1e0, 1e1, 1e2, 1e3, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9 };
 160 static
 161 double ep_10[10] = {
 162   1e0, 1e10, 1e20, 1e30, 1e40, 1e50, 1e60, 1e70, 1e80, 1e90 };
 163 static
 164 double ep_100 = 1e100;
 165
 166 /* float register */
 167 static
 168 unsigned char floatdig[MAXPREC];
 169
 170 /*
 171  *  global io variables
 172  */
 173
 174 static Text_Mode*      textptr = NULL;
 175 static VarString*      textrecptr;
 176
 177 static int             actual_index;
 178 static int             maximum_index;
 179 static int             iolist_index;
 180
 181 static __tmp_IO_list*  iolistptr;
 182 static int             iolistlen;
 183 static char*           iostrptr;
 184 static int             iostrlen;
 185
 186
 187 static convcode_t     convcode;
 188 static editcode_t     editcode;
 189 static iocode_t       iocode;
 190 static unsigned long  repetition;
 191 static Boolean        leftadjust;
 192 static Boolean        overflowev;
 193 static Boolean        dynamicwid;
 194 static Boolean        paddingdef;
 195 static char           paddingchar;
 196 static Boolean        fractiondef;
 197 static unsigned long  fractionwidth;
 198 static Boolean        exponentdef;
 199 static unsigned long  exponentwidth;
 200 static unsigned long  clausewidth;
 201 static signed long    textindex;
 202
 203 static
 204 __tmp_IO_enum_table_type bool_tab[] =
 205    { { 0, "FALSE" },
 206      { 1, "TRUE"  },
 207      { 0 , NULL   }  };
 208
 209 /*
 210  * case insensitive compare: s1 is zero delimited, s2 has n chars
 211  */
 212 static
 213 int casncmp( const char* s1, const char* s2, int n )
 214 {
 215   int res = 0;
 216   while( n-- )
 217   {
 218     if( (res = toupper(*s1++) - toupper(*s2++)) )
 219       return res;
 220   }
 221   return *s1;
 222 }
 223
 224 /*
 225  * skip spaces with blank equal to tab
 226  */
 227 static
 228 int skip_space( int limit )
 229 {
 230   int skipped = 0;
 231   while( actual_index < limit &&
 232          (iostrptr[actual_index] == ' ' || iostrptr[actual_index] == '\t' ) )
 233   {
 234     actual_index++;
 235     skipped++;
 236   }
 237   return skipped;
 238 }
 239
 240 /*
 241  * skip leading pad characters
 242  */
 243 static
 244 int skip_pad( int limit )
 245 {
 246   int skipped = 0;
 247   while( actual_index < limit && iostrptr[actual_index] == paddingchar )
 248   {
 249     actual_index++;
 250     skipped++;
 251   }
 252 #if _TEXTIO_DEBUG_
 253   printf( "skipping '%c' until %d: %d\n", paddingchar, limit, skipped );
 254 #endif
 255   return skipped;
 256 }
 257
 258 /*
 259  * backup trailing pad characters
 260  */
 261 static
 262 int piks_pad( int start, int limit )
 263 {
 264   int skipped = 0;
 265   while( start >/***=*/ limit && iostrptr[--start] == paddingchar )
 266   {
 267     skipped++;
 268   }
 269 #if _TEXTIO_DEBUG_
 270   printf( "piksing '%c' from %d until %d: %d\n",
 271           paddingchar, start, limit, skipped );
 272 #endif
 273   return skipped;
 274 }
 275
 276 /*
 277  * parse an integer
 278  */
 279 static
 280 int parse_int( int limit, int SET, int base,
 281                unsigned long* valptr, int* signptr )
 282 {
 283   int           parsed = actual_index;
 284   Boolean       digits = False;
 285   unsigned long value  = 0;
 286   char          curr;
 287   int           dig;
 288
 289   if( actual_index >= limit )
 290     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_INT );
 291   *signptr = +1;
 292   if( iostrptr[actual_index] == '+' )
 293     actual_index++;
 294   else
 295     if( iostrptr[actual_index] == '-' )
 296     {  *signptr = -1;
 297        actual_index++;
 298     }
 299
 300   for( ; actual_index < limit; actual_index++ )
 301   {
 302     curr = iostrptr[actual_index];
 303     if( curr == '_' ) continue;
 304     if( isXXX(curr,SET) )
 305     {
 306       digits = True;
 307       dig = curr <= '9' ? curr - '0' : toupper(curr) - 'A' + 10;
 308       if( value > (ULONG_MAX - dig)/base )
 309         IOEXCEPTION( TEXTFAIL, INT_VAL_OVERFLOW );
 310       value = value*base + dig;
 311       continue;
 312     }
 313     break;
 314   }
 315   if( !digits )
 316     IOEXCEPTION( TEXTFAIL, NO_DIGITS_FOR_INT );
 317
 318   *valptr = value;
 319 #if _TEXTIO_DEBUG_
 320   printf( "parsing for int until %d, base %d: %u\n", limit, base, value );
 321 #endif
 322   return actual_index - parsed;
 323 }
 324
 325 static
 326 double
 327 make_float( int dexp, int sign )
 328 {
 329   double value = atof( floatdig );
 330 #if _TEXTIO_DEBUG_
 331   printf( " value = %25.20e, dexp = %d\n", value, dexp );
 332 #endif
 333   while( dexp >= 100 )
 334     value *= ep_100, dexp -= 100;
 335   if( dexp >= 10 )
 336     value *= ep_10[dexp/10], dexp %= 10;
 337   if( dexp > 0 )
 338     value *= ep_1[dexp];
 339
 340   while( dexp <= -100 )
 341     value /= ep_100, dexp += 100;
 342   if( dexp <= -10 )
 343     value /= ep_10[-dexp/10], dexp %= 10;
 344   if( dexp < 0 )
 345     value /= ep_1[-dexp];
 346
 347   return  sign ? -value : value;
 348 }
 349
 350 /* %C -> fixed point   [+|-]<digit>+[.<digit>*]  */
 351 static
 352 int parse_fixedpoint( int limit, double* valptr )
 353 {
 354   int           parsed = actual_index;
 355   Boolean       digits = False;
 356   int           sdig = 0;
 357   double        value;
 358   char          curr;
 359   int           sign = False;
 360   int           expo = 0;
 361
 362   if( actual_index >= limit )
 363     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_FLOAT );
 364   if( iostrptr[actual_index] == '+' )
 365     actual_index++;
 366   else
 367     if( iostrptr[actual_index] == '-' )
 368     {
 369        sign = True;
 370        actual_index++;
 371     }
 372
 373   floatdig[0] = '.';
 374   for( ; actual_index < limit; actual_index++ )
 375   {
 376     curr = iostrptr[actual_index];
 377     if( ! isDEC(curr) )
 378       break;
 379     digits = True;
 380     if( sdig < MAXPREC - 1 )
 381     {
 382       if( sdig || curr != '0' )
 383       {
 384         floatdig[++sdig] = curr;
 385         expo++;
 386       }
 387     }
 388     else
 389       if( sdig )
 390         expo++;
 391   }
 392   if( digits && curr == '.' )
 393   {
 394     actual_index++;
 395     for( ; actual_index < limit; actual_index++ )
 396     {
 397       curr = iostrptr[actual_index];
 398       if( !isDEC(curr) )
 399         break;
 400       if( sdig < MAXPREC - 1 )
 401       {
 402         if( sdig || curr != '0' )
 403           floatdig[++sdig] = curr;
 404         else
 405           expo--;
 406       }
 407     }
 408   }
 409   floatdig[++sdig] = '\0';
 410
 411   if( !digits )
 412     IOEXCEPTION( TEXTFAIL, NO_DIGITS_FOR_FLOAT );
 413
 414   *valptr = make_float( expo, sign);
 415   return actual_index - parsed;
 416 }
 417
 418
 419 typedef enum {
 420   s_sign, s_dig, s_period, s_fraca, s_fracb, s_expo, s_exposign,
 421   s_expoa, s_expob }
 422 scient_t;
 423
 424 /* %C -> scientific   [+|-]<digit>[.<digit>*]E[=|-]<digit>+  */
 425 static
 426 int parse_scientific( int limit, double* valptr, double dmin, double dmax )
 427 {
 428   int           parsed = actual_index;
 429   int           sdig = 0;
 430   char          curr;
 431   double        value;
 432   int           sign = False;
 433   int           expo = 0;
 434   int           expo_sign = +1;
 435
 436   scient_t      state = s_sign;
 437
 438   if( actual_index >= limit )
 439     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_FLOAT );
 440
 441   floatdig[0] = '.';
 442   for( ; actual_index < limit; actual_index++ )
 443   {
 444     curr = iostrptr[actual_index];
 445     switch( state )
 446     {
 447     case s_sign:
 448       if( iostrptr[actual_index] == '+' )
 449       {
 450         state = s_dig;
 451         break;
 452       }
 453       if( iostrptr[actual_index] == '-' )
 454       {
 455         sign = True;
 456         state = s_dig;
 457         break;
 458       }
 459       /* fall through - no break */
 460     case s_dig:
 461       if( isDEC(curr) && curr > '0' )
 462       {
 463         floatdig[++sdig] = curr;
 464         state = s_period;
 465         break;
 466       }
 467       IOEXCEPTION( TEXTFAIL, NO_DIGITS_FOR_FLOAT );
 468     case s_period:
 469       if( curr == '.' )
 470       {
 471         state = s_fraca;
 472         break;
 473       }
 474       if( curr == 'E' )
 475       {
 476         state = s_exposign;
 477         break;
 478       }
 479       IOEXCEPTION( TEXTFAIL, NO_EXPONENT );
 480     case s_fraca:
 481       if( isDEC(curr) )
 482       {
 483         floatdig[++sdig] = curr;
 484         state = s_fracb;
 485         break;
 486       }
 487       IOEXCEPTION( TEXTFAIL, NO_DIGITS_FOR_FLOAT );
 488     case s_fracb:
 489       if( isDEC(curr) )
 490       {
 491         if( sdig < MAXPREC - 1 )
 492           floatdig[++sdig] = curr;
 493         break;
 494       }
 495       if( curr == 'E' )
 496       {
 497         state = s_exposign;
 498         break;
 499       }
 500       IOEXCEPTION( TEXTFAIL, NO_EXPONENT );
 501     case s_exposign:
 502       if( iostrptr[actual_index] == '+' )
 503       {
 504         state = s_expoa;
 505         break;
 506       }
 507       if( iostrptr[actual_index] == '-' )
 508       {
 509         expo_sign = -1;
 510         state = s_expoa;
 511         break;
 512       }
 513     case s_expoa:
 514       if( isDEC(curr) )
 515       {
 516         expo = curr - '0';
 517         state = s_expob;
 518         break;
 519       }
 520       IOEXCEPTION( TEXTFAIL, NO_EXPONENT );
 521     case s_expob:
 522       expo = expo*10 + (curr - '0');
 523       if( expo > 1000 )
 524         IOEXCEPTION( TEXTFAIL, REAL_OVERFLOW );
 525     }
 526   }
 527   if( state != s_expob )
 528     IOEXCEPTION( TEXTFAIL, NO_EXPONENT );
 529
 530   expo *= expo_sign;
 531   expo++;
 532
 533   floatdig[++sdig] = '\0';
 534
 535   *valptr = make_float( expo, sign );
 536   return actual_index - parsed;
 537 }
 538
 539
 540 static
 541 int parse_set( int limit, __tmp_IO_enum_table_type* tabptr,
 542                unsigned long* valptr )
 543 {
 544   int    parsed = actual_index;
 545   char   curr;
 546   __tmp_IO_enum_table_type* etptr;
 547
 548   if( actual_index >= limit )
 549     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_SET );
 550
 551   curr = iostrptr[actual_index];
 552   if( isXXX(curr,LET+USC) )
 553     actual_index++;
 554   else
 555     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_SET );
 556
 557   for( ; actual_index < limit; actual_index++ )
 558   {
 559     if( ! isXXX(iostrptr[actual_index],LET+DEC+USC) )
 560       break;
 561   }
 562
 563   if( tabptr )
 564      while( tabptr->name )
 565      {
 566        if( !casncmp( tabptr->name, &iostrptr[parsed], actual_index-parsed ) )
 567        {
 568          *valptr = tabptr->value;
 569 #if _TEXTIO_DEBUG_
 570          printf( "parsing set value until %d: %u\n", limit, tabptr->value );
 571 #endif
 572          return actual_index - parsed;
 573        }
 574        tabptr++;
 575      }
 576   IOEXCEPTION( TEXTFAIL, SET_CONVERSION_ERROR );
 577 }
 578
 579 static
 580 int parse_bit( int limit, char* bitptr )
 581 {
 582   int parsed = actual_index;
 583   int i = 0;
 584   char curr;
 585
 586   if( actual_index >= limit )
 587     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_BOOLS );
 588
 589   for( ; actual_index < limit; actual_index++ )
 590   {
 591     curr = iostrptr[actual_index] - '0';
 592     if( curr == 0 || curr == 1 )
 593       /* __setbitinset( i++, bitptr, limit, curr ); */
 594       __setbitpowerset (bitptr, limit, 0, i++, curr, __FILE__, __LINE__);
 595     else
 596       break;
 597   }
 598   return actual_index - parsed;
 599 }
 600
 601 static
 602 char* myultoa( unsigned long ul, char* buf, int base )
 603 {
 604   char*         res = buf;
 605   unsigned long h = ul/base;
 606   unsigned long q = 1;
 607
 608   while( h >= q ) q *= base;
 609   while( q > 0 )
 610   {
 611     *buf++ = "0123456789ABCDEF"[ul/q];
 612     ul %= q;
 613     q /= base;
 614   }
 615   *buf++ = '\0';
 616   return res;
 617 }
 618
 619 /*
 620  *  convert a bit string from src, bit offset up to len
 621  */
 622 static
 623 char* bitput( char* dst, char* src, int offset, int len )
 624 {
 625   char* res = dst;
 626   int i;
 627   for( i = offset; i < len; i++ )
 628   {
 629     *dst++ = __inpowerset( i, src, len, 0 ) ? '1' : '0';
 630   }
 631   return res;
 632 }
 633
 634 /*
 635  * dround: round decimal register *digptr starting at digit mdigs,
 636  *         on carry advance begin of digit sequence and bump exponent
 637  */
 638 static
 639 char*
 640 dround( char* digptr, int mdigs, int* deptr )
 641 {
 642   int carry;
 643 #if _TEXTIO_DEBUG_
 644   printf( "Rounding from %d\n", mdigs );
 645 #endif
 646   if( digptr[mdigs] >= 5 )
 647   {
 648     carry = 1;
 649     while( carry )
 650     {
 651       digptr[--mdigs]++;
 652       if( digptr[mdigs] >= 10 )
 653         digptr[mdigs] = 0;
 654       else
 655         carry = 0;
 656     }
 657   }
 658   if( mdigs < 0 )
 659   {
 660     digptr[--mdigs] = 1;
 661     (*deptr)++;
 662     return digptr - 1;
 663   }
 664   else
 665     return digptr;
 666 }
 667
 668 /*
 669  * mydtoa: convert val with a precision of mantdigs to a decimal fraction
 670  *         first digit is at **fstdiptr, decimal exponent is at *deptr
 671  */
 672 static
 673 char*
 674 mydtoa( double val, int mantdigs, int* deptr, int* sgnptr )
 675 {
 676   double m;
 677   int be;
 678   int de = -1;
 679   int fstdig = 0;
 680   int idig;
 681   char* digptr = floatdig+2;
 682
 683   floatdig[0] = floatdig[1] = 0;
 684
 685   if( val < 0 )
 686     *sgnptr = -1, val = fabs( val );
 687   else
 688     *sgnptr = +1;
 689
 690   /* split the value */
 691   m = frexp( val, &be ) * 10.0;
 692
 693   /* 5.0 <= m < 10.0 */
 694   while( be > 0 )
 695   {
 696     de++; be--; m /= 5.0;
 697     if( m < 1.0 )
 698       m *= 10.0, de--;
 699   }
 700   while( be < 0 )
 701   {
 702     de--; be++; m *= 5.0;
 703     if( m >= 10.0 )
 704       m /= 10.0, de++;
 705   }
 706
 707   for( idig = 0; idig < mantdigs; idig++ )
 708   {
 709     digptr[idig] = (int)m;
 710     m = (m - digptr[idig])*10.0;
 711   }
 712   digptr[idig] = (int)m;
 713
 714   *deptr = de;
 715   return dround( digptr, mantdigs, deptr );
 716 }
 717
 718 #define PUT(c) \
 719   { if( ifst <= ++iprt && iprt <= ilst ) *dst++ = c; }
 720
 721 static
 722 char*
 723 fixput( char* dst, char* src,
 724         int ifst, int ilst,
 725         int sign, int fst, int lst,
 726         int nid, int nfd )
 727 {
 728   char* dstsav = dst;
 729   int idig;
 730   int iprt = 0;
 731
 732   if( sign < 0 )
 733     PUT( '-' );
 734   for( idig = nid; idig >= -nfd; idig-- )
 735   {
 736     if (idig == -1)
 737       PUT( '.' );
 738     PUT( idig > fst || lst >= idig ? '0': '0' + *src++ );
 739   }
 740   return dstsav;
 741 }
 742
 743 static
 744 char*
 745 sciput( char* dst, char* src, char* expbeg,
 746         int ifst, int ilst,
 747         int sign, int de, int expwid )
 748 {
 749   char* dstsav = dst;
 750   int iprt = 0;
 751   int nfd = fractionwidth;
 752   int explen = strlen( expbeg );
 753
 754   if( sign < 0 )
 755     PUT( '-' );
 756   PUT( '0' + *src++ );
 757   PUT( '.' );
 758
 759   while( nfd-- )
 760     PUT( '0' + *src++ );
 761   PUT( 'E' );
 762   PUT( de >= 0 ? '+' : '-' );
 763   while( expwid > explen )
 764   {
 765     PUT( '0' );
 766     expwid--;
 767   }
 768   while( explen-- )
 769     PUT( *expbeg++ );
 770   return dstsav;
 771 }
 772
 773 /*
 774  *  handle dynamic field width
 775  */
 776 static
 777 get_field_width( void )
 778 {
 779   unsigned long  width;
 780   unsigned long  ulongval;
 781            long  longval;
 782   __tmp_IO_list  io;
 783
 784
 785   if( ++iolist_index > iolistlen )
 786     IOEXCEPTION( TEXTFAIL, IOLIST_EXHAUSTED );
 787
 788   io = *iolistptr++;
 789
 790   /* must be integer, >= 0 */
 791   switch( io.__descr )
 792   {
 793   case __IO_ByteVal:
 794     longval = io.__t.__valbyte;
 795     goto signed_fieldwidth;
 796   case __IO_UByteVal:
 797     width = io.__t.__valubyte;
 798     goto unsigned_fieldwidth;
 799   case __IO_IntVal:
 800     longval = io.__t.__valint;
 801     goto signed_fieldwidth;
 802   case __IO_UIntVal:
 803     width = io.__t.__valuint;
 804     goto unsigned_fieldwidth;
 805   case __IO_LongVal:
 806     longval = io.__t.__vallong;
 807     goto signed_fieldwidth;
 808   case __IO_ULongVal:
 809     width = io.__t.__valulong;
 810     goto unsigned_fieldwidth;
 811   case __IO_ByteLoc:
 812     longval = *(signed char*)io.__t.__locint;
 813     goto signed_fieldwidth;
 814   case __IO_UByteLoc:
 815     width = *(unsigned char*)io.__t.__locint;
 816     goto unsigned_fieldwidth;
 817   case __IO_IntLoc:
 818     longval = *(signed short*)io.__t.__locint;
 819     goto signed_fieldwidth;
 820   case __IO_UIntLoc:
 821     width = *(unsigned short*)io.__t.__locint;
 822     goto unsigned_fieldwidth;
 823   case __IO_LongLoc:
 824     longval = *(signed long*) io.__t.__locint;
 825     goto signed_fieldwidth;
 826   case __IO_ULongLoc:
 827     width = *(unsigned long*)io.__t.__locint;
 828     goto unsigned_fieldwidth;
 829   default:
 830     IOEXCEPTION( TEXTFAIL, NON_INT_FIELD_WIDTH );
 831   }
 832
 833 signed_fieldwidth: ;
 834   if( longval < 0 )
 835     IOEXCEPTION( TEXTFAIL, NEGATIVE_FIELD_WIDTH );
 836   width = longval;
 837
 838 unsigned_fieldwidth: ;
 839   return width;
 840 }
 841
 842
 843 static
 844 void inpconv( void )
 845 {
 846   __tmp_IO_list  io;
 847   int            width;
 848   int            limit;
 849   int            skiplim;
 850   int            skipped;
 851   int            bypass;
 852   int            parsed;
 853   Boolean        fixedchars;
 854   int            fixedlen;
 855   unsigned char  curr;
 856   double         dval;
 857   float          fval;
 858
 859   __tmp_IO_long  lval;
 860   int            sign;
 861   unsigned long  umin;
 862   unsigned long  umax;
 863     signed long  smin;
 864     signed long  smax;
 865   int            ilen;
 866   short unsigned slen;
 867   __tmp_IO_enum_table_type* settabptr;
 868
 869   while( repetition-- )
 870   {
 871     if( ++iolist_index > iolistlen )
 872       IOEXCEPTION( TEXTFAIL, IOLIST_EXHAUSTED );
 873
 874     io = *iolistptr++;
 875
 876     if( dynamicwid )
 877       width = get_field_width();
 878     else
 879       width = clausewidth;
 880
 881     bypass = skipped = 0;
 882     if( width )
 883     {
 884       if( actual_index + width > iostrlen )
 885         IOEXCEPTION( TEXTFAIL, NOT_ENOUGH_CHARS );
 886
 887       switch(io.__descr)
 888       {
 889       case __IO_CharLoc:
 890       case __IO_CharRangeLoc:
 891         fixedchars = True;
 892         fixedlen = 1;
 893         break;
 894       case __IO_CharStrLoc:
 895         fixedchars = True;
 896         fixedlen = io.__t.__loccharstring.string_length;
 897         break;
 898       default:
 899         fixedchars = False;
 900         break;
 901       }
 902
 903       if( leftadjust )
 904       {
 905         skiplim = fixedchars ? actual_index + fixedlen
 906                              : actual_index;
 907         bypass = skipped = piks_pad( actual_index + width, skiplim );
 908       }
 909       else
 910       {
 911         skiplim = fixedchars ? actual_index + width - fixedlen
 912                              : actual_index + width;
 913         skipped = skip_pad( skiplim );
 914       }
 915       width -= skipped;
 916       limit = actual_index + width;
 917     }
 918     else
 919     { /* free format */
 920       if( paddingdef || !( io.__descr == __IO_CharLoc ||
 921                            io.__descr == __IO_CharRangeLoc ||
 922                            io.__descr == __IO_CharStrLoc ||
 923                            io.__descr == __IO_CharVaryingLoc ) )
 924         if( paddingchar == ' ' || paddingchar == '\t' )
 925           skip_space( iostrlen );
 926         else
 927           skip_pad( iostrlen );
 928       limit = iostrlen;
 929     }
 930
 931     switch( io.__descr )
 932     {
 933     case __IO_ByteLoc:
 934       ilen = 1;
 935       smin = CH_BYTE_MIN;
 936       smax = CH_BYTE_MAX;
 937       goto parse_signed_int;
 938     case __IO_UByteLoc:
 939       ilen = 1;
 940       umin = 0;
 941       umax = CH_UBYTE_MAX;
 942       goto parse_unsigned_int;
 943     case __IO_IntLoc:
 944       ilen = 2;
 945       smin = CH_INT_MIN;
 946       smax = CH_INT_MAX;
 947       goto parse_signed_int;
 948     case __IO_UIntLoc:
 949       ilen = 2;
 950       umin = 0;
 951       umax = CH_UINT_MAX;
 952       goto parse_unsigned_int;
 953     case __IO_LongLoc:
 954       ilen = 4;
 955       smin = CH_LONG_MIN;
 956       smax = CH_LONG_MAX;
 957       goto parse_signed_int;
 958     case __IO_ULongLoc:
 959       ilen = 4;
 960       umin = 0;
 961       umax = CH_ULONG_MAX;
 962       goto parse_unsigned_int;
 963
 964     case __IO_ByteRangeLoc:
 965       ilen = 1;
 966       smin = io.__t.__locintrange.lower.slong;
 967       smax = io.__t.__locintrange.upper.slong;
 968       goto parse_signed_int;
 969     case __IO_UByteRangeLoc:
 970       ilen = 1;
 971       umin = io.__t.__locintrange.lower.ulong;
 972       umax = io.__t.__locintrange.upper.ulong;
 973       goto parse_unsigned_int;
 974     case __IO_IntRangeLoc:
 975       ilen = 2;
 976       smin = io.__t.__locintrange.lower.slong;
 977       smax = io.__t.__locintrange.upper.slong;
 978       goto parse_signed_int;
 979     case __IO_UIntRangeLoc:
 980       ilen = 2;
 981       umin = io.__t.__locintrange.lower.ulong;
 982       umax = io.__t.__locintrange.upper.ulong;
 983       goto parse_unsigned_int;
 984     case __IO_LongRangeLoc:
 985       ilen = 4;
 986       smin = io.__t.__locintrange.lower.slong;
 987       smax = io.__t.__locintrange.upper.slong;
 988       goto parse_signed_int;
 989     case __IO_ULongRangeLoc:
 990       ilen = 4;
 991       umin = io.__t.__locintrange.lower.ulong;
 992       umax = io.__t.__locintrange.upper.ulong;
 993       goto parse_unsigned_int;
 994
 995     case __IO_BoolLoc:
 996       ilen = 1;
 997       umin = 0;
 998       umax = 1;
 999       settabptr = bool_tab;
1000       goto parse_set;
1001     case __IO_BoolRangeLoc:
1002       ilen = 1;
1003       umin = io.__t.__locboolrange.lower;
1004       umax = io.__t.__locboolrange.upper;
1005       settabptr = bool_tab;
1006       goto parse_set;
1007
1008     case __IO_SetLoc:
1009       ilen = io.__t.__locsetrange.length;
1010       settabptr = io.__t.__locsetrange.name_table;
1011       umin = 0;
1012       umax = CH_ULONG_MAX;
1013       goto parse_set;
1014     case __IO_SetRangeLoc:
1015       ilen = io.__t.__locsetrange.length;
1016       settabptr = io.__t.__locsetrange.name_table;
1017       umin = io.__t.__locsetrange.lower;
1018       umax = io.__t.__locsetrange.upper;
1019       goto parse_set;
1020
1021     case __IO_CharLoc:
1022       umin = 0;
1023       umax = 0xff;
1024       goto parse_char;
1025     case __IO_CharRangeLoc:
1026       umin = io.__t.__loccharrange.lower;
1027       umax = io.__t.__loccharrange.upper;
1028       goto parse_char;
1029
1030     case __IO_CharVaryingLoc:
1031       if( convcode != DefaultConv )
1032         IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1033       slen = io.__t.__loccharstring.string_length;
1034       if( (parsed = limit - actual_index) < slen )
1035         slen = parsed;
1036       else
1037         parsed = slen;
1038       memcpy( io.__t.__loccharstring.string + 2,
1039               &iostrptr[actual_index], parsed );
1040       MOV2(io.__t.__loccharstring.string,&slen);
1041       actual_index += parsed;
1042       goto check_field_complete;
1043
1044
1045     case __IO_CharStrLoc:
1046       if( convcode != DefaultConv )
1047         IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1048       if( actual_index + io.__t.__loccharstring.string_length > limit )
1049         IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_CHARS );
1050       memcpy( io.__t.__loccharstring.string,
1051               &iostrptr[actual_index],
1052               parsed = io.__t.__loccharstring.string_length );
1053       actual_index += parsed;
1054       goto check_field_complete;
1055
1056     case __IO_BitStrLoc:
1057       if( convcode != DefaultConv )
1058         IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1059       parsed = parse_bit( limit, io.__t.__loccharstring.string );
1060       if( parsed < io.__t.__loccharstring.string_length )
1061         IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_BOOLS );
1062       goto check_field_complete;
1063
1064     case __IO_LongRealLoc:
1065     case __IO_RealLoc:
1066       switch( convcode )
1067       {
1068       case ScientConv:
1069         parse_scientific( limit, &dval, DBL_MIN, DBL_MAX );
1070         break;
1071       case DefaultConv:
1072         parse_fixedpoint( limit, &dval );
1073         break;
1074       default:
1075         IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1076       }
1077       if( io.__descr == __IO_LongRealLoc )
1078         memcpy( io.__t.__loclongreal, &dval, sizeof(double) );
1079       else
1080       {
1081         fval = (float)dval;
1082         MOV4(io.__t.__locreal,&fval);
1083       }
1084       goto check_field_complete;
1085     default:
1086       IOEXCEPTION( TEXTFAIL, INVALID_IO_LIST );
1087     }
1088
1089
1090 parse_signed_int: ;
1091     if( convcode == ScientConv )
1092       IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1093     parsed = parse_int( limit, dset[convcode], base[convcode],
1094                         &lval.ulong, &sign );
1095     if( sign < 0 )
1096     {
1097       if( lval.ulong > (unsigned long)CH_LONG_MIN )
1098         IOEXCEPTION( TEXTFAIL, INTEGER_RANGE_ERROR );
1099       lval.slong = -lval.ulong;
1100     }
1101     else
1102     {
1103       /* not needed: lval.slong = lval.ulong; */
1104       /* Hack: sign extension for bin/oct/dec if no sign present */
1105       if( convcode != DefaultConv && lval.ulong & (1 << (ilen*8-1)) )
1106       {
1107         if( ilen < 4 )
1108           lval.ulong |= 0xFFFFFFFF << ilen*8;
1109       }
1110       else
1111         if( lval.ulong > (unsigned long)CH_LONG_MAX )
1112           IOEXCEPTION( TEXTFAIL, INTEGER_RANGE_ERROR );
1113     }
1114     if( lval.slong < smin || smax < lval.slong )
1115       IOEXCEPTION( TEXTFAIL, INTEGER_RANGE_ERROR );
1116     goto store_int;
1117
1118 parse_unsigned_int: ;
1119     if( convcode == ScientConv )
1120       IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1121     parsed = parse_int( limit, dset[convcode], base[convcode],
1122                         &lval.ulong, &sign );
1123     if( sign < 0 ||  lval.ulong < umin || umax < lval.ulong )
1124       IOEXCEPTION( TEXTFAIL, INTEGER_RANGE_ERROR );
1125     goto store_int;
1126
1127 parse_set: ;
1128     if( convcode != DefaultConv )
1129       IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1130     parsed = parse_set( limit, settabptr, &lval.ulong );
1131     if( lval.ulong < umin || umax < lval.ulong )
1132       IOEXCEPTION( TEXTFAIL, SET_RANGE_ERROR );
1133     goto store_int;
1134
1135 store_int: ;
1136     switch( ilen )
1137     {
1138     case 1:
1139       *(unsigned char*)io.__t.__locint = lval.ulong;
1140       break;
1141     case 2:
1142       slen = lval.ulong;
1143       MOV2(io.__t.__locint,&slen);
1144       break;
1145     case 4:
1146       MOV4(io.__t.__locint,&lval.ulong);
1147       break;
1148     default:
1149       IOEXCEPTION( TEXTFAIL, INTERNAL_ERROR );
1150     }
1151     goto check_field_complete;
1152
1153 parse_char: ;
1154     if( convcode != DefaultConv )
1155       IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1156     if( actual_index >= limit )
1157       IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_CHARS );
1158     curr = iostrptr[actual_index++];
1159     parsed = 1;
1160     if( curr < umin || umax < curr )
1161       IOEXCEPTION( TEXTFAIL, CHAR_RANGE_ERROR );
1162     *io.__t.__locchar = curr;
1163     goto check_field_complete;
1164
1165 check_field_complete: ;
1166     actual_index += bypass;
1167     if( width > parsed )
1168       IOEXCEPTION( TEXTFAIL, INVALID_CHAR );
1169   }
1170 }
1171
1172 static
1173 void inpedit( void )
1174 {
1175   int           nchars;
1176
1177   if( dynamicwid )
1178     clausewidth = get_field_width();
1179
1180   switch( editcode )
1181   {
1182   case SpaceSkip:
1183     nchars = repetition*clausewidth;
1184     if( actual_index + nchars > iostrlen )
1185       IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_EDIT );
1186     for( ; nchars ; nchars-- )
1187       if( iostrptr[actual_index++] != ' ' )
1188         IOEXCEPTION( TEXTFAIL, NO_SPACE_TO_SKIP );
1189     break;
1190
1191   case SkipLeft:
1192     nchars = repetition*clausewidth;
1193     if( (actual_index -= nchars) < 0 )
1194       IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_EDIT );
1195     break;
1196
1197   case SkipRight:
1198     nchars = repetition*clausewidth;
1199     if( (actual_index += nchars) > iostrlen )
1200       IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_EDIT );
1201     break;
1202
1203   case Tabulation:
1204     if( (actual_index = clausewidth) > iostrlen )
1205       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1206     break;
1207   }
1208 }
1209
1210 static
1211 void outconv( void )
1212 {
1213   unsigned long             width;
1214   char                      itembuf[33];
1215   unsigned long             ulongval;
1216            long             longval;
1217   __tmp_IO_list             io;
1218   __tmp_IO_enum_table_type* etptr;
1219   char*                     itembeg;
1220   unsigned long             itemlen;
1221   double                    doubleval;
1222   int                       de;
1223   int                       sign;
1224   int                       mantdigs;
1225   int                       nid;
1226   int                       nfd;
1227   char*                     expbeg;
1228   int                       explen;
1229   unsigned int              expwid;
1230
1231   while( repetition-- )
1232   {
1233     if( ++iolist_index > iolistlen )
1234       IOEXCEPTION( TEXTFAIL, IOLIST_EXHAUSTED );
1235
1236     io = *iolistptr++;
1237     width =  dynamicwid ? get_field_width() : clausewidth;
1238
1239     switch( convcode )
1240     {
1241     case DefaultConv:
1242       switch( io.__descr )
1243       {
1244       case __IO_ByteVal:
1245         longval = io.__t.__valbyte;
1246         goto signed_conversion;
1247       case __IO_UByteVal:
1248         ulongval = io.__t.__valubyte;
1249         goto unsigned_conversion;
1250       case __IO_IntVal:
1251         longval = io.__t.__valint;
1252         goto signed_conversion;
1253       case __IO_UIntVal:
1254         ulongval = io.__t.__valuint;
1255         goto unsigned_conversion;
1256       case __IO_LongVal:
1257         longval = io.__t.__vallong;
1258         goto signed_conversion;
1259       case __IO_ULongVal:
1260         ulongval = io.__t.__valulong;
1261         goto unsigned_conversion;
1262
1263       case __IO_BoolVal:
1264         switch( io.__t.__valbool )
1265         {
1266         case 0:
1267           itembeg = "FALSE";
1268           itemlen = 5;
1269           goto move_item;
1270         case 1:
1271           itembeg = "TRUE";
1272           itemlen = 4;
1273           goto move_item;
1274         default:
1275           IOEXCEPTION( TEXTFAIL, BOOL_CONVERSION_ERROR );
1276         }
1277
1278       case __IO_CharVal:
1279         itembeg = &io.__t.__valchar;
1280         itemlen = 1;
1281         goto move_item;
1282
1283       case __IO_SetVal:
1284         /* locate name string using set mode name table */
1285         itembeg = 0;
1286
1287         if( (etptr = io.__t.__valset.name_table) )
1288           while( etptr->name )
1289           {
1290             if( etptr->value == io.__t.__valset.value )
1291             {
1292               itembeg = etptr->name;
1293               itemlen = strlen( itembeg );
1294               goto move_item;
1295             }
1296             etptr++;
1297           }
1298        IOEXCEPTION( TEXTFAIL, SET_CONVERSION_ERROR );
1299
1300       case __IO_CharVaryingLoc:
1301         {
1302           unsigned short l;
1303           itembeg = (char*)io.__t.__loccharstring.string;
1304           MOV2(&l,itembeg);
1305           itembeg += 2;
1306           itemlen = l;
1307           goto move_item;
1308         }
1309
1310       case __IO_CharStrLoc:
1311         itembeg = io.__t.__loccharstring.string;
1312         itemlen = io.__t.__loccharstring.string_length;
1313         goto move_item;
1314
1315       case __IO_BitStrLoc:
1316         itemlen = io.__t.__loccharstring.string_length;
1317         itembeg = io.__t.__loccharstring.string;
1318
1319         if( !width )
1320           width = itemlen;
1321
1322         /* check remaining space */
1323         if( actual_index + width > iostrlen )
1324           IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1325
1326         if( itemlen == width )
1327           bitput( iostrptr + actual_index, itembeg, 0, itemlen );
1328         else
1329           if( itemlen < width )
1330             if( leftadjust )
1331               memset( bitput( iostrptr + actual_index, itembeg, 0, itemlen )
1332                       + itemlen,
1333                       paddingchar, width - itemlen );
1334             else
1335               bitput( memset( iostrptr + actual_index,
1336                               paddingchar, width - itemlen )
1337                       + width - itemlen,
1338                       itembeg, itemlen - width, itemlen );
1339           else
1340             if( overflowev )
1341               memset( iostrptr + actual_index, '*', width );
1342             else
1343               if( leftadjust )
1344                 bitput( iostrptr + actual_index, itembeg, 0, width );
1345               else
1346                 bitput( iostrptr + actual_index, itembeg,
1347                         itemlen - width, itemlen );
1348         goto adjust_index;
1349
1350       case __IO_RealVal:
1351         doubleval = io.__t.__valreal;
1352         mantdigs = FMANTDIGS;
1353         goto fixed_point_conversion;
1354       case __IO_LongRealVal:
1355         doubleval = io.__t.__vallongreal;
1356         mantdigs = DBL_DIG;
1357         goto fixed_point_conversion;
1358         break;
1359
1360       default:
1361         IOEXCEPTION( TEXTFAIL, INVALID_IO_LIST );
1362       }
1363
1364     case HexConv:
1365     case OctalConv:
1366     case BinaryConv:
1367       switch( io.__descr )
1368       {
1369       case __IO_ByteVal:
1370       case __IO_UByteVal:
1371         ulongval = io.__t.__valubyte;
1372         break;
1373       case __IO_IntVal:
1374       case __IO_UIntVal:
1375         ulongval = io.__t.__valuint;
1376         break;
1377       case __IO_LongVal:
1378       case __IO_ULongVal:
1379         ulongval = io.__t.__valulong;
1380         break;
1381       default:
1382         IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1383       }
1384       itembeg = myultoa( ulongval, itembuf, base[convcode] );
1385       itemlen = strlen( itembeg );
1386       goto move_item;
1387
1388     case ScientConv:
1389       switch( io.__descr )
1390       {
1391       case __IO_RealVal:
1392         doubleval = io.__t.__valreal;
1393         mantdigs = FMANTDIGS;
1394         if( !fractiondef )
1395           fractionwidth = FMANTDIGS - 1;
1396         goto scientific_conversion;
1397       case __IO_LongRealVal:
1398         doubleval = io.__t.__vallongreal;
1399         mantdigs = DBL_DIG;
1400         if( !fractiondef )
1401           fractionwidth = DBL_DIG - 1;
1402         goto scientific_conversion;
1403         break;
1404       default:
1405         IOEXCEPTION( TEXTFAIL, CONVCODE_MODE_MISFIT );
1406       }
1407     }
1408
1409 fixed_point_conversion: ;
1410     itembeg = mydtoa( doubleval, mantdigs, &de, &sign );
1411     if( fractiondef && de >= -fractionwidth - 1
1412         && -fractionwidth > de - mantdigs )
1413       itembeg = dround( itembeg, de + fractionwidth + 1, &de );
1414
1415     nid = de >= 0 ? de : 0;
1416     nfd = fractiondef ? fractionwidth
1417                       : ( de + 1 - mantdigs > 0 ? 0 : mantdigs - de - 1 );
1418     itemlen = ( sign < 0 ? 1 : 0 ) + 2 + nid + nfd;
1419 #if _TEXTIO_DEBUG_
1420 printf( "fixed item length %d\n", itemlen );
1421 #endif
1422     if( !width )
1423       width = itemlen;
1424 #if _TEXTIO_DEBUG_
1425 printf( "fixed item width %d\n", width );
1426 #endif
1427     /* check remaining space */
1428     if( actual_index + width > iostrlen )
1429       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1430
1431     if( itemlen == width )
1432       fixput( iostrptr + actual_index, itembeg,
1433               1, itemlen, sign, de, de - mantdigs, nid, nfd );
1434     else
1435       if( itemlen < width )
1436         if( leftadjust )
1437           memset( fixput( iostrptr + actual_index, itembeg,
1438                           1, itemlen, sign, de, de - mantdigs, nid, nfd )
1439                   + itemlen,
1440                   paddingchar, width - itemlen );
1441         else
1442           fixput( memset( iostrptr + actual_index,
1443                           paddingchar, width - itemlen )
1444                   + width - itemlen,
1445                   itembeg, 1, itemlen, sign, de, de - mantdigs, nid, nfd );
1446       else
1447         if( overflowev )
1448           memset( iostrptr + actual_index, '*', width );
1449         else
1450           if( leftadjust )
1451             fixput( iostrptr + actual_index, itembeg,
1452                     1, width, sign, de, de - mantdigs, nid, nfd );
1453           else
1454             fixput( iostrptr + actual_index, itembeg,
1455                     itemlen - width + 1, itemlen,
1456                     sign, de, de - mantdigs, nid, nfd );
1457     goto adjust_index;
1458
1459 scientific_conversion: ;
1460     itembeg = mydtoa( doubleval, mantdigs, &de, &sign );
1461
1462     if( fractiondef && fractionwidth < mantdigs )
1463       itembeg = dround( itembeg, fractionwidth + 1, &de );
1464
1465     expbeg = myultoa( abs(de), itembuf, 10 );
1466     explen = strlen( expbeg );
1467
1468     expwid = explen > exponentwidth ? explen : exponentwidth;
1469     itemlen = ( sign < 0 ? 1 : 0 ) + 2 + fractionwidth + 2 + expwid;
1470 #if _TEXTIO_DEBUG_
1471 printf( "floating item length %d, fraction %d, exponent %d\n",
1472         itemlen, fractionwidth, expwid );
1473 #endif
1474     if( width == 0 )
1475       width = itemlen;
1476 #if _TEXTIO_DEBUG_
1477 printf( "floating item width %d\n", width );
1478 #endif
1479     /* check remaining space */
1480     if( actual_index + width > iostrlen )
1481       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1482
1483     if( itemlen == width )
1484       sciput( iostrptr + actual_index, itembeg, expbeg,
1485               1, itemlen, sign, de, expwid );
1486     else
1487       if( itemlen < width )
1488         if( leftadjust )
1489           memset( sciput( iostrptr + actual_index, itembeg, expbeg,
1490                           1, itemlen, sign, de, expwid )
1491                   + itemlen,
1492                   paddingchar, width - itemlen );
1493         else
1494           sciput( memset( iostrptr + actual_index,
1495                           paddingchar, width - itemlen )
1496                   + width - itemlen,
1497                   itembeg, expbeg, 1, itemlen, sign, de, expwid );
1498       else
1499         if( overflowev )
1500           memset( iostrptr + actual_index, '*', width );
1501         else
1502           if( leftadjust )
1503             sciput( iostrptr + actual_index, itembeg, expbeg,
1504                     1, width, sign, de, expwid );
1505           else
1506             sciput( iostrptr + actual_index, itembeg, expbeg,
1507                     itemlen - width + 1, itemlen,
1508                     sign, de, expwid );
1509     goto adjust_index;
1510
1511 signed_conversion: ;
1512     if( longval >= 0 )
1513       itembeg = myultoa( longval, itembuf, 10 );
1514     else
1515     {
1516       itembuf[0] = '-';
1517       myultoa( -longval, itembuf+1, 10 );
1518       itembeg = itembuf;
1519     }
1520     itemlen = strlen( itembeg );
1521     goto move_item;
1522
1523 unsigned_conversion: ;
1524     itembeg = myultoa( ulongval, itembuf, 10 );
1525     itemlen = strlen( itembeg );
1526     goto move_item;
1527
1528 move_item: ;
1529     if( !width )
1530       width = itemlen;
1531
1532     /* check remaining space */
1533     if( actual_index + width > iostrlen )
1534       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1535
1536     /* move item, filling or truncating or overflow-evidencing */
1537     if( itemlen == width )
1538       memcpy( iostrptr + actual_index, itembeg, itemlen );
1539     else
1540       if( itemlen < width )
1541         if( leftadjust )
1542           memset( memcpy( iostrptr + actual_index, itembeg, itemlen )
1543                   + itemlen,
1544                   paddingchar, width - itemlen );
1545         else
1546           memcpy( memset( iostrptr + actual_index,
1547                           paddingchar, width - itemlen )
1548                   + width - itemlen,
1549                   itembeg, itemlen );
1550       else
1551         if( overflowev )
1552           memset( iostrptr + actual_index, '*', width );
1553         else
1554           if( leftadjust )
1555             memcpy( iostrptr + actual_index, itembeg, width );
1556           else
1557             memcpy( iostrptr + actual_index,
1558                     itembeg + itemlen - width, width );
1559
1560   /*
1561    *  adjust.
1562    */
1563 adjust_index: ;
1564   actual_index += width;
1565   if( actual_index > maximum_index )
1566     maximum_index = actual_index;
1567   }
1568 }
1569
1570 static
1571 void outedit( void )
1572 {
1573   int nchars;
1574
1575   if( dynamicwid )
1576     clausewidth = get_field_width();
1577   switch( editcode )
1578   {
1579   case SpaceSkip:
1580     nchars = repetition*clausewidth;
1581     if( actual_index + nchars > iostrlen )
1582       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1583     memset( iostrptr + actual_index, ' ', nchars );
1584     actual_index += nchars;
1585     if( actual_index > maximum_index )
1586       maximum_index = actual_index;
1587     break;
1588
1589   case SkipLeft:
1590     nchars = repetition*clausewidth;
1591     if(  actual_index - nchars < 0 )
1592       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1593     actual_index -= nchars;
1594     break;
1595
1596   case SkipRight:
1597     nchars = repetition*clausewidth;
1598     if( actual_index + nchars > iostrlen )
1599       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1600     actual_index += nchars;
1601     if( actual_index > maximum_index )
1602     {
1603       memset( iostrptr + maximum_index, ' ', actual_index - maximum_index );
1604       maximum_index = actual_index;
1605     }
1606     break;
1607
1608   case Tabulation:
1609     if( clausewidth >= iostrlen )
1610       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1611     actual_index = clausewidth;
1612     if( actual_index > maximum_index )
1613     {
1614       memset( iostrptr + maximum_index, ' ', actual_index - maximum_index );
1615       maximum_index = actual_index;
1616     }
1617     break;
1618   }
1619 }
1620
1621
1622 static
1623 void inpioctrl( void )
1624 {
1625   unsigned short hlen;
1626   if( !textptr )
1627     IOEXCEPTION( TEXTFAIL, IO_CONTROL_NOT_VALID );
1628   if( iocode != EndPage )
1629   {
1630     jmp_buf ioerror;
1631     unsigned long info;
1632
1633     if (textptr->access_sub->association)
1634       {
1635         if( (info = setjmp( ioerror )) )
1636           IOEXCEPTION( info>>16, info & 0xffff );
1637         while( repetition-- )
1638           {
1639             __readrecord( textptr->access_sub, textindex,
1640                          (char*)textptr->text_record,
1641                          __FILE__, __LINE__ );
1642             actual_index = 0;
1643             MOV2(&hlen,&textptr->text_record->len);
1644             iostrlen = hlen;
1645           }
1646       }
1647     else
1648       IOEXCEPTION (NOTCONNECTED, IS_NOT_CONNECTED);
1649   }
1650 }
1651
1652 /* specify pre/post in the order "/+-?!" */
1653 static
1654 char* pre_char =  "\0\f\0\r\0"; /* Z.200: "\n\f\0\n\0" */
1655 static
1656 char* post_char = "\n\n\r\0\0"; /* Z.200: "\r\r\r\0\0" */
1657
1658 static
1659 void outioctrl( void )
1660 {
1661   Association_Mode* assoc;
1662   unsigned short hlen;
1663   if( !textptr )
1664     IOEXCEPTION( TEXTFAIL, IO_CONTROL_NOT_VALID );
1665   if( (assoc = textptr->access_sub->association) )
1666   {
1667     jmp_buf ioerror;
1668     unsigned long info;
1669     if( (info = setjmp( ioerror )) )
1670       IOEXCEPTION( info>>16, info & 0xffff );
1671
1672     while( repetition-- )
1673     {
1674       if( iocode != EndPage )
1675       {
1676         if( TEST_FLAG( assoc, IO_FIRSTLINE ) )
1677         {
1678           CLR_FLAG( assoc, IO_FIRSTLINE );
1679           assoc->ctl_pre = '\0';
1680         }
1681         else
1682         {
1683           if( TEST_FLAG( assoc, IO_FORCE_PAGE ) )
1684           {
1685             CLR_FLAG( assoc, IO_FORCE_PAGE );
1686             assoc->ctl_pre = '\f';
1687           }
1688           else
1689             assoc->ctl_pre = pre_char[iocode];
1690         }
1691         assoc->ctl_post = post_char[iocode];
1692         hlen = actual_index;
1693         MOV2(&textptr->text_record->len,&hlen);
1694         __writerecord( textptr->access_sub, textindex,
1695                        (char*)textptr->text_record,
1696                        textptr->text_record->len,
1697                        __FILE__, __LINE__ );
1698         hlen = actual_index = 0;
1699         MOV2(&textptr->text_record->len,&hlen);
1700       }
1701       else if( !TEST_FLAG( textptr, IO_FIRSTLINE ) )
1702         SET_FLAG( textptr, IO_FORCE_PAGE );
1703       assoc->ctl_pre = assoc->ctl_post = '\0';
1704     }
1705   }
1706   else
1707     IOEXCEPTION (NOTCONNECTED, IS_NOT_CONNECTED);
1708 }
1709
1710 static
1711 void (**actionptr)( void );
1712 static
1713 void (*readactions[])( void ) = { inpconv, inpedit, inpioctrl };
1714 static
1715 void (*writeactions[])( void ) = { outconv, outedit, outioctrl };
1716
1717
1718 static
1719 void emitstr( char* begtxt, char* endtxt )
1720 {
1721   char c;
1722   int  nchars = endtxt - begtxt;
1723   if( actual_index + nchars > iostrlen )
1724       IOEXCEPTION( TEXTFAIL, TEXT_LOC_OVERFLOW );
1725   memcpy( iostrptr + actual_index, begtxt, nchars );
1726   actual_index += nchars;
1727   if( actual_index > maximum_index )
1728     maximum_index = actual_index;
1729 }
1730
1731 static
1732 void scanstr( char* begtxt, char* endtxt )
1733 {
1734   int  nchars = endtxt - begtxt;
1735   if( actual_index + nchars > iostrlen )
1736     IOEXCEPTION( TEXTFAIL, NO_CHARS_FOR_TEXT );
1737   if( strncmp( iostrptr + actual_index, begtxt, nchars ) )
1738     IOEXCEPTION( TEXTFAIL, FORMAT_TEXT_MISMATCH );
1739   actual_index += nchars;
1740 }
1741
1742 void (*ftextptr) ( char*, char* );
1743
1744 static
1745 formatexit_t scanformcont( char* fcs, int len,
1746                            char** fcsptr, int* lenptr )
1747 {
1748   char          curr;
1749   fcsstate_t    state  = FormatText;
1750   unsigned long buf;
1751   int           dig;
1752   acttype_t     action;
1753   char*         begtxt = fcs;
1754
1755   while( len-- )
1756   {
1757     curr = *fcs++;
1758     switch( state )
1759     {
1760     case FormatText:
1761       if( curr == '%' )
1762       {
1763         ftextptr( begtxt, fcs-1 );
1764         state = FirstPercent;
1765       }
1766       break;
1767
1768 after_first_percent: ;
1769     case FirstPercent:
1770       if( curr == '%' )
1771       {
1772         state = FormatText;
1773         begtxt = fcs - 1;
1774         break;
1775       }
1776       if( curr == ')' )
1777       {
1778         *lenptr = len;
1779         *fcsptr = fcs;
1780         return EndAtParen;
1781       }
1782       if( isDEC(curr) )
1783       {
1784         state = RepFact;
1785         repetition = curr - '0';
1786         break;
1787       }
1788
1789       repetition = 1;
1790
1791 test_for_control_codes: ;
1792       if( isCVC(curr) )
1793       {
1794         state = ConvClause;
1795         action = ConvAct;
1796         convcode = strchr( CONVERSIONCODES, curr ) - CONVERSIONCODES;
1797         leftadjust = False;
1798         overflowev = False;
1799         dynamicwid = False;
1800         paddingdef = False;
1801         paddingchar = ' ';
1802         fractiondef = False;
1803         /* fractionwidth = 0; default depends on mode ! */
1804         exponentdef = False;
1805         exponentwidth = 3;
1806         clausewidth = 0;
1807         break;
1808       }
1809       if( isEDC(curr) )
1810       {
1811         state = EditClause;
1812         action = EditAct;
1813         editcode = strchr( EDITCODES, curr ) - EDITCODES;
1814         dynamicwid = False;
1815         clausewidth = editcode == Tabulation ? 0 : 1;
1816         break;
1817       }
1818       if( isIOC(curr) )
1819       {
1820         state = ClauseEnd;
1821         action = IOAct;
1822         iocode = strchr( IOCODES, curr ) - IOCODES;
1823         break;
1824       }
1825       if( curr == '(' )
1826       {
1827         unsigned long times = repetition;
1828         int  cntlen;
1829         char* cntfcs;
1830         while( times-- )
1831         {
1832           if( scanformcont( fcs, len, &cntfcs, &cntlen ) != EndAtParen )
1833             IOEXCEPTION( TEXTFAIL, UNMATCHED_OPENING_PAREN );
1834         }
1835         fcs = cntfcs;
1836         len = cntlen;
1837         state  = FormatText;
1838         begtxt = fcs;
1839         break;
1840       }
1841       IOEXCEPTION( TEXTFAIL, BAD_FORMAT_SPEC_CHAR );
1842
1843     case RepFact:
1844       if( isDEC(curr) )
1845       {
1846         dig = curr - '0';
1847         if( repetition > (ULONG_MAX - dig)/10 )
1848           IOEXCEPTION( TEXTFAIL, REPFAC_OVERFLOW );
1849         repetition = repetition*10 + dig;
1850         break;
1851       }
1852       goto test_for_control_codes;
1853
1854     case ConvClause:
1855       if( isDEC(curr) )
1856       {
1857         state = ClauseWidth;
1858         clausewidth = curr - '0';
1859         break;
1860       }
1861       if( curr == 'L' )
1862       {
1863         if( leftadjust )
1864           IOEXCEPTION( TEXTFAIL, DUPLICATE_QUALIFIER );
1865         leftadjust = True;
1866         break;
1867       }
1868       if( curr == 'E' )
1869       {
1870         if( overflowev )
1871           IOEXCEPTION( TEXTFAIL, DUPLICATE_QUALIFIER );
1872         overflowev = True;
1873         break;
1874       }
1875       if( curr == 'P' )
1876       {
1877         if( paddingdef )
1878           IOEXCEPTION( TEXTFAIL, DUPLICATE_QUALIFIER );
1879         paddingdef = True;
1880         state = CatchPadding;
1881         break;
1882       }
1883
1884 test_for_variable_width: ;
1885       if( curr == 'V' )
1886       {
1887         dynamicwid = True;
1888         state = AfterWidth;
1889         break;
1890       }
1891       goto test_for_fraction_width;
1892
1893     case ClauseWidth:
1894       if( isDEC(curr) )
1895       {
1896         dig = curr - '0';
1897         if( clausewidth > (ULONG_MAX - dig)/10 )
1898           IOEXCEPTION( TEXTFAIL, CLAUSE_WIDTH_OVERFLOW );
1899         clausewidth = clausewidth*10 + dig;
1900         break;
1901       }
1902       /* fall through */
1903
1904 test_for_fraction_width: ;
1905     case AfterWidth:
1906       if( curr == '.' )
1907       {
1908         if( convcode != DefaultConv && convcode != ScientConv )
1909           IOEXCEPTION( TEXTFAIL, NO_FRACTION );
1910         fractiondef = True;
1911         state = FractWidth;
1912         break;
1913       }
1914       goto test_for_exponent_width;
1915
1916     case FractWidth:
1917       if( isDEC( curr ) )
1918       {
1919         state = FractWidthCont;
1920         fractionwidth = curr - '0';
1921         break;
1922       }
1923       else
1924         IOEXCEPTION( TEXTFAIL, NO_FRACTION_WIDTH );
1925
1926     case FractWidthCont:
1927       if( isDEC( curr ) )
1928       {
1929         dig = curr - '0';
1930         if( fractionwidth > (ULONG_MAX - dig)/10 )
1931           IOEXCEPTION( TEXTFAIL, FRACTION_WIDTH_OVERFLOW );
1932         fractionwidth = fractionwidth*10 + dig;
1933         break;
1934       }
1935
1936 test_for_exponent_width: ;
1937       if( curr == ':' )
1938       {
1939         if( convcode != ScientConv )
1940           IOEXCEPTION( TEXTFAIL, NO_EXPONENT );
1941         exponentdef = True;
1942         state = ExpoWidth;
1943         break;
1944       }
1945       goto test_for_final_percent;
1946
1947     case ExpoWidth:
1948       if( isDEC( curr ) )
1949       {
1950         state = ExpoWidthCont;
1951         exponentwidth = curr - '0';
1952         break;
1953       }
1954       else
1955         IOEXCEPTION( TEXTFAIL, NO_EXPONENT_WIDTH );
1956
1957     case ExpoWidthCont:
1958       if( isDEC( curr ) )
1959       {
1960         dig = curr - '0';
1961         if( exponentwidth > (ULONG_MAX - dig)/10 )
1962           IOEXCEPTION( TEXTFAIL, EXPONENT_WIDTH_OVERFLOW );
1963         exponentwidth = exponentwidth*10 + dig;
1964         break;
1965       }
1966       /* fall through  */
1967
1968 test_for_final_percent: ;
1969     case ClauseEnd:
1970       if( curr == '%' )
1971       {
1972         state = LastPercent;
1973         break;
1974       }
1975
1976   do_the_action: ;
1977       actionptr[action]();
1978       state = FormatText;
1979       begtxt = fcs - 1;
1980       break;
1981
1982     case CatchPadding:
1983       paddingchar = curr;
1984       state = ConvClause;
1985       break;
1986
1987     case EditClause:
1988       if( isDEC(curr) )
1989       {
1990         state = ClauseWidth;
1991         clausewidth = curr - '0';
1992         break;
1993       }
1994       goto test_for_variable_width;
1995
1996     case LastPercent:
1997       actionptr[action]();
1998       if( curr == '.' )
1999       {
2000         state = FormatText;
2001         begtxt = fcs;
2002         break;
2003       }
2004       goto after_first_percent;
2005
2006     default:
2007       IOEXCEPTION( TEXTFAIL, INTERNAL_ERROR );
2008     }
2009   }
2010   switch( state )
2011   {
2012   case FormatText:
2013     ftextptr( begtxt, fcs );
2014     break;
2015   case FirstPercent:
2016   case LastPercent:
2017   case RepFact:
2018   case FractWidth:
2019   case ExpoWidth:
2020     IOEXCEPTION( TEXTFAIL, BAD_FORMAT_SPEC_CHAR );
2021   case CatchPadding:
2022     IOEXCEPTION( TEXTFAIL, NO_PAD_CHAR );
2023   default:
2024     actionptr[action]();
2025   }
2026
2027   *lenptr = len;
2028   *fcsptr = fcs;
2029   return NormalEnd;
2030 }
2031
2032 static
2033 void
2034 __read_format (char*           fmtptr,
2035                int             fmtlen,
2036                __tmp_IO_list*  ioptr,
2037                int             iolen,
2038                void*           inpptr,
2039                int             inplen )
2040 {
2041   formatexit_t res;
2042   unsigned short l;
2043
2044   iostrptr = (char*)inpptr;
2045   iostrlen = inplen;
2046
2047   /* initialisation */
2048   iolist_index = 0;
2049   iolistptr    = ioptr;
2050   iolistlen    = iolen;
2051
2052   actionptr = readactions;
2053   ftextptr = scanstr;
2054
2055   if( (res = scanformcont( fmtptr, fmtlen, &fmtptr, &fmtlen )) == EndAtParen )
2056     IOEXCEPTION( TEXTFAIL, UNMATCHED_CLOSING_PAREN );
2057
2058   if( iolist_index != iolen )
2059     IOEXCEPTION( TEXTFAIL, EXCESS_IOLIST_ELEMENTS );
2060
2061   return;
2062 }
2063
2064 void
2065 __readtext_f( Text_Mode*      the_text_loc,
2066               signed long     the_index,
2067               char*           fmtptr,
2068               int             fmtlen,
2069               __tmp_IO_list*  ioptr,
2070               int             iolen,
2071               char*           file,
2072               int             line )
2073 {
2074   unsigned long info;
2075
2076   if( (info = setjmp( __io_exception )) )
2077     CHILLEXCEPTION( file, line, info>>16, info & 0xffff );
2078
2079   textptr       = the_text_loc;
2080   textrecptr    = textptr->text_record;
2081   actual_index  = textptr->actual_index;
2082   textindex     = the_index;
2083
2084   __read_format ( fmtptr, fmtlen, ioptr, iolen,
2085                   (char*)textrecptr + 2, textptr->text_record->len );
2086   textptr->actual_index = actual_index;
2087 }
2088
2089 void
2090 __readtext_s( void*           string_ptr,
2091               int             string_len,
2092               char*           fmtptr,
2093               int             fmtlen,
2094               __tmp_IO_list*  ioptr,
2095               int             iolen,
2096               char*           file,
2097               int             line )
2098 {
2099   int info;
2100
2101   if( (info = setjmp( __io_exception )) )
2102     CHILLEXCEPTION( file, line, info>>16, info & 0xffff );
2103
2104   textptr      = NULL;
2105   actual_index = 0;
2106
2107   __read_format ( fmtptr, fmtlen,  ioptr, iolen, string_ptr, string_len );
2108 }
2109
2110 static
2111 void
2112 __write_format (char*           fmtptr,
2113                 int             fmtlen,
2114                 __tmp_IO_list*  ioptr,
2115                 int             iolen,
2116                 void*           outptr,
2117                 int             outlen )
2118 {
2119   formatexit_t res;
2120   unsigned short l;
2121
2122   /* initialisation */
2123   maximum_index = actual_index;
2124   iolist_index = 0;
2125
2126   actionptr = writeactions;
2127   ftextptr  = emitstr;
2128   iolistptr = ioptr;
2129   iolistlen = iolen;
2130   iostrptr  = (char *)outptr + 2;
2131   iostrlen  = outlen;
2132
2133   if( (res = scanformcont( fmtptr, fmtlen, &fmtptr, &fmtlen )) == EndAtParen )
2134     IOEXCEPTION( TEXTFAIL, UNMATCHED_CLOSING_PAREN );
2135
2136   if( iolist_index != iolen )
2137     IOEXCEPTION( TEXTFAIL, EXCESS_IOLIST_ELEMENTS );
2138
2139   /* set length of output string */
2140 #if _TEXTIO_DEBUG_
2141   printf( "maximum index = %d\n", maximum_index );
2142 #endif
2143   l = maximum_index;
2144   MOV2(outptr,&l);
2145   return;
2146 }
2147
2148 void
2149 __writetext_f( Text_Mode*      the_text_loc,
2150                signed long     the_index,
2151                char*           fmtptr,
2152                int             fmtlen,
2153                __tmp_IO_list*  ioptr,
2154                int             iolen,
2155                char*           file,
2156                int             line )
2157 {
2158   int info;
2159
2160   if( (info = setjmp( __io_exception )) )
2161     CHILLEXCEPTION( file, line, info>>16, info & 0xffff );
2162
2163   textptr       = the_text_loc;
2164   textrecptr    = the_text_loc->text_record;
2165   textindex     = the_index;
2166   iolistptr     = ioptr;
2167   iolistlen     = iolen;
2168
2169   actual_index = textptr->actual_index;
2170   __write_format ( fmtptr, fmtlen, ioptr, iolen,
2171                    textrecptr, textptr->access_sub->reclength - 2 );
2172   textptr->actual_index = actual_index;
2173 }
2174
2175 void
2176 __writetext_s( void*           string_ptr,
2177                int             string_len,
2178                char*           fmtptr,
2179                int             fmtlen,
2180                __tmp_IO_list*  ioptr,
2181                int             iolen,
2182                char*           file,
2183                int             line )
2184 {
2185   int info;
2186
2187   if( (info = setjmp( __io_exception )) )
2188     CHILLEXCEPTION( file, line, info>>16, info & 0xffff );
2189
2190   textptr      = NULL;
2191   actual_index = 0;
2192
2193   __write_format ( fmtptr, fmtlen, ioptr, iolen, string_ptr, string_len );
2194 }