home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-387-Vol-3of3.iso / m / mawk11as.zip / PRINT.C < prev    next >
C/C++ Source or Header  |  1991-12-18  |  11KB  |  454 lines
  1.  
  2. /********************************************
  3. print.c
  4. copyright 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.1  91/12/05  07:56:22  brennan
  15.  * 1.1 pre-release
  16.  * 
  17. */
  18.  
  19. #include "mawk.h"
  20. #include "bi_vars.h"
  21. #include "bi_funct.h"
  22. #include "memory.h"
  23. #include "field.h"
  24. #include "scan.h"
  25. #include "files.h"
  26.  
  27. static void  PROTO( print_cell, (CELL *, FILE *) ) ;
  28. static STRING* PROTO( do_printf, (FILE *, char *, unsigned, CELL *) ) ;
  29. static void  PROTO( arg_error, (char *, char *, char *) ) ;
  30. static void  PROTO( bad_conversion, (int, char *, char *)) ;
  31.  
  32.  
  33.  
  34. /* this can be moved and enlarged  by -W sprintf=num  */
  35. char *sprintf_buff = string_buff ;
  36. char *sprintf_limit = string_buff + SPRINTF_SZ ;
  37.  
  38. static void print_cell(p, fp)
  39.   register CELL *p ;
  40.   register FILE *fp ;
  41. { register int len ;
  42.   
  43.   switch( p->type )
  44.   {
  45.     case C_NOINIT : break ;
  46.     case C_MBSTRN :
  47.     case C_STRING :
  48.     case C_STRNUM :
  49.         switch( len = string(p)->len )
  50.         {
  51.           case 0 :  break ;
  52.           case 1 :
  53.                     putc(string(p)->str[0],fp) ;
  54.                     break ;
  55.  
  56.           default :
  57.                     fwrite(string(p)->str, SIZE_T(1), SIZE_T(len), fp) ;
  58.         }
  59.         break ;
  60.  
  61.     case C_DOUBLE :
  62.     if ( (double)(len = (int) p->dval) == p->dval )
  63.         fprintf(fp, "%d", len) ;
  64.     else
  65.         fprintf(fp, string(OFMT)->str, p->dval) ;
  66.         break ;
  67.  
  68.     default :
  69.         bozo("bad cell passed to print_cell") ;
  70.   }
  71. }
  72.  
  73. /* on entry to bi_print or bi_printf the stack is:
  74.  
  75.    sp[0] = an integer k
  76.        if ( k < 0 )  output is to a file with name in sp[-1]
  77.        { so open file and sp -= 2 }
  78.  
  79.    sp[0] = k >= 0 is the number of print args
  80.    sp[-k]   holds the first argument 
  81. */
  82.  
  83. CELL *bi_print(sp)
  84.   CELL *sp ; /* stack ptr passed in */
  85. { register CELL *p ;
  86.   register int k ;
  87.   FILE *fp ;
  88.  
  89.   if ( (k = sp->type) < 0 )
  90.   { if ( (--sp)->type < C_STRING ) cast1_to_s(sp) ;
  91.     fp = (FILE *) file_find( string(sp), k ) ;
  92.     free_STRING(string(sp)) ;
  93.     k = (--sp)->type ;
  94.   }
  95.   else  fp = stdout ;
  96.  
  97.   if ( k )  
  98.   { p = sp - k ; /* clear k variables off the stack */
  99.     sp = p - 1 ;
  100.     while ( k-- > 1 ) 
  101.     { print_cell(p,fp) ; print_cell(OFS,fp) ;
  102.       cell_destroy(p) ; p++ ; }
  103.     
  104.     print_cell(p, fp) ;  cell_destroy(p) ;
  105.   }
  106.   else  
  107.   { sp-- ;
  108.     print_cell( &field[0], fp )  ; }
  109.  
  110.   print_cell(ORS , fp) ;
  111.   return sp ;
  112. }
  113.   
  114. /*---------- types and defs for doing printf and sprintf----*/
  115. #define  PF_C        0
  116. #define  PF_S        1
  117. #define  PF_D        2   /* int conversion */
  118. #define  PF_LD        3   /* long int */
  119. #define  PF_F        4   /* float conversion */
  120.  
  121. /* for switch on number of '*' and type */
  122. #define  AST(num,type)  (5*(num)+(type))
  123.  
  124. /* some picky ANSI compilers go berserk without this */
  125. #if HAVE_PROTOS
  126. typedef int (*PRINTER)(PTR,char *,...) ;
  127. #else
  128. typedef int (*PRINTER)() ;
  129. #endif
  130.  
  131. /*-------------------------------------------------------*/
  132.  
  133. static void  arg_error( few_or_many, who, format)
  134.   char *few_or_many , *who, *format ;
  135. {
  136.   rt_error("too %s arguments passed to %s(\"%s\")",
  137.     few_or_many, who, format) ;
  138. }
  139.  
  140. static void bad_conversion(cnt, who, format)
  141.   int cnt ; 
  142.   char *who , *format ;
  143. {
  144.   rt_error( "improper conversion(number %d) in %s(\"%s\")", 
  145.          cnt, who, format ) ;
  146. }
  147.  
  148. /* the contents of format are preserved,
  149.    caller does CELL cleanup 
  150.  
  151.    This routine does both printf and sprintf (if fp==0)
  152. */
  153. static STRING *do_printf( fp, format, argcnt, cp)
  154.   FILE *fp ;
  155.   char *format ; 
  156.   CELL *cp ;  /* ptr to an array of arguments ( on the eval stack) */
  157.   unsigned argcnt ;  /* number of args on eval stack */
  158. { 
  159.   char  save ;
  160.   char *p ;
  161.   register char *q = format ;
  162.   register char *target ;
  163.   int l_flag , h_flag ;  /* seen %ld or %hd  */
  164.   int ast_cnt ;
  165.   int ast[2] ;
  166.   long lval ;
  167.   int ival ;  /* caters to MSDOS */
  168.   int num_conversion = 0 ; /* for error messages */
  169.   char *who ; /*ditto*/
  170.   int pf_type ;  /* conversion type */
  171.   PRINTER printer ; /* pts at fprintf() or sprintf() */
  172.  
  173.   if ( fp == (FILE *) 0 ) /* doing sprintf */
  174.   {
  175.     target = sprintf_buff ;
  176.     printer = (PRINTER) sprintf ;
  177.     who = "sprintf" ;
  178.   }
  179.   else /* doing printf */
  180.   {
  181.     target = (char *) fp ; /* will never change */
  182.     printer = (PRINTER) fprintf ;
  183.     who = "printf" ;
  184.   }
  185.  
  186.   while ( 1 )
  187.   { 
  188.     if ( fp )
  189.     {
  190.       while ( *q != '%' )
  191.     if ( *q == 0 )
  192.             if ( argcnt == 0 )  return (STRING *) 0 ;
  193.             else arg_error("many", who, format) ;
  194.     else
  195.     { putc(*q,fp) ; q++ ; }
  196.     }
  197.     else
  198.     {
  199.       while ( *q != '%' )
  200.     if ( *q == 0 )
  201.         if ( argcnt == 0 ) /* done */
  202.         if ( target > sprintf_limit ) /* damaged */
  203.         {
  204.           /* hope this works */
  205.           rt_overflow("sprintf buffer",
  206.               sprintf_limit - sprintf_buff) ;
  207.         }
  208.         else  /* really done */
  209.         {
  210.           STRING *retval ;
  211.           int len = target - sprintf_buff ;
  212.  
  213.           retval = new_STRING((char*)0, len) ;
  214.           (void)memcpy(retval->str, sprintf_buff, SIZE_T(len)) ;
  215.           return retval ;
  216.         }
  217.             else arg_error("many", who, format) ;
  218.     else  *target++ = *q++ ;
  219.     }
  220.        
  221.  
  222.     num_conversion++ ;
  223.   
  224.     if ( * ++q == '%' )   /* %% */
  225.     {
  226.     if ( fp )   putc(*q, fp) ; 
  227.     else *target++ = *q ;
  228.  
  229.     q++ ; continue ;
  230.     }
  231.  
  232.     /* mark the '%' with p */
  233.     p = q-1 ;
  234.  
  235.     /* eat the flags */
  236.     while ( *q == '-' || *q == '+' || *q == ' ' ||
  237.             *q == '#' || *q == '0' )  q++ ;
  238.  
  239.     ast_cnt = 0 ;
  240.     if ( *q == '*' )
  241.     { 
  242.       if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  243.       ast[ast_cnt++] = (int) cp++ ->dval ;
  244.       argcnt-- ; q++ ;
  245.     }
  246.     else
  247.     while ( scan_code[*(unsigned char *)q] == SC_DIGIT )  q++ ;
  248.     /* width is done */
  249.  
  250.     if ( *q == '.' )  /* have precision */
  251.     { q++ ;
  252.       if ( *q == '*' )
  253.       {
  254.     if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  255.         ast[ast_cnt++] = (int) cp++ ->dval ;
  256.         argcnt-- ; q++ ;
  257.       }
  258.       else
  259.       while ( scan_code[*(unsigned char*)q] == SC_DIGIT ) q++ ; 
  260.     }
  261.  
  262.     if ( argcnt <= 0 )  arg_error("few", who, format) ;
  263.     l_flag = h_flag = 0 ;
  264.  
  265.     if ( *q == 'l' ) { q++ ; l_flag = 1 ; }
  266.  
  267. #if HAVE_PRINTF_HD
  268.     else
  269.     if ( *q == 'h' ) { q++ ; h_flag = 1 ; }
  270. #endif
  271.  
  272.     switch( *q++ )
  273.     {
  274.       case 's' :
  275.             if ( l_flag + h_flag ) 
  276.         bad_conversion(num_conversion,who,format) ;
  277.             if ( cp->type < C_STRING ) cast1_to_s(cp) ;
  278.             pf_type = PF_S ;
  279.             break ;
  280.  
  281.       case 'c' :
  282.             if ( l_flag + h_flag )
  283.         bad_conversion(num_conversion,who,format) ;
  284.  
  285.         switch( cp->type )
  286.         {
  287.           case C_NOINIT :
  288.             ival = 0 ;
  289.             break ;
  290.  
  291.           case C_STRNUM :
  292.           case C_DOUBLE :
  293.             ival = (int) cp->dval ;
  294.             break ;
  295.  
  296.           case  C_STRING :
  297.             ival = string(cp)->str[0] ;
  298.             break ;
  299.  
  300.           case  C_MBSTRN :
  301.             check_strnum(cp) ;
  302.             ival = cp->type == C_STRING ?
  303.             string(cp)->str[0] : (int) cp->dval ;
  304.             break ;
  305.           
  306.           default :
  307.             bozo("printf %c") ;
  308.         }
  309.  
  310.             pf_type = PF_C ;
  311.         break ;
  312.  
  313.       case 'd' :
  314.       case 'o' :
  315.       case 'x' :
  316.       case 'X' :
  317.       case 'i' :
  318.       case 'u' :
  319.             if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  320.             lval = (long) cp->dval ;
  321. #if HAVE_PRINTF_HD
  322.         if ( h_flag ) lval &= 0xffff ;
  323. #endif
  324.             pf_type = l_flag ? PF_LD : PF_D ;
  325.             break ;
  326.     
  327.       case 'e' :
  328.       case 'g' :
  329.       case 'f' :
  330.       case 'E' :
  331.       case 'G' :
  332.             if ( h_flag + l_flag )
  333.         bad_conversion(num_conversion,who,format) ;
  334.             if ( cp->type != C_DOUBLE ) cast1_to_d(cp) ;
  335.             pf_type = PF_F ;
  336.             break ;
  337.  
  338.       default : bad_conversion(num_conversion,who,format) ;
  339.     }
  340.  
  341.     save = *q ;
  342.     *q = 0 ;
  343.  
  344.     /* ready to call printf() */
  345.     switch( AST(ast_cnt, pf_type ) )
  346.     {
  347.       case AST(0, PF_C )  :
  348.             (*printer)((PTR) target, p, ival) ;
  349.             break ;
  350.  
  351.       case AST(1, PF_C ) :
  352.             (*printer)((PTR) target, p, ast[0], ival) ;
  353.             break ;
  354.  
  355.       case AST(2, PF_C ) :
  356.             (*printer)((PTR) target, p, ast[0], ast[1], ival) ;
  357.             break ;
  358.  
  359.       case AST(0, PF_S) :
  360.             (*printer)((PTR) target, p, string(cp)->str) ;
  361.             break ;
  362.  
  363.       case AST(1, PF_S) :
  364.             (*printer)((PTR) target, p, ast[0],string(cp)->str) ;
  365.             break ;
  366.  
  367.       case AST(2, PF_S) :
  368.             (*printer)((PTR) target, p, ast[0], ast[1], string(cp)->str) ;
  369.             break ;
  370.  
  371.       case AST(0, PF_D) :
  372.             (*printer)((PTR) target, p, (int) lval) ;
  373.             break ;
  374.  
  375.       case AST(1, PF_D) :
  376.             (*printer)((PTR) target, p, ast[0], (int) lval) ;
  377.             break ;
  378.  
  379.       case AST(2, PF_D) :
  380.             (*printer)((PTR) target, p, ast[0], ast[1], (int) lval) ;
  381.             break ;
  382.  
  383.       case AST(0, PF_LD) :
  384.             (*printer)((PTR) target, p,  lval) ;
  385.             break ;
  386.  
  387.       case AST(1, PF_LD) :
  388.             (*printer)((PTR) target, p, ast[0],  lval) ;
  389.             break ;
  390.  
  391.       case AST(2, PF_LD) :
  392.             (*printer)((PTR) target, p, ast[0], ast[1],  lval) ;
  393.             break ;
  394.  
  395.       case AST(0, PF_F) :
  396.             (*printer)((PTR) target, p,  cp->dval) ;
  397.             break ;
  398.  
  399.       case AST(1, PF_F) :
  400.             (*printer)((PTR) target, p, ast[0],  cp->dval) ;
  401.             break ;
  402.  
  403.       case AST(2, PF_F) :
  404.             (*printer)((PTR) target, p, ast[0], ast[1],  cp->dval) ;
  405.             break ;
  406.     }
  407.     if ( fp == (FILE *) 0 ) while ( *target ) target++ ;
  408.     *q = save ; argcnt-- ; cp++ ;
  409.   }
  410. }
  411.  
  412. CELL *bi_printf(sp)
  413.   register CELL *sp ;
  414. { register int k ;
  415.   register CELL *p ;
  416.   FILE *fp ;
  417.  
  418.   if ( (k = sp->type) < 0 )
  419.   { if ( (--sp)->type < C_STRING ) cast1_to_s(sp) ;
  420.     fp = (FILE *) file_find( string(sp), k ) ;
  421.     free_STRING(string(sp)) ;
  422.     k = (--sp)->type ;
  423.   }
  424.   else  fp = stdout ;
  425.  
  426.   sp -= k-- ; /* sp points at the format string */
  427.   if ( sp->type < C_STRING )  cast1_to_s(sp) ;
  428.   do_printf(fp, string(sp)->str, k, sp+1) ;
  429.  
  430.   free_STRING(string(sp)) ;
  431.   for ( p = sp+1 ; k-- ; p++ )  cell_destroy(p) ;
  432.   return --sp ;
  433. }
  434.  
  435. CELL *bi_sprintf(sp)
  436.   CELL *sp ;
  437. { CELL *p ;
  438.   int argcnt = sp->type ;
  439.   STRING *sval ;
  440.  
  441.   sp -= argcnt-- ; /* sp points at the format string */
  442.   if ( sp->type != C_STRING )  cast1_to_s(sp) ;
  443.  
  444.   sval = do_printf((FILE *)0, string(sp)->str, argcnt, sp+1) ;
  445.   free_STRING(string(sp)) ;
  446.   sp->ptr = (PTR) sval ;
  447.  
  448.   for ( p = sp+1 ; argcnt-- ; p++ )  cell_destroy(p) ;
  449.  
  450.   return sp ;
  451. }
  452.  
  453.  
  454.