home *** CD-ROM | disk | FTP | other *** search
/ BURKS 2 / BURKS_AUG97.ISO / BURKS / SOFTWARE / SOURCES / MAWK11AS.ZIP / FIELD.C (.txt) < prev    next >
C/C++ Source or Header  |  1991-12-18  |  14KB  |  608 lines
  1.  
  2. /********************************************
  3. field.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:    field.c,v $
  14.  * Revision 5.1  91/12/05  07:55:57  brennan
  15.  * 1.1 pre-release
  16.  * 
  17. */
  18.  
  19.  
  20. /* field.c */
  21.  
  22. #include "mawk.h"
  23. #include "field.h"
  24. #include "init.h"
  25. #include "memory.h"
  26. #include "scan.h"
  27. #include "bi_vars.h"
  28. #include "repl.h"
  29. #include "regexp.h"
  30.  
  31. CELL  field[FBANK_SZ+NUM_PFIELDS] ;
  32.  
  33. CELL  *fbank[NUM_FBANK] = {field} ;
  34.  
  35. static int max_field = MAX_SPLIT ; /* maximum field actually created*/
  36.  
  37. static void PROTO( build_field0, (void) ) ;
  38. static void PROTO( set_rs_shadow, (void) ) ;
  39. static void PROTO( load_pfield, (char*, CELL*)) ;
  40. static void PROTO( load_field_ov, (void)) ;
  41.  
  42.  
  43.  
  44. /* a description of how to split based on RS.
  45.    If RS is changed, so is rs_shadow */
  46. SEPARATOR rs_shadow = {SEP_CHAR, '\n'} ;
  47. /* a splitting CELL version of FS */
  48. CELL fs_shadow = {C_SPACE} ;
  49. int   nf ;  
  50.   /* nf holds the true value of NF.  If nf < 0 , then
  51.      NF has not been computed, i.e., $0 has not been split
  52.   */
  53.  
  54. static void set_rs_shadow()
  55. { CELL c ;
  56.   STRING  *sval ;
  57.   char *s ;
  58.   unsigned len ;
  59.  
  60.   if ( posix_space_flag && mawk_state == EXECUTION ) 
  61.           scan_code['\n'] = SC_UNEXPECTED ;
  62.  
  63.   if ( rs_shadow.type == SEP_STR )  free_STRING((STRING*) rs_shadow.ptr) ;
  64.  
  65.   cast_for_split( cellcpy(&c, RS) ) ;
  66.   switch( c.type )
  67.   {
  68.     case C_RE :
  69.         if ( s = is_string_split(c.ptr, &len) )
  70.             if ( len == 1 )
  71.             { rs_shadow.type = SEP_CHAR ;
  72.               rs_shadow.c = s[0] ;
  73.             }
  74.             else
  75.             { rs_shadow.type = SEP_STR ;
  76.               rs_shadow.ptr = (PTR) new_STRING(s) ;
  77.             }
  78.         else
  79.         { rs_shadow.type = SEP_RE ;
  80.           rs_shadow.ptr = c.ptr ;
  81.         }
  82.         break ;
  83.  
  84.     case C_SPACE :
  85.         rs_shadow.type = SEP_CHAR ;
  86.         rs_shadow.c = ' ' ;
  87.         break ;
  88.  
  89.     case C_SNULL : /* RS becomes one or more blank lines */
  90.     if ( mawk_state == EXECUTION ) scan_code['\n'] = SC_SPACE ;
  91.         rs_shadow.type = SEP_MLR ;
  92.         sval = new_STRING( "\n\n+" ) ;
  93.         rs_shadow.ptr = re_compile(sval) ;
  94.         free_STRING(sval) ;
  95.         break ;
  96.  
  97.     default : bozo("bad cell in set_rs_shadow") ;
  98.   }
  99. }
  100.  
  101. static  void load_pfield(name, cp)
  102.   char *name ;
  103.   CELL *cp ;
  104. { SYMTAB *stp ;
  105.  
  106.   stp = insert(name) ; stp->type = ST_FIELD ;
  107.   stp->stval.cp = cp ;
  108. }
  109.  
  110. /* initialize $0 and the pseudo fields */
  111. void  field_init()
  112. { 
  113.   field[0].type = C_STRING ;
  114.   field[0].ptr = (PTR) & null_str ;
  115.   null_str.ref_cnt++ ;
  116.  
  117.   load_pfield("NF",NF) ;
  118.   NF->type = C_DOUBLE ;
  119.   NF->dval = 0.0 ;
  120.  
  121.   load_pfield("RS", RS) ;
  122.   RS->type = C_STRING ;
  123.   RS->ptr =  (PTR) new_STRING( "\n" ) ;
  124.   /* rs_shadow already set */
  125.  
  126.   load_pfield("FS", FS) ;
  127.   FS->type = C_STRING ;
  128.   FS->ptr = (PTR) new_STRING( " " ) ;
  129.   /* fs_shadow is already set */
  130.  
  131.   load_pfield("OFMT", OFMT) ;
  132.   OFMT->type = C_STRING ;
  133.   OFMT->ptr = (PTR) new_STRING( "%.6g" ) ;
  134.  
  135.   load_pfield("CONVFMT", CONVFMT) ;
  136.   CONVFMT->type = C_STRING ;
  137.   CONVFMT->ptr = OFMT->ptr ;
  138.   string(OFMT)->ref_cnt++ ;
  139. }
  140.  
  141.  
  142.  
  143. void  set_field0( s, len)
  144.   char *s ;
  145.   unsigned len ;
  146. { 
  147.   cell_destroy( & field[0] ) ;
  148.   nf = -1 ;
  149.  
  150.   if ( len )
  151.   {
  152.     field[0].type = C_MBSTRN ;
  153.     field[0].ptr = (PTR) new_STRING( (char *) 0, len) ;
  154.     (void) memcpy( string(&field[0])->str, s, SIZE_T(len) ) ;
  155.   }
  156.   else
  157.   {
  158.     field[0].type = C_STRING ;
  159.     field[0].ptr = (PTR) &null_str ;
  160.     null_str.ref_cnt++ ;
  161.   }
  162. }
  163.  
  164.  
  165.  
  166. /* split field[0] into $1, $2 ... and set NF  */
  167.  
  168. void  split_field0()
  169. { register CELL *cp ;
  170.   register int cnt ;
  171.   CELL  c ;  /* copy field[0] here if not string */
  172.  
  173.  
  174.   if ( field[0].type < C_STRING )
  175.   { cast1_to_s(cellcpy(&c, field+0)) ;
  176.     cp = &c ;
  177.   }
  178.   else   cp = &field[0] ;
  179.  
  180.   if ( string(cp)->len == 0 )  nf = 0 ;
  181.   else
  182.   {
  183.     switch( fs_shadow.type )
  184.     {
  185.       case   C_SNULL :  /* FS == "" */
  186.           nf = 1 ;
  187.           cell_destroy(NF) ;
  188.           NF->type = C_DOUBLE ;
  189.           NF->dval = 1.0 ;
  190.           field[1].type = C_MBSTRN ;
  191.           field[1].ptr = cp->ptr ;
  192.  
  193.           if ( cp == field )  string(cp)->ref_cnt++ ;
  194.           /* else we gain one ref_cnt and lose one for a wash */
  195.  
  196.           return ;
  197.  
  198.       case  C_SPACE :
  199.           nf = space_split(string(cp)->str, string(cp)->len) ;
  200.           break ;
  201.  
  202.       default :
  203.           nf = re_split(string(cp)->str, fs_shadow.ptr) ;
  204.           break ;
  205.     }
  206.         
  207.   }
  208.   
  209.   cell_destroy(NF) ;
  210.   NF->type = C_DOUBLE ;
  211.   NF->dval = (double) nf ;
  212.  
  213.   if ( nf > MAX_SPLIT )  
  214.   {
  215.     cnt = MAX_SPLIT ; load_field_ov() ;
  216.   }
  217.   else cnt = nf ;
  218.  
  219.   while ( cnt > 0 )
  220.   {
  221.     cell_destroy(field+cnt) ;
  222.     field[cnt].ptr = (PTR) split_buff[cnt-1] ;
  223.     field[cnt--].type = C_MBSTRN ;
  224.   }
  225.  
  226.   if ( cp == &c )  free_STRING( string(cp) ) ;
  227. }
  228.  
  229. /*
  230.   assign CELL *cp to field or pseudo field
  231.   and take care of all side effects
  232. */
  233.  
  234. void  field_assign( fp, cp)
  235.   register CELL *fp ;
  236.   CELL *cp ;
  237. { 
  238.   CELL c ;
  239.   int i , j ;
  240.  
  241.   /* the most common case first */
  242.   if ( fp == field )
  243.   { cell_destroy(field) ;
  244.     (void) cellcpy(fp, cp) ;
  245.     nf = -1 ;
  246.     return ;
  247.   }
  248.  
  249.   /* its not important to do any of this fast */
  250.  
  251.   if ( nf < 0 )  split_field0() ;
  252.  
  253. #if  LM_DOS
  254.   if ( !SAMESEG(fp,field) )  goto lm_dos_label ;
  255. #endif
  256.  
  257.   switch( i = (fp - field) )
  258.   {
  259.  
  260.     case  NF_field :
  261.  
  262.         cell_destroy(NF) ;
  263.         (void) cellcpy(NF, cellcpy(&c,cp) ) ;
  264.         if ( c.type != C_DOUBLE )  cast1_to_d(&c) ;
  265.  
  266.         if ( (j = (int) c.dval) < 0 )
  267.             rt_error("negative value assigned to NF") ;
  268.  
  269.         if ( j > nf )
  270.             for ( i = nf+1 ; i <= j ; i++ )
  271.             { 
  272.           cp = field_ptr(i) ;
  273.           cell_destroy(cp) ;
  274.           cp->type = C_STRING ;
  275.               cp->ptr = (PTR) &null_str ;
  276.               null_str.ref_cnt++ ;
  277.             }
  278.  
  279.         nf = j ;
  280.         build_field0() ;
  281.         break ;
  282.  
  283.     case  RS_field :
  284.         cell_destroy(RS) ;
  285.         (void) cellcpy(RS, cp) ;
  286.         set_rs_shadow() ;
  287.         break ;
  288.  
  289.     case  FS_field :
  290.         cell_destroy(FS) ;
  291.         cast_for_split( cellcpy(&fs_shadow, cellcpy(FS, cp)) ) ;
  292.         break ;
  293.  
  294.     case OFMT_field : 
  295.     case CONVFMT_field:
  296.         /* If the user does something stupid with OFMT or CONVFMT,
  297.        we could crash.
  298.            We'll make an attempt to protect ourselves here.  This is
  299.            why OFMT and CONVFMT are pseudo fields.
  300.  
  301.            The ptrs of OFMT and CONVFMT always have a valid STRING,
  302.        even if assigned a DOUBLE or NOINIT
  303.         */
  304.  
  305.         free_STRING( string(fp) ) ;
  306.         (void) cellcpy(fp, cp) ;
  307.         if ( fp->type < C_STRING ) /* !! */
  308.              fp->ptr = (PTR) new_STRING( "%.6g" ) ;
  309.         else
  310.     if ( fp == CONVFMT )
  311.         {
  312.           /* It's a string, but if it's really goofy and CONVFMT,
  313.          it could still damage us. Test it .
  314.       */
  315.           string_buff[256] = 0 ;
  316.           (void) sprintf(string_buff, 
  317.              string(fp)->str, 3.1459) ;
  318.           if ( string_buff[256] )
  319.                 rt_error("CONVFMT assigned unusable value") ;
  320.         }
  321.         break ;
  322.  
  323. #if LM_DOS
  324. lm_dos_label :
  325. #endif
  326.  
  327.     default:  /* $1 or $2 or ... */
  328.  
  329.  
  330.         cell_destroy(fp) ;
  331.         (void) cellcpy(fp, cp) ;
  332.  
  333.     if ( i < 0 || i > MAX_SPLIT ) i = field_addr_to_index(fp) ;    
  334.  
  335.         if ( i > nf )
  336.         { for ( j = nf+1 ; j < i ; j++ )
  337.           { 
  338.         cp = field_ptr(j) ;
  339.         cell_destroy(cp) ;
  340.             cp->type = C_STRING ;
  341.         cp->ptr = (PTR) &null_str ;
  342.             null_str.ref_cnt++ ;
  343.           }
  344.           nf = i ;
  345.           cell_destroy(NF) ;
  346.           NF->type = C_DOUBLE ;
  347.           NF->dval = (double) i ;
  348.         }
  349.  
  350.         build_field0() ;
  351.  
  352.   }
  353. }
  354.  
  355.  
  356. /* construct field[0] from the ot