Diff for /gforth/string.fs between versions 1.2 and 1.14

version 1.2, 2000/04/12 20:53:46 version 1.14, 2011/01/09 20:04:15
Line 1 Line 1
 \ dynamic string handling                              10aug99py  \ dynamic string handling                              10aug99py
   
 : delete   ( buffer size count -- )  \ Copyright (C) 2000,2005,2007,2010 Free Software Foundation, Inc.
   over min >r  r@ - ( left over )  dup 0>  
   IF  2dup swap dup  r@ +  -rot swap move  THEN  + r> bl fill ;  \ This file is part of Gforth.
   
 : insert   ( string length buffer size -- )  \ Gforth is free software; you can redistribute it and/or
   rot over min >r  r@ - ( left over )  \ modify it under the terms of the GNU General Public License
   over dup r@ +  rot move   r> move  ;  \ as published by the Free Software Foundation, either version 3
   \ of the License, or (at your option) any later version.
 : $padding ( n -- n' )  
   [ 6 cells ] Literal + [ -4 cells ] Literal and ;  \ This program is distributed in the hope that it will be useful,
 : $! ( addr1 u addr2 -- )  \ but WITHOUT ANY WARRANTY; without even the implied warranty of
   dup @ IF  dup @ free throw  THEN  \ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   over $padding allocate throw over ! @  \ GNU General Public License for more details.
   over >r  rot over cell+  r> move 2dup ! + cell+ bl swap c! ;  
 : $@len ( addr -- u )  @ @ ;  \ You should have received a copy of the GNU General Public License
 : $@ ( addr1 -- addr2 u )  @ dup cell+ swap @ ;  \ along with this program. If not, see http://www.gnu.org/licenses/.
 : $!len ( u addr -- )  
   over $padding over @ swap resize throw over ! @ ! ;  [IFUNDEF] $!
 : $del ( addr off u -- )   >r >r dup $@ r> /string r@ delete  : delete   ( buffer size n -- ) \ gforth-string
   dup $@len r> - swap $!len ;      \G deletes the first @var{n} bytes from a buffer and fills the
 : $ins ( addr1 u addr2 off -- ) >r      \G rest at the end with blanks.
   2dup dup $@len rot + swap $!len  $@ 1+ r> /string insert ;      over min >r  r@ - ( left over )  dup 0>
 : $+! ( addr1 u addr2 -- ) dup $@len $ins ;      IF  2dup swap dup  r@ +  -rot swap move  THEN  + r> bl fill ;
 : $off ( addr -- )  dup @ free throw off ;  
   : insert   ( string length buffer size -- ) \ gforth-string
       \G inserts a string at the front of a buffer. The remaining
       \G bytes are moved on.
       rot over min >r  r@ - ( left over )
       over dup r@ +  rot move   r> move  ;
   
   : $padding ( n -- n' ) \ gforth-string
       [ 6 cells ] Literal + [ -4 cells ] Literal and ;
   : $! ( addr1 u addr2 -- ) \ gforth-string string-store
       \G stores a string at an address, If there was a string there
       \G already, that string will be lost.
       dup @ IF  dup @ free throw  THEN
       over $padding allocate throw over ! @
       over >r  rot over cell+  r> move 2dup ! + cell+ bl swap c! ;
   : $@len ( addr -- u ) \ gforth-string string-fetch-len
       \G returns the length of the stored string.
       @ @ ;
   : $@ ( addr1 -- addr2 u ) \ gforth-string string-fetch
       \G returns the stored string.
       @ dup cell+ swap @ ;
   : $!len ( u addr -- ) \ gforth-string string-store-len
       \G changes the length of the stored string.  Therefore we must
       \G change the memory area and adjust address and count cell as
       \G well.
       over $padding over @ swap resize throw over ! @ ! ;
   : $del ( addr off u -- ) \ gforth-string string-del
       \G deletes @var{u} bytes from a string with offset @var{off}.
       >r >r dup $@ r> /string r@ delete
       dup $@len r> - swap $!len ;
   : $ins ( addr1 u addr2 off -- ) \ gforth-string string-ins
       \G inserts a string at offset @var{off}.
       >r 2dup dup $@len rot + swap $!len  $@ 1+ r> /string insert ;
   : $+! ( addr1 u addr2 -- ) \ gforth-string string-plus-store
       \G appends a string to another.
       dup $@len $ins ;
   : $off ( addr -- ) \ gforth-string string-off
       \G releases a string.
       dup @ dup IF  free throw off  ELSE  2drop  THEN ;
   : $init ( addr -- ) \ gforth-string string-init
       \G initializes a string to empty (doesn't look at what was there before).
       >r r@ off s" " r> $! ;
   
 \ dynamic string handling                              12dec99py  \ dynamic string handling                              12dec99py
   
 : $split ( addr u char -- addr1 u1 addr2 u2 )  : $split ( addr u char -- addr1 u1 addr2 u2 ) \ gforth-string string-split
   >r 2dup r> scan dup >r dup IF  1 /string  THEN      \G divides a string into two, with one char as separator (e.g. '?'
   2swap r> - 2swap ;      \G for arguments in an HTML query)
       >r 2dup r> scan dup >r dup IF  1 /string  THEN
 : $iter ( .. $addr char xt -- .. ) { char xt }      2swap r> - 2swap ;
   $@ BEGIN  dup  WHILE  char $split >r >r xt execute r> r>  
      REPEAT  2drop ;  : $iter ( .. $addr char xt -- .. ) \ gforth-string string-iter
       \G takes a string apart piece for piece, also with a character as
       \G separator. For each part a passed token will be called. With
       \G this you can take apart arguments -- separated with '&' -- at
       \G ease.
       >r >r
       $@ BEGIN  dup  WHILE  r@ $split i' -rot >r >r execute r> r>
       REPEAT  2drop rdrop rdrop ;
   [THEN]
   

Removed from v.1.2  
changed lines
  Added in v.1.14


FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>