home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / MAWK113.ZIP / mawk113 / print.c < prev    next >
C/C++ Source or Header  |  1993-01-20  |  12KB  |  521 lines
  1.  
  2. /********************************************
  3. print.c
  4. copyright 1992, 1991.  Michael D. Brennan
  5.  
  6. This is a source file for mawk, an implementation of
  7. the AWK programming language.
  8.  
  9. Mawk is distributed without warranty under the terms of
  10. the GNU General Public License, version 2, 1991.
  11. ********************************************/
  12.  
  13. /* $Log: print.c,v $
  14.  * Revision 5.4.1.2  1993/01/20  12:53:11  mike
  15.  * d_to_l()
  16.  *
  17.  * Revision 5.4.1.1  1993/01/15  03:33:47  mike
  18.  * patch3: safer double to int conversion
  19.  *
  20.  * Revision 5.4  1992/11/29  18:03:11  mike
  21.  * when printing integers, convert doubles to
  22.  * longs so output is the same on 16bit systems as 32bit systems
  23.  *
  24.  * Revision 5.3  1992/08/17  14:23:21  brennan
  25.  * patch2: After parsing, only bi_sprintf() uses string_buff.
  26.  *
  27.  * Revision 5.2  1992/02/24  10:52:16  brennan
  28.  * printf and sprintf() can now have more args than % conversions
  29.  * removed HAVE_PRINTF_HD -- it was too obscure
  30.  *
  31.  * Revision 5.1  91/12/05  07:56:22  brennan
  32.  * 1.1 pre-release
  33.  * 
  34. */
  35.  
  36. #include "mawk.h"
  37. #include "bi_vars.h"
  38. #include "bi_funct.h"
  39. #include "memory.h"
  40. #include "field.h"
  41. #include "scan.h"
  42. #include "files.h"
  43.  
  44. static void  PROTO( print_cell, (CELL *, FILE *) ) ;
  45. static STRING* PROTO( do_printf, (FILE *, char *, unsigned, CELL *) ) ;
  46. static void  PROTO( bad_conversion, (int, char *, char *)) ;
  47.  
  48.  
  49.  
  50. /* this can be moved and enlarged  by -W sprintf=num  */
  51. char *sprintf_buff = string_buff ;
  52. char *sprintf_limit = string_buff + SPRINTF_SZ ;
  53.  
  54. /* Once execute() starts the sprintf code is (belatedly) the only
  55.    code allowed to use string_buff  */
  56.  
  57. static void print_cell(p, fp)
  58.   register CELL *p ;
  59.   register FILE *fp ;
  60. { 
  61.   int len ;
  62.   
  63.   switch( p->type )
  64.   {
  65.     case C_NOINIT : break ;
  66.     case C_MBSTRN :
  67.     case C_STRING :
  68.     case C_STRNUM :
  69.         switch( len = string(p)->len )
  70.         {
  71.           case 0 :  break ;
  72.           case 1 :
  73.                     putc(string(p)->str[0],fp) ;
  74.                     break ;
  75.  
  76.           default :
  77.                     fwrite(string(p)->str, SIZE_T(1), SIZE_T(len), fp) ;
  78.         }
  79.         break ;
  80.  
  81.     case C_DOUBLE :
  82.     {
  83.       long ival = d_to_l(p->dval) ;
  84.  
  85.       /* integers print as "%[l]d" */ 
  86.       if ( (double) ival == p->dval )
  87.             fprintf(fp, INT_FMT, ival) ;
  88.       else
  89.           fprintf(fp, string(OFMT)->str, p->dval) ;
  90.     }
  91.         break ;
  92.  
  93.     default :
  94.         bozo("bad cell passed to print_cell") ;
  95.   }
  96. }
  97.  
  98. /* on entry to bi_print or bi_printf the stack is:
  99.  
  100.    sp[0] = an integer k
  101.        if ( k < 0 )  output is to a file with name in sp[-1]
  102.        { so open file and sp -= 2 }
  103.  
  104.    sp[0] = k >= 0 is the number of print args
  105.    sp[-k]   holds the first argument 
  106. */
  107.  
  108. CELL *bi_print(sp)
  109.   CELL *sp ; /* stack ptr passed in */
  110. { 
  111.   register CELL *p ;
  112.   register int k ;
  113.   FILE *fp ;
  114.  
  115.   k = sp->type ;
  116.   if ( k < 0 )
  117.   { 
  118.     /* k holds redirection */
  119.     if ( (--sp)->type < C_STRING ) cast1_to_s(sp) ;
  120.     fp = (FILE *) file_find( string(sp), k ) ;
  121.     free_STRING(string(sp)) ;
  122.     k = (--sp)->type ;
  123.     /* k now has number of arguments */
  124.   }
  125.   else  fp = stdout ;
  126.  
  127.   if ( k )  
  128.   { 
  129.     p = sp - k ; /* clear k variables off the stack */
  130.     sp = p - 1 ;
  131.     k-- ;
  132.  
  133.     while ( k > 0 ) 
  134.     { 
  135.       print_cell(p,fp) ; print_cell(OFS,fp) ;
  136.       cell_destroy(p) ; 
  137.       p++ ; k-- ;
  138.     }
  139.     
  140.     print_cell(p, fp) ;  cell_destroy(p) ;
  141.   }
  142.   else  
  143.   { /* print $0 */
  144.     sp-- ;
  145.     print_cell( &field[0], fp )  ;
  146.   }
  147.  
  148.   print_cell(ORS , fp) ;
  149.   return sp ;
  150. }
  151.   
  152. /*---------- types and defs for doing printf and sprintf----*/
  153. #define  PF_C        0   /* %c */
  154. #define  PF_S        1   /* %s */
  155. #define  PF_D        2   /* int conversion */
  156. #define  PF_F        3   /* float conversion */
  157.  
  158. /* for switch on number of '*' and type */
  159. #define  AST(num,type)  ((PF_F+1)*(num)+(type))
  160.  
  161. /* some picky ANSI compilers go berserk without this */
  162. #if HAVE_PROTOS
  163. typedef int (*PRINTER)(PTR,char *,...) ;
  164. #else
  165. typedef int (*PRINTER)() ;
  166. #endif
  167.  
  168. /*-------------------------------------------------------*/
  169.  
  170. static void bad_conversion(cnt, who, format)
  171.   int cnt ; 
  172.   char *who , *format ;
  173. {
  174.   rt_error( "improper conversion(number %d) in %s(\"%s\")", 
  175.          cnt, who, format ) ;
  176. }
  177.  
  178. /* the contents of format are preserved,
  179.    caller does CELL cleanup 
  180.  
  181.    This routine does both printf and sprintf (if fp==0)
  182. */
  183. static STRING *do_printf( fp, format, argcnt, cp)
  184.   FILE *fp ;
  185.   char *format ; 
  186.   CELL *cp ;  /* ptr to an array of arguments ( on the eval stack) */
  187.   unsigned argcnt ;  /* number of args on eval stack */
  188. { 
  189.   char  save ;
  190.   char *p ;
  191.   register char *q = format ;
  192.   register char *target ;
  193.   int l_flag , h_flag ;  /* seen %ld or %hd  */
  194.   int ast_cnt ;
  195.   int ast[2] ;
  196.   long lval ;  /* hold integer values */
  197.   int num_conversion = 0 ; /* for error messages */
  198.   char *who ; /*ditto*/
  199.   int pf_type ;  /* conversion type */
  200.   PRINTER printer ; /* pts at fprintf() or sprintf() */
  201.  
  202. #ifdef   SHORT_INTS
  203.   char xbuff[256] ; /* splice in l qualifier here */
  204. #endif
  205.  
  206.   if ( fp == (FILE *) 0 ) /* doing sprintf */
  207.   {
  208.     target = sprintf_buff ;
  209.     printer = (PRINTER) sprintf ;
  210.     who = "sprintf" ;
  211.   }
  212.   else /* doing printf */
  213.   {
  214.     target = (char *) fp ; /* will never change */
  215.     printer = (PRINTER) fprintf ;
  216.     who = "printf" ;
  217.   }
  218.  
  219.   while ( 1 )
  220.   { 
  221.     if ( fp )  /* printf */
  222.     {
  223.       while ( *q != '%' )
  224.     if ( *q == 0 )  return (STRING *) 0 ;
  225.     else
  226.     { putc(*q,fp) ; q++ ; }
  227.     }
  228.     else  /* sprintf */
  229.     {
  230.       while ( *q != '%' )
  231.     if ( *q == 0 )
  232.     {
  233.         if ( target > sprintf_limit ) /* damaged */
  234.         {
  235.           /* hope this works */
  236.           rt_overflow("sprintf buffer",
  237.               sprintf_limit - sprintf_buff) ;
  238.         }
  239.         else  /* really done */
  240.         {
  241.           STRING *retval ;
  242.           int len = target - sprintf_buff ;
  243.  
  244.           retval = new_STRING((char*)0, len) ;
  245.           (void)memcpy(retval->str, sprintf_buff, SIZE_T(len)) ;
  246.           return retval ;
  247.         }
  248.     }
  249.     else  *target++ = *q++ ;
  250.     }
  251.        
  252.  
  253.     /* *q == '%' */
  254.     num_conversion++ ;
  255.   
  256.     if ( * ++q == '%' )   /* %% */
  257.     {
  258.     if ( fp )   putc(*q, fp) ; 
  259.     else *target++ = *q ;
  260.  
  261.     q++ ; continue ;
  262.     }
  263.  
  264.     /* mark the '%' with p */
  265.     p = q-1 ;
  266.  
  267.     /* eat the flags */
  268.     while ( *q == '-' || *q == '+' || *q == ' ' ||
  269.             *q == '#' || *q == '0' )  q++ ;
  270.  
  271.     ast_cnt = 0 ;
  272.     if ( *q == '*' )
  273.     { 
  274.       if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  275.       ast[ast_cnt++] = d_to_i(cp++ ->dval) ;
  276.       argcnt-- ; q++ ;
  277.     }
  278.     else
  279.     while ( scan_code[*(unsigned char *)q] == SC_DIGIT )  q++ ;
  280.     /* width is done */
  281.  
  282.     if ( *q == '.' )  /* have precision */
  283.     { q++ ;
  284.       if ( *q == '*' )
  285.       {
  286.     if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  287.         ast[ast_cnt++] = d_to_i(cp++ ->dval) ;
  288.         argcnt-- ; q++ ;
  289.       }
  290.       else
  291.       while ( scan_code[*(unsigned char*)q] == SC_DIGIT ) q++ ; 
  292.     }
  293.  
  294.     if ( argcnt <= 0 )  
  295.         rt_error("not enough arguments passed to %s(\"%s\")",
  296.           who, format) ;
  297.  
  298.     l_flag = h_flag = 0 ;
  299.  
  300.     if ( *q == 'l' ) { q++ ; l_flag = 1 ; }
  301.     else
  302.     if ( *q == 'h' ) { q++ ; h_flag = 1 ; }
  303.  
  304.     switch( *q++ )
  305.     {
  306.       case 's' :
  307.             if ( l_flag + h_flag ) 
  308.         bad_conversion(num_conversion,who,format) ;
  309.             if ( cp->type < C_STRING ) cast1_to_s(cp) ;
  310.             pf_type = PF_S ;
  311.             break ;
  312.  
  313.       case 'c' :
  314.             if ( l_flag + h_flag )
  315.         bad_conversion(num_conversion,who,format) ;
  316.  
  317.         switch( cp->type )
  318.         {
  319.           case C_NOINIT :
  320.             lval = 0 ;
  321.             break ;
  322.  
  323.           case C_STRNUM :
  324.           case C_DOUBLE :
  325.             lval = (long) d_to_i(cp->dval) ;
  326.             break ;
  327.  
  328.           case  C_STRING :
  329.             lval = string(cp)->str[0] ;
  330.             break ;
  331.  
  332.           case  C_MBSTRN :
  333.             check_strnum(cp) ;
  334.             lval = cp->type == C_STRING ?
  335.             string(cp)->str[0] : (long) d_to_i(cp->dval) ;
  336.             break ;
  337.           
  338.           default :
  339.             bozo("printf %c") ;
  340.         }
  341.  
  342.             pf_type = PF_C ;
  343.         break ;
  344.  
  345.       case 'd' :
  346.       case 'o' :
  347.       case 'x' :
  348.       case 'X' :
  349.       case 'i' :
  350.       case 'u' :
  351.             if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  352.         if ( cp->dval > MAX__LONG ) lval = MAX__LONG ;
  353.         else
  354.         if ( cp->dval > -MAX__LONG ) lval = (long) cp->dval ;
  355.         else lval = -MAX__LONG ;
  356.  
  357.             pf_type = PF_D ;
  358.             break ;
  359.     
  360.       case 'e' :
  361.       case 'g' :
  362.       case 'f' :
  363.       case 'E' :
  364.       case 'G' :
  365.             if ( h_flag + l_flag )
  366.         bad_conversion(num_conversion,who,format) ;
  367.             if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  368.             pf_type = PF_F ;
  369.             break ;
  370.  
  371.       default : bad_conversion(num_conversion,who,format) ;
  372.     }
  373.  
  374.     save = *q ;
  375.     *q = 0 ;
  376.  
  377. #ifdef  SHORT_INTS
  378.     if ( pf_type == PF_D )
  379.     {
  380.       /* need to splice in long modifier */
  381.       strcpy(xbuff, p) ;
  382.  
  383.       if ( l_flag ) /* do nothing */ ;
  384.       else
  385.       {
  386.     int k = q - p ;
  387.  
  388.     if ( h_flag )
  389.     {
  390.       lval = (short) lval ;
  391.       /* replace the 'h' with 'l' (really!) */
  392.       xbuff[k-2] = 'l' ;
  393.       if ( xbuff[k-1] != 'd' && xbuff[k-1] != 'i' ) lval &= 0xffff ;
  394.     }
  395.     else
  396.     {
  397.       /* the usual case */
  398.       xbuff[k] = xbuff[k-1] ;
  399.       xbuff[k-1] = 'l' ;
  400.       xbuff[k+1] = 0 ;
  401.     }
  402.       }
  403.     }
  404. #endif
  405.  
  406.     /* ready to call printf() */
  407.     switch( AST(ast_cnt, pf_type ) )
  408.     {
  409.       case AST(0, PF_C )  :
  410.             (*printer)((PTR) target, p, (int) lval) ;
  411.             break ;
  412.  
  413.       case AST(1, PF_C ) :
  414.             (*printer)((PTR) target, p, ast[0], (int) lval) ;
  415.             break ;
  416.  
  417.       case AST(2, PF_C ) :
  418.             (*printer)((PTR) target, p, ast[0], ast[1], (int)lval) ;
  419.             break ;
  420.  
  421.       case AST(0, PF_S) :
  422.             (*printer)((PTR) target, p, string(cp)->str) ;
  423.             break ;
  424.  
  425.       case AST(1, PF_S) :
  426.             (*printer)((PTR) target, p, ast[0],string(cp)->str) ;
  427.             break ;
  428.  
  429.       case AST(2, PF_S) :
  430.             (*printer)((PTR) target,p,ast[0],ast[1],string(cp)->str) ;
  431.             break ;
  432.  
  433. #ifdef  SHORT_INTS
  434. #define    FMT    xbuff     /* format in xbuff */
  435. #else
  436. #define FMT     p         /* p -> format */
  437. #endif
  438.       case AST(0, PF_D) :
  439.             (*printer)((PTR) target, FMT, lval) ;
  440.             break ;
  441.  
  442.       case AST(1, PF_D) :
  443.             (*printer)((PTR) target, FMT, ast[0], lval) ;
  444.             break ;
  445.  
  446.       case AST(2, PF_D) :
  447.             (*printer)((PTR) target, FMT, ast[0], ast[1], lval) ;
  448.             break ;
  449.  
  450. #undef  FMT
  451.  
  452.  
  453.       case AST(0, PF_F) :
  454.             (*printer)((PTR) target, p,  cp->dval) ;
  455.             break ;
  456.  
  457.       case AST(1, PF_F) :
  458.             (*printer)((PTR) target, p, ast[0],  cp->dval) ;
  459.             break ;
  460.  
  461.       case AST(2, PF_F) :
  462.             (*printer)((PTR) target, p, ast[0], ast[1],  cp->dval) ;
  463.             break ;
  464.     }
  465.     if ( fp == (FILE *) 0 ) while ( *target ) target++ ;
  466.     *q = save ; argcnt-- ; cp++ ;
  467.   }
  468. }
  469.  
  470. CELL *bi_printf(sp)
  471.   register CELL *sp ;
  472. { register int k ;
  473.   register CELL *p ;
  474.   FILE *fp ;
  475.  
  476.   k = sp->type ;
  477.   if ( k  < 0 )
  478.   { 
  479.     /* k has redirection */
  480.     if ( (--sp)->type < C_STRING ) cast1_to_s(sp) ;
  481.     fp = (FILE *) file_find( string(sp), k ) ;
  482.     free_STRING(string(sp)) ;
  483.     k = (--sp)->type ;
  484.     /* k is now number of args including format */
  485.   }
  486.   else  fp = stdout ;
  487.  
  488.   sp -= k ; /* sp points at the format string */
  489.   k-- ;
  490.  
  491.   if ( sp->type < C_STRING )  cast1_to_s(sp) ;
  492.   do_printf(fp, string(sp)->str, k, sp+1) ;
  493.   free_STRING(string(sp)) ;
  494.  
  495.   /* cleanup arguments on eval stack */
  496.   for ( p = sp+1 ; k ; k--, p++ )  cell_destroy(p) ;
  497.   return --sp ;
  498. }
  499.  
  500. CELL *bi_sprintf(sp)
  501.   CELL *sp ;
  502. { CELL *p ;
  503.   int argcnt = sp->type ;
  504.   STRING *sval ;
  505.  
  506.   sp -= argcnt ; /* sp points at the format string */
  507.   argcnt-- ;
  508.  
  509.   if ( sp->type != C_STRING )  cast1_to_s(sp) ;
  510.   sval = do_printf((FILE *)0, string(sp)->str, argcnt, sp+1) ;
  511.   free_STRING(string(sp)) ;
  512.   sp->ptr = (PTR) sval ;
  513.  
  514.   /* cleanup */
  515.   for (p = sp+1 ; argcnt ; argcnt--, p++ )  cell_destroy(p) ;
  516.  
  517.   return sp ;
  518. }
  519.  
  520.  
  521.