home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 11 Util / 11-Util.zip / MAWK113.ZIP / mawk113 / cast.c < prev    next >
C/C++ Source or Header  |  1993-01-22  |  10KB  |  448 lines
  1.  
  2. /********************************************
  3. cast.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.  
  14. /*   $Log: cast.c,v $
  15.  * Revision 5.3.1.4  1993/01/22  15:05:19  mike
  16.  * pow2->mpow2 for linux
  17.  *
  18.  * Revision 5.3.1.3  1993/01/22  14:18:33  mike
  19.  * const for strtod and ansi picky compilers
  20.  *
  21.  * Revision 5.3.1.2  1993/01/20  12:53:06  mike
  22.  * d_to_l()
  23.  *
  24.  * Revision 5.3.1.1  1993/01/15  03:33:37  mike
  25.  * patch3: safer double to int conversion
  26.  *
  27.  * Revision 5.3  1992/11/28  23:48:42  mike
  28.  * For internal conversion numeric->string, when testing
  29.  * if integer, use longs instead of ints so 16 and 32 bit
  30.  * systems behave the same
  31.  *
  32.  * Revision 5.2  1992/08/17  14:19:45  brennan
  33.  * patch2: After parsing, only bi_sprintf() uses string_buff.
  34.  *
  35.  * Revision 5.1  1991/12/05  07:55:41  brennan
  36.  * 1.1 pre-release
  37.  *
  38. */
  39.  
  40.  
  41. /*  cast.c  */
  42.  
  43. #include "mawk.h"
  44. #include "field.h"
  45. #include "memory.h"
  46. #include "scan.h"
  47. #include "repl.h"
  48.  
  49. int mpow2[NUM_CELL_TYPES] = {1,2,4,8,16,32,64,128,256,512} ;
  50.  
  51. void cast1_to_d( cp )
  52.   register CELL *cp ;
  53. {
  54.   switch( cp->type )
  55.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  56.  
  57.     case C_DOUBLE :  return ;
  58.  
  59.     case C_MBSTRN :
  60.     case C_STRING :  
  61.           { register STRING *s = (STRING *) cp->ptr  ;
  62.  
  63. #if FPE_TRAPS_ON  /* look for overflow error */
  64.             errno = 0 ;
  65.             cp->dval = strtod(s->str,(char **)0) ;
  66.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  67.                 rt_error("overflow converting %s to double", s) ;
  68. #else
  69.             cp->dval = strtod(s->str,(char **)0) ;
  70. #endif
  71.             free_STRING(s) ;
  72.           }
  73.             break ;
  74.  
  75.     case C_STRNUM :  
  76.       /* don't need to convert, but do need to free the STRING part */
  77.             free_STRING( string(cp) ) ;
  78.             break ;
  79.  
  80.  
  81.     default :
  82.             bozo("cast on bad type") ;
  83.   }
  84.   cp->type = C_DOUBLE ;
  85. }
  86.  
  87. void cast2_to_d( cp )
  88.   register CELL *cp ;
  89. { register STRING *s ;
  90.  
  91.   switch( cp->type )
  92.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  93.  
  94.     case C_DOUBLE :  goto two ;
  95.     case C_STRNUM :  
  96.             free_STRING( string(cp) ) ;
  97.             break ;
  98.  
  99.     case C_MBSTRN :
  100.     case C_STRING :  
  101.             s = (STRING *) cp->ptr ;
  102.  
  103. #if FPE_TRAPS_ON  /* look for overflow error */
  104.             errno = 0 ;
  105.             cp->dval = strtod(s->str,(char **)0) ;
  106.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  107.                 rt_error("overflow converting %s to double", s) ;
  108. #else
  109.             cp->dval = strtod(s->str,(char **)0) ;
  110. #endif
  111.             free_STRING(s) ;
  112.             break ;
  113.  
  114.     default :
  115.             bozo("cast on bad type") ;
  116.   }
  117.   cp->type = C_DOUBLE ;
  118.  
  119. two:   cp++ ;
  120.   switch( cp->type )
  121.   { case C_NOINIT :  cp->dval = 0.0 ; break ;
  122.  
  123.     case C_DOUBLE :  return ;
  124.     case C_STRNUM :  
  125.             free_STRING( string(cp) ) ;
  126.             break ;
  127.  
  128.     case C_MBSTRN :
  129.     case C_STRING :  
  130.             s = (STRING *) cp->ptr ;
  131.  
  132. #if FPE_TRAPS_ON  /* look for overflow error */
  133.             errno = 0 ;
  134.             cp->dval = strtod(s->str,(char **)0) ;
  135.             if ( errno && cp->dval != 0.0 ) /* ignore underflow */
  136.                 rt_error("overflow converting %s to double", s) ;
  137. #else
  138.             cp->dval = strtod(s->str,(char **)0) ;
  139. #endif
  140.             free_STRING(s) ;
  141.             break ;
  142.  
  143.     default :
  144.             bozo("cast on bad type") ;
  145.   }
  146.   cp->type = C_DOUBLE ;
  147. }
  148.  
  149. void cast1_to_s( cp )
  150.   register CELL *cp ;
  151. { 
  152.   register long lval ;
  153.   char xbuff[260] ;
  154.  
  155.   switch( cp->type )
  156.   { case C_NOINIT :  
  157.         null_str.ref_cnt++ ;
  158.         cp->ptr = (PTR) &null_str ;
  159.         break ;
  160.  
  161.     case C_DOUBLE  :
  162.     
  163.     lval = d_to_l(cp->dval) ;
  164.     if ( lval == cp->dval )
  165.         (void) sprintf(xbuff, INT_FMT, lval) ;
  166.     else
  167.             (void) sprintf(xbuff , string(CONVFMT)->str, cp->dval) ;
  168.  
  169.         cp->ptr = (PTR) new_STRING(xbuff) ;
  170.         break ;
  171.  
  172.     case C_STRING :  return ;
  173.  
  174.     case C_MBSTRN :
  175.     case C_STRNUM :  break ;
  176.  
  177.     default :  bozo("bad type on cast") ;
  178.   }
  179.   cp->type = C_STRING ;
  180. }
  181.  
  182. void cast2_to_s( cp )
  183.   register CELL *cp ;
  184. { 
  185.   register long lval ;
  186.   char xbuff[260] ;
  187.  
  188.   switch( cp->type )
  189.   { case C_NOINIT : 
  190.         null_str.ref_cnt++ ;
  191.         cp->ptr = (PTR) &null_str ;
  192.         break ;
  193.  
  194.     case C_DOUBLE  :
  195.  
  196.     lval = d_to_l(cp->dval) ;
  197.     if ( lval == cp->dval )
  198.         (void) sprintf(xbuff, INT_FMT, lval) ;
  199.     else
  200.             (void) sprintf(xbuff , string(CONVFMT)->str, cp->dval) ;
  201.  
  202.         cp->ptr = (PTR) new_STRING(xbuff) ;
  203.         break ;
  204.  
  205.     case C_STRING :  goto two ;
  206.  
  207.     case C_MBSTRN :
  208.     case C_STRNUM :  break ;
  209.  
  210.     default :  bozo("bad type on cast") ;
  211.   }
  212.   cp->type = C_STRING ;
  213.  
  214. two:
  215.   cp++ ;
  216.  
  217.   switch( cp->type )
  218.   { case C_NOINIT :  
  219.         null_str.ref_cnt++ ; 
  220.         cp->ptr = (PTR) &null_str ;
  221.         break ;
  222.  
  223.     case C_DOUBLE  :
  224.  
  225.     lval = d_to_l(cp->dval) ;
  226.     if ( lval == cp->dval )
  227.         (void) sprintf(xbuff, INT_FMT, lval) ;
  228.     else
  229.             (void) sprintf(xbuff , string(CONVFMT)->str, cp->dval) ;
  230.  
  231.         cp->ptr = (PTR) new_STRING(xbuff) ;
  232.         break ;
  233.  
  234.     case C_STRING :  return ;
  235.  
  236.     case C_MBSTRN :
  237.     case C_STRNUM :  break ;
  238.  
  239.     default :  bozo("bad type on cast") ;
  240.   }
  241.   cp->type = C_STRING ;
  242. }
  243.  
  244. void  cast_to_RE( cp )
  245.   register CELL *cp ;
  246. { register PTR p ;
  247.  
  248.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  249.  
  250.   p = re_compile( string(cp) ) ;
  251.   free_STRING( string(cp) ) ;
  252.   cp->type = C_RE ;
  253.   cp->ptr = p ;
  254.  
  255. }
  256.  
  257. void  cast_for_split(cp)
  258.   register CELL *cp ;
  259. {
  260.   static char meta[] = "^$.*+?|[]()" ;
  261.   static char xbuff[] = "\\X" ;
  262.   int c ;
  263.   unsigned len ;
  264.     
  265.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  266.  
  267.   if ( (len = string(cp)->len) == 1 )
  268.   {
  269.         if ( (c = string(cp)->str[0]) == ' ' )
  270.         { free_STRING(string(cp)) ;
  271.           cp->type = C_SPACE ; 
  272.           return ; 
  273.         }
  274.         else
  275.         if ( strchr(meta, c) )
  276.         { xbuff[1] = c ;
  277.           free_STRING(string(cp)) ;
  278.           cp->ptr = (PTR) new_STRING(xbuff) ;
  279.         }
  280.   }
  281.   else
  282.   if ( len == 0 ) 
  283.   { free_STRING(string(cp)) ;
  284.     cp->type = C_SNULL ; 
  285.     return ; 
  286.   }
  287.  
  288.   cast_to_RE(cp) ;
  289. }
  290.  
  291. /* input: cp-> a CELL of type C_MBSTRN (maybe strnum)
  292.    test it -- casting it to the appropriate type
  293.    which is C_STRING or C_STRNUM
  294. */
  295.  
  296. void check_strnum( cp )
  297.   CELL *cp ;
  298. { char *test ;
  299.   register unsigned char *s , *q ;
  300.  
  301.   cp->type = C_STRING ; /* assume not C_STRNUM */
  302.   s = (unsigned char *) string(cp)->str ;
  303.   q = s + string(cp)->len ;
  304.   while ( scan_code[*s] == SC_SPACE )  s++ ;
  305.   if ( s == q )  return ;
  306.  
  307.   while ( scan_code[ q[-1] ] == SC_SPACE )  q-- ;
  308.   if ( scan_code[ q[-1] ] != SC_DIGIT &&
  309.        q[-1] != '.' )   return ;
  310.  
  311.   switch ( scan_code[*s] )
  312.   {
  313.     case SC_DIGIT :
  314.     case SC_PLUS  :
  315.     case SC_MINUS :
  316.     case SC_DOT   :
  317.  
  318. #if FPE_TRAPS_ON
  319.              errno = 0 ;
  320.              cp->dval  = strtod((char *)s, &test) ;
  321.              if ( errno && cp->dval != 0.0 )
  322.                 rt_error(
  323.                 "overflow converting %s to double" , s) ;
  324. #else
  325.              cp->dval = strtod((char *)s, &test) ;
  326. #endif
  327.  
  328.              if ((char *) q <= test )  cp->type = C_STRNUM ;
  329.          /*  <= instead of == , for some buggy strtod
  330.          e.g. Apple Unix */
  331.   }
  332. }
  333.  
  334. /* cast a CELL to a replacement cell */
  335.  
  336. void cast_to_REPL( cp )
  337.   register CELL *cp ;
  338. { register STRING *sval ;
  339.  
  340.   if ( cp->type < C_STRING )  cast1_to_s(cp) ;
  341.   sval = (STRING *) cp->ptr ;
  342.  
  343.   (void) cellcpy(cp, repl_compile(sval)) ;
  344.   free_STRING(sval) ;
  345. }
  346.  
  347.  
  348. /* convert a double to long (this is not as simple as a
  349.    cast because the results are undefined if it won't fit).
  350.    Truncate large values to +MAX__LONG or -MAX__LONG
  351.    Send nans to -MAX__LONG
  352. */
  353.  
  354. long
  355. d_to_l(d)
  356.   double d ;
  357. {
  358.   if ( d >= MAX__LONG )  return MAX__LONG ;
  359.   if ( d >  -MAX__LONG ) return (int) d ;
  360.   return -MAX__LONG ;
  361. }
  362.  
  363. #if   HAVE_STRTOD==0
  364.  
  365. /* don't use this unless you really don't have strtod() because
  366.    (1) its probably slower than your real strtod()
  367.    (2) atof() may call the real strtod() 
  368. */
  369.  
  370. #if __STDC__ == 0
  371. #define const
  372. #endif
  373.  
  374. double strtod(s, endptr)
  375.   const char *s ;
  376.   char  **endptr ;
  377. {
  378.   register unsigned char *p ; 
  379.   int flag ;
  380.   double atof() ;
  381.  
  382.   if ( endptr )
  383.   {
  384.     p = (unsigned char*) s ;
  385.  
  386.     flag = 0 ;
  387.     while ( *p == ' ' || *p == '\t' ) p++ ;
  388.     if ( *p == '-' || *p == '+' ) p++ ;
  389.     while ( scan_code[*p] == SC_DIGIT ) { flag++ ; p++ ; }
  390.     if ( *p == '.' )
  391.     {
  392.       p++ ;
  393.       while ( scan_code[*p] == SC_DIGIT ) { flag++ ; p++ ; }
  394.     }
  395.     /* done with number part */
  396.     if ( flag == 0 )
  397.     { /* no number part */
  398.       *endptr = s ; return 0.0 ; 
  399.     }
  400.     else *endptr = (char *) p ;
  401.  
  402.     /* now look for exponent */
  403.     if ( *p == 'e' || *p == 'E' )
  404.     {
  405.       flag = 0 ;
  406.       p++ ;
  407.       if ( *p == '-' || *p == '+' ) p++ ;
  408.       while ( scan_code[*p] == SC_DIGIT ) { flag++ ; p++ ; }
  409.       if ( flag ) *endptr = (char *) p ;
  410.     }
  411.   }
  412.   return atof(s) ;
  413. }
  414. #endif  /* HAVE_STRTOD==0 */
  415.  
  416. #if   HAVE_FMOD==0
  417.  
  418. #if SW_FP_CHECK   /* this is V7 and XNX23A specific */
  419.  
  420. double  fmod(x, y)
  421.   double x, y ;
  422. { double modf() ;
  423.   double dtmp, ipart ;
  424.  
  425.   clrerr();
  426.   dtmp = x / y;
  427.   fpcheck();
  428.   (void) modf(dtmp, &ipart) ;
  429.   return x - ipart*y ;
  430. }
  431.  
  432. #else
  433.  
  434. double  fmod(x, y)
  435.   double x, y ;
  436. { double modf() ;
  437.   double ipart ;
  438.  
  439.   (void) modf(x/y, &ipart) ;
  440.   return x - ipart*y ;
  441. }
  442.  
  443. #endif
  444. #endif  
  445.  
  446.  
  447.  
  448.