Hi Forthers,

Having announced an update to Cweed4, I just noticed that the Win32Forth
word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
means that it cannot handle strings longer than 255 bytes.

Does anyone have a (high level?) version of REPLACE that can handle
longer strings?

Thanks in advance,
Howerd

On 11/11/2021 21:07, Howerd Oakford wrote:
> Hi Forthers,
>
> Having announced an update to Cweed4, I just noticed that the Win32Forth
> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> means that it cannot handle strings longer than 255 bytes.
>
> Does anyone have a (high level?) version of REPLACE that can handle
> longer strings?

REPLACE is a search/substitute routine? Perhaps this will do.

: +STRING ( a1 u1 a2 u2 -- a2 u3 )
2swap swap 2over + 2 pick move + ;

: counted DOES> count ;

create "FND counted ( -- a u ) 0 c, 63 allot
create "REP counted ( -- a u ) 0 c, 63 allot

: SUBST ( a u a2 -- a2 u2 )
0 2>r begin 2dup "fnd search while
2swap 2 pick - 2r> +string
"rep 2swap +string 2>r "fnd nip /string
repeat 2r> +string 2nip ;

\ for Cweed (untested)

create "OUT 1024 allot \ or existing buffer of your choice

: ADDR ( "name" -- addr )
' >body state @ if postpone literal then ; immediate

: replaceBuf ( $old $new -- )
addr "rep place addr "fnd place
get_TempBuffer0 "out subst copy_toTempBuffer0 ;

On 11/11/2021 23:34, dxforth wrote:
> On 11/11/2021 21:07, Howerd Oakford wrote:
>> Hi Forthers,
>>
>> Having announced an update to Cweed4, I just noticed that the Win32Forth
>> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
>> means that it cannot handle strings longer than 255 bytes.
>>
>> Does anyone have a (high level?) version of REPLACE that can handle
>> longer strings?
>
> REPLACE is a search/substitute routine?

It appears your REPLACE stops after the first match. In that case
use SUBST-FIRST instead of SUBST .

: SUBST-FIRST ( a u a2 -- a2 u2 )
0 2>r 2dup "fnd search if
2swap 2 pick - 2r> +string
"rep 2swap +string 2>r "fnd nip /string
else 2drop then 2r> +string ;

On 11/11/2021 13:34, dxforth wrote:
> On 11/11/2021 21:07, Howerd Oakford wrote:
>> Hi Forthers,
>>
>> Having announced an update to Cweed4, I just noticed that the Win32Forth
>> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
>> means that it cannot handle strings longer than 255 bytes.
>>
>> Does anyone have a (high level?) version of REPLACE that can handle
>> longer strings?
>
> REPLACE is a search/substitute routine?  Perhaps this will do.
>
> : +STRING ( a1 u1 a2 u2 -- a2 u3 )
>   2swap swap 2over + 2 pick move + ;
>
> : counted DOES> count ;
>
> create "FND counted ( -- a u )  0 c, 63 allot
> create "REP counted ( -- a u )  0 c, 63 allot
>
> : SUBST ( a u a2 -- a2 u2 )
>   0  2>r  begin  2dup "fnd search  while
>     2swap  2 pick -  2r> +string
>     "rep 2swap +string  2>r  "fnd nip /string
>   repeat  2r> +string  2nip ;
>
>
> \ for Cweed (untested)
>
> create "OUT  1024 allot  \ or existing buffer of your choice
>
> : ADDR ( "name" -- addr )
>   ' >body state @ if postpone literal then ; immediate
>
> : replaceBuf ( $old $new -- )
>   addr "rep place  addr "fnd place
>   get_TempBuffer0 "out subst  copy_toTempBuffer0 ;
>

Hi dxforth,

Thanks for the code. I fixed this later in the day, and the new version
is online. I didn't change the version number because I thought nobody
would have downloaded it yet, but you beat me to it ;-)

It turns out that I had already done 32 bit versions of COUNT , PLACE
and APPEND / +PLACE , shown below.

So now Cweed works with long lines when checking the Barr coding rules :-)

All we need to do now is to decide on the right names for these new
creations ;-)

Cheers,
Howerd

*****************************************************************************
\ Big 32 bit count versions of Place , Append and Count
\ The first 32 bit cell contains a 32 bit byte count
\
*****************************************************************************
$800 Buffer: BIG_STRBUF

: BigPlace ( a n a -- )
2dup ! cell+ swap cells move
;

: BigCount ( a -- a n )
dup @ swap cell+ swap
;

: BigAppend ( a n a -- )
2dup 2>r BigCount + swap move 2r> +!
;

: BigSUBST ( source len old len new len -- result len )
LOCALS| nl n pl p | 0 BIG_STRBUF !
BEGIN DUP 0> WHILE
2DUP p pl SEARCH WHILE ( s l m l)
ROT OVER - >R ROT R> BIG_STRBUF BigAppend
n nl BIG_STRBUF BigAppend
pl /STRING
REPEAT 2SWAP BIG_STRBUF BigAppend THEN
2DROP BIG_STRBUF BigCount ;

: BigREPLACE ( new l source l old l -- result l )
DUP>R 2OVER 2>R
SEARCH IF ( new l a n)
DUP 2R> ROT - BIG_STRBUF BigPlace
R> /STRING 2SWAP BIG_STRBUF BigAppend BIG_STRBUF BigAppend
ELSE ( new l a n)
2R> BIG_STRBUF BigPlace R>DROP 2DROP 2DROP
THEN BIG_STRBUF BigCount ;

: ttBR ( -- )
s" totally wonderful" s" hello replaceme world!!!" cr 2dup type
s" replaceme" BigREPLACE cr type
;

On 12/11/2021 08:54, Howerd Oakford wrote:
>
> : BigPlace ( a n a -- )
> 2dup ! cell+ swap cells move
> ;

Following Wil Baden's PLACE:

: BigPlace ( a n a -- )
2dup 2>r cell+ swap cells move 2r> ! ;
;

source and destination are permitted to overlap.

On Thursday, November 11, 2021 at 11:07:58 AM UTC+1, Howerd wrote:
> Hi Forthers,
>
> Having announced an update to Cweed4, I just noticed that the Win32Forth
> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> means that it cannot handle strings longer than 255 bytes.
>
> Does anyone have a (high level?) version of REPLACE that can handle
> longer strings?

An old library, haven't used it in ages. Your mileage may vary.

---8<--
\ Delete string a2/n2 from string a1/n1
\ Return the resulting string in a1/n3 and the remainder of the
\ line after the delete in string a2/n4
\ If the deletion was made, f is 1 otherwise 0

: delete ( a1 n1 a2 n2 -- a1 n3 a2 n4 f)
2>r 2dup 2r> dup >r search
dup r> swap >r >r ( a1 n1 a2 n2 f)
if ( a1 n1 a2 n2)
2swap r@ - 2swap r@ - ( a1 n3 a2 n4)
2dup over r@ chars + ( a1 n3 a2 n4 a3)
-rot cmove ( a1 n3 a2 n4)
then
r> drop r>
;

\ Delete all occurences of string a2/n2 in string a1/n1
\ Return the resulting string in a1/n3

: deleteall ( a1 n1 a2 n2 -- a1 n3)
2>r swap dup rot ( a1 a1 n1)
begin ( a1 a1 n1)
2r> 2dup 2>r delete ( a1 a1 n3 a2 n4 f)
while ( a1 a1 n3 a2 n4)
2swap 2drop ( a1 a2 n4)
repeat ( a1 a2 n4)
2drop chars + over - ( a1 n5)
2r> 2drop ( a1 n5)
;

\ Spread string a1/n1 at position n2 by n3 characters
\ Return the resulting string in a1/n4 and the opened up
\ space in string a2 n3

: spread ( a1 n1 n2 n3 -- a1 n4 a2 n3)
rot >r >r ( a1 n2)
over over chars + swap ( a1 a2 n2)
over dup r@ + rot ( a1 a2 a2 a3 n2)
r> swap r@ swap - swap >r ( a1 a2 a2 a3 n1-n2)
cmove r@ rot r> r> + ( a2 n3 a1 n4)
2swap ( a1 n4 a2 n3)
;

\ Insert string a2/n2 into string a1/n1 at position n3
\ Return the resulting string in a1/n3 and the remainder of
\ the line after the insertion in a3/n4

: insert ( a1 n1 a2 n2 n3 -- a1 n3 a3 n4)
-rot 2dup 2>r ( a1 n1 n3 a2 n2)
nip spread ( a1 n3 a3 n2)
over 2r> ( a1 n3 a3 n2 a3 a2 n2)
rot swap cmove chars + ( a1 n3 a4)
>r 2dup chars + r@ - ( a1 n3 n4)
r> swap
;

\ Replace string a2/n2 in string a1/n1 by string a3/n3
\ Return the resulting string in a1/n4 and the remainder of the
\ line after the delete in string a4/n5
\ If the replacement was made, f is 1 otherwise 0

: replace ( a1 n1 a2 n2 a3 n3 -- a1 n4 a4 n5 f)
2>r delete dup 2r> rot >r 2>r
if
nip over swap - 2r> rot insert
else
2r> 2drop
then
r>
;

\ Replace all occurences of string a2/n2 in string a1/n1 by string a3/n3
\ Return the resulting string in a1/n4

: replaceall ( a1 n1 a2 n2 a3 n3 -- a1 n4)
2>r 2>r swap dup rot
begin
2r> 2dup 2r> 2dup 2>r 2swap 2>r replace
while
2swap 2drop
repeat
2drop chars + over -
2r> 2r> 2drop 2drop
;
---8<---

Hans Bezemer

On Thursday, 11 November 2021 at 21:54:06 UTC, Howerd wrote:
> On 11/11/2021 13:34, dxforth wrote:
> > On 11/11/2021 21:07, Howerd Oakford wrote:
> >> Hi Forthers,
> >>
> >> Having announced an update to Cweed4, I just noticed that the Win32Forth
> >> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> >> means that it cannot handle strings longer than 255 bytes.
> >>
> >> Does anyone have a (high level?) version of REPLACE that can handle
> >> longer strings?
> >
> > REPLACE is a search/substitute routine? Perhaps this will do.
> >
> > : +STRING ( a1 u1 a2 u2 -- a2 u3 )
> > 2swap swap 2over + 2 pick move + ;
> >
> > : counted DOES> count ;
> >
> > create "FND counted ( -- a u ) 0 c, 63 allot
> > create "REP counted ( -- a u ) 0 c, 63 allot
> >
> > : SUBST ( a u a2 -- a2 u2 )
> > 0 2>r begin 2dup "fnd search while
> > 2swap 2 pick - 2r> +string
> > "rep 2swap +string 2>r "fnd nip /string
> > repeat 2r> +string 2nip ;
> >
> >
> > \ for Cweed (untested)
> >
> > create "OUT 1024 allot \ or existing buffer of your choice
> >
> > : ADDR ( "name" -- addr )
> > ' >body state @ if postpone literal then ; immediate
> >
> > : replaceBuf ( $old $new -- )
> > addr "rep place addr "fnd place
> > get_TempBuffer0 "out subst copy_toTempBuffer0 ;
> >
> Hi dxforth,
>
> Thanks for the code. I fixed this later in the day, and the new version
> is online. I didn't change the version number because I thought nobody
> would have downloaded it yet, but you beat me to it ;-)
>
>
> It turns out that I had already done 32 bit versions of COUNT , PLACE
> and APPEND / +PLACE , shown below.
>
> So now Cweed works with long lines when checking the Barr coding rules :-)
>
> All we need to do now is to decide on the right names for these new
> creations ;-)
>
> Cheers,
> Howerd
>
>
> *****************************************************************************
> \ Big 32 bit count versions of Place , Append and Count
> \ The first 32 bit cell contains a 32 bit byte count
> \
> *****************************************************************************
> $800 Buffer: BIG_STRBUF
>
> : BigPlace ( a n a -- )
> 2dup ! cell+ swap cells move
> ;
>
> : BigCount ( a -- a n )
> dup @ swap cell+ swap
> ;
>
> : BigAppend ( a n a -- )
> 2dup 2>r BigCount + swap move 2r> +!
> ;
>
> : BigSUBST ( source len old len new len -- result len )
> LOCALS| nl n pl p | 0 BIG_STRBUF !
> BEGIN DUP 0> WHILE
> 2DUP p pl SEARCH WHILE ( s l m l)
> ROT OVER - >R ROT R> BIG_STRBUF BigAppend
> n nl BIG_STRBUF BigAppend
> pl /STRING
> REPEAT 2SWAP BIG_STRBUF BigAppend THEN
> 2DROP BIG_STRBUF BigCount ;
>
>
> : BigREPLACE ( new l source l old l -- result l )
> DUP>R 2OVER 2>R
> SEARCH IF ( new l a n)
> DUP 2R> ROT - BIG_STRBUF BigPlace
> R> /STRING 2SWAP BIG_STRBUF BigAppend BIG_STRBUF BigAppend
> ELSE ( new l a n)
> 2R> BIG_STRBUF BigPlace R>DROP 2DROP 2DROP
> THEN BIG_STRBUF BigCount ;
>
> : ttBR ( -- )
> s" totally wonderful" s" hello replaceme world!!!" cr 2dup type
> s" replaceme" BigREPLACE cr type
> ;

I havent used win32forth in a while , but place, count and append appear very similar to lcount, lplace and l+place.

On 13/11/2021 04:21, Hans Bezemer wrote:
> On Thursday, November 11, 2021 at 11:07:58 AM UTC+1, Howerd wrote:
>> Hi Forthers,
>>
>> Having announced an update to Cweed4, I just noticed that the Win32Forth
>> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
>> means that it cannot handle strings longer than 255 bytes.
>>
>> Does anyone have a (high level?) version of REPLACE that can handle
>> longer strings?
>
> An old library, haven't used it in ages. Your mileage may vary.
>

Some nice ideas in there I hadn't considered.

Only had use for such a thing recently (replacing .html with .htm
in some 800 files - not something I wanted to do manually :)

On 13/11/2021 06:49, NN wrote:
>
> I havent used win32forth in a while , but place, count and append appear very similar to lcount, lplace and l+place.
>

Indeed it does. OTOH they're limited to 1024 chars for Windows-related reasons.
But hey, 1024 should be enough for anyone :)

On 12/11/2021 17:21, Hans Bezemer wrote:
> On Thursday, November 11, 2021 at 11:07:58 AM UTC+1, Howerd wrote:
>> Hi Forthers,
>>
>> Having announced an update to Cweed4, I just noticed that the Win32Forth
>> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
>> means that it cannot handle strings longer than 255 bytes.
>>
>> Does anyone have a (high level?) version of REPLACE that can handle
>> longer strings?
>
> An old library, haven't used it in ages. Your mileage may vary.

It certainly does

>
> ---8<--
> \ Delete string a2/n2 from string a1/n1
> \ Return the resulting string in a1/n3 and the remainder of the
> \ line after the delete in string a2/n4
> \ If the deletion was made, f is 1 otherwise 0
>
> : delete ( a1 n1 a2 n2 -- a1 n3 a2 n4 f)
> 2>r 2dup 2r> dup >r search
> dup r> swap >r >r ( a1 n1 a2 n2 f)
> if ( a1 n1 a2 n2)
> 2swap r@ - 2swap r@ - ( a1 n3 a2 n4)
> 2dup over r@ chars + ( a1 n3 a2 n4 a3)
> -rot cmove ( a1 n3 a2 n4)
> then
> r> drop r>
> ;
>
> \ Delete all occurences of string a2/n2 in string a1/n1
> \ Return the resulting string in a1/n3
>
> : deleteall ( a1 n1 a2 n2 -- a1 n3)
> 2>r swap dup rot ( a1 a1 n1)
> begin ( a1 a1 n1)
> 2r> 2dup 2>r delete ( a1 a1 n3 a2 n4 f)
> while ( a1 a1 n3 a2 n4)
> 2swap 2drop ( a1 a2 n4)
> repeat ( a1 a2 n4)
> 2drop chars + over - ( a1 n5)
> 2r> 2drop ( a1 n5)
> ;
>
> \ Spread string a1/n1 at position n2 by n3 characters
> \ Return the resulting string in a1/n4 and the opened up
> \ space in string a2 n3
>
> : spread ( a1 n1 n2 n3 -- a1 n4 a2 n3)
> rot >r >r ( a1 n2)
> over over chars + swap ( a1 a2 n2)
> over dup r@ + rot ( a1 a2 a2 a3 n2)
> r> swap r@ swap - swap >r ( a1 a2 a2 a3 n1-n2)
> cmove r@ rot r> r> + ( a2 n3 a1 n4)
> 2swap ( a1 n4 a2 n3)
> ;
>
> \ Insert string a2/n2 into string a1/n1 at position n3
> \ Return the resulting string in a1/n3 and the remainder of
> \ the line after the insertion in a3/n4
>
> : insert ( a1 n1 a2 n2 n3 -- a1 n3 a3 n4)
> -rot 2dup 2>r ( a1 n1 n3 a2 n2)
> nip spread ( a1 n3 a3 n2)
> over 2r> ( a1 n3 a3 n2 a3 a2 n2)
> rot swap cmove chars + ( a1 n3 a4)
> >r 2dup chars + r@ - ( a1 n3 n4)
> r> swap
> ;
>
> \ Replace string a2/n2 in string a1/n1 by string a3/n3
> \ Return the resulting string in a1/n4 and the remainder of the
> \ line after the delete in string a4/n5
> \ If the replacement was made, f is 1 otherwise 0
>
> : replace ( a1 n1 a2 n2 a3 n3 -- a1 n4 a4 n5 f)
> 2>r delete dup 2r> rot >r 2>r
> if
> nip over swap - 2r> rot insert
> else
> 2r> 2drop
> then
> r>
> ;
>
> \ Replace all occurences of string a2/n2 in string a1/n1 by string a3/n3
> \ Return the resulting string in a1/n4
>
> : replaceall ( a1 n1 a2 n2 a3 n3 -- a1 n4)
> 2>r 2>r swap dup rot
> begin
> 2r> 2dup 2r> 2dup 2>r 2swap 2>r replace
> while
> 2swap 2drop
> repeat
> 2drop chars + over -
> 2r> 2r> 2drop 2drop
> ;
> ---8<---

Perhaps this works in 4th but, unless I'm misunderstanding something, it
doesn't work in standard Forth despite using standard words, for example
a crude test using GForth:

\ Test ok
ok
create buf 1000 allot ok
0 value len ok
: src s" aaa*****bbbb*****ccccc*****dd" ; ok
: targ s" *****" ; ok
: >buf ( ca u -- ) dup to len buf swap cmove ; ok
: buf@ buf len ; ok
: .buf ( -- ) buf@ cr type ; ok
ok
src >buf ok
buf@ 2dup cr type targ s" ------" replace cr . cr type cr type cr .s
aaa*****bbbb*****ccccc*****dd
-1
bbbb**bbbb**bbbb**bbb
aaa------bbbb**bbbb**bbbb**bbb
<0> ok
ok
src >buf ok
buf@ 2dup cr type targ s" ------" replaceall cr type cr .s
aaa*****bbbb*****ccccc*****dd
aaa------bbbb**bbbb**bbbb**bbb
<0> ok
ok
src >buf ok
buf@ 2dup cr type targ s" --" replace cr . cr type cr type cr .s
aaa*****bbbb*****ccccc*****dd
-1
bbbbbbbbbbbbbbbbbbbbb
aaa--bbbbbbbbbbbbbbbbbbbbb
<0> ok
ok
ok
src >buf ok
buf@ 2dup cr type targ s" --" replaceall cr type cr .s
aaa*****bbbb*****ccccc*****dd
aaa--bbbbbbbbbbbbbbbbbbbbb
<0> ok

Other Forth systems give the same result.

--
Gerry

On Thursday, November 11, 2021 at 6:07:58 AM UTC-4, Howerd wrote:
> Hi Forthers,
>
> Having announced an update to Cweed4, I just noticed that the Win32Forth
> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> means that it cannot handle strings longer than 255 bytes.
>
> Does anyone have a (high level?) version of REPLACE that can handle
> longer strings?

Just curious, which version of Win32Forth are you using?

--

Rick C.

- Get 1,000 miles of free Supercharging
- Tesla referral code - https://ts.la/richard11209

On 30/11/2021 03:44, Rick C wrote:
> On Thursday, November 11, 2021 at 6:07:58 AM UTC-4, Howerd wrote:
>> Hi Forthers,
>>
>> Having announced an update to Cweed4, I just noticed that the Win32Forth
>> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
>> means that it cannot handle strings longer than 255 bytes.
>>
>> Does anyone have a (high level?) version of REPLACE that can handle
>> longer strings?
>
> Just curious, which version of Win32Forth are you using?

http://www.inventio.co.uk/LegacyIndex.htm

On 11/29/21 7:06 AM, Gerry Jackson wrote:

> Perhaps this works in 4th but, unless I'm misunderstanding something, it
> doesn't work in standard Forth despite using standard words, for example
> ...

Yeah. I got similar errors on the tests I tried. Maybe I'm using the
words incorrectly. Not sure.

The same tests work fine with my object-based library replace routines.
Downside is having to load my library with its oo support code. Not an
issue for me because I always have it loaded.

-Doug

On Monday, November 29, 2021 at 9:20:26 PM UTC-4, dxforth wrote:
> On 30/11/2021 03:44, Rick C wrote:
> > On Thursday, November 11, 2021 at 6:07:58 AM UTC-4, Howerd wrote:
> >> Hi Forthers,
> >>
> >> Having announced an update to Cweed4, I just noticed that the Win32Forth
> >> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> >> means that it cannot handle strings longer than 255 bytes.
> >>
> >> Does anyone have a (high level?) version of REPLACE that can handle
> >> longer strings?
> >
> > Just curious, which version of Win32Forth are you using?
> http://www.inventio.co.uk/LegacyIndex.htm

So that would be Win32Forth V6.05H?

Is that because of issues with AVS from later editions or just because it works and no reason to change?

--

Rick C.

+ Get 1,000 miles of free Supercharging
+ Tesla referral code - https://ts.la/richard11209

On Monday, November 29, 2021 at 10:58:05 PM UTC-4, Rick C wrote:
> On Monday, November 29, 2021 at 9:20:26 PM UTC-4, dxforth wrote:
> > On 30/11/2021 03:44, Rick C wrote:
> > > On Thursday, November 11, 2021 at 6:07:58 AM UTC-4, Howerd wrote:
> > >> Hi Forthers,
> > >>
> > >> Having announced an update to Cweed4, I just noticed that the Win32Forth
> > >> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> > >> means that it cannot handle strings longer than 255 bytes.
> > >>
> > >> Does anyone have a (high level?) version of REPLACE that can handle
> > >> longer strings?
> > >
> > > Just curious, which version of Win32Forth are you using?
> > http://www.inventio.co.uk/LegacyIndex.htm
> So that would be Win32Forth V6.05H?
>
> Is that because of issues with AVS from later editions or just because it works and no reason to change?

BTW, the green font on that page is completely illegible to me. It vibrates into the background making the font illegible. The cyan font is not very clear either. Why use such difficult to see colors? I thought the dark gray on light gray fad was a PITA, but this is even worse. At least I can use Reader view in Firefox to read it losing all formatting.

--

Rick C.

-- Get 1,000 miles of free Supercharging
-- Tesla referral code - https://ts.la/richard11209

On 30/11/2021 14:02, Rick C wrote:
> ...
> BTW, the green font on that page is completely illegible to me. It vibrates into the
> background making the font illegible. The cyan font is not very clear either. Why use such
> difficult to see colors? I thought the dark gray on light gray fad was a PITA, but this is
> even worse. At least I can use Reader view in Firefox to read it losing all formatting.

Perhaps colorForth wasn't such a good idea after all :)

On 30/11/2021 13:25, Doug Hoffman wrote:
> On 11/29/21 7:06 AM, Gerry Jackson wrote:
>
>> Perhaps this works in 4th but, unless I'm misunderstanding something, it
>> doesn't work in standard Forth despite using standard words, for example
>> ...
>
> Yeah. I got similar errors on the tests I tried. Maybe I'm using the
> words incorrectly. Not sure.
>
> The same tests work fine with my object-based library replace routines.
> Downside is having to load my library with its oo support code. Not an
> issue for me because I always have it loaded.

Got it going by replacing CMOVE with CMOVE> in SPREAD. Whether it's a
complete fix I don't know.

On 11/30/21 6:39 AM, dxforth wrote:
> Got it going by replacing CMOVE with CMOVE> in SPREAD.  Whether it's a
> complete fix I don't know.

It works fine with your fix on my large torture test ( 10 times the
size of the KJB from the Hoyt test). Nice catch!

-Doug

On Tuesday, November 30, 2021 at 12:39:29 PM UTC+1, dxforth wrote:
> Got it going by replacing CMOVE with CMOVE> in SPREAD. Whether it's a
> complete fix I don't know.

In 4tH there is no bug, because ALL "MOVE" variations (CMOVE, CMOVE>, MOVE - and their cell equivalent SMOVE) are INTELLIGENT. They do not only check whether a "move" goes outside the sandbox, they also evaluate the direction and adjust accordingly. So, yes - a fix at "SPREAD" makes sense - and given it's the only word that moves in that direction, it might be the fix one needed.

I've applied it in my source as well, so others won't fall in the same trap when they rip one of my libs ;-)
BTW, it's a smart move to PLACE the source string in an appropriately sized buffer. There is a lot of movement going on - especially when expanding by sizeof("replacement") > sizeof("original") of course.

I'm sorry for any inconvenience caused, but I warned you this was an old vanilla lib from 4tH. Thanks for figuring this out!

Hans Bezemer

On Wednesday, December 1, 2021 at 12:17:35 PM UTC+1, Hans Bezemer wrote:

> I've applied it in my source as well, so others won't fall in the same trap when they rip one of my libs ;-)
https://sourceforge.net/p/forth-4th/code/1370/

On 11/11/2021 10:07, Howerd Oakford wrote:
> Hi Forthers,
>
> Having announced an update to Cweed4, I just noticed that the Win32Forth
> word REPLACE uses a 256 byte string buffer and COUNT and APPEND. This
> means that it cannot handle strings longer than 255 bytes.
>
> Does anyone have a (high level?) version of REPLACE that can handle
> longer strings?
>

This implementation of REPLACE and REPLACE-ALL was written to test the
functionality of a simple buffer similar to the standard pictured output
buffer but without the defects.

The method is straightforward. SPLIT-ALL recursively splits the source
string into substrings of the text between replacements. When the
recursion unwinds the substrings are copied to a buffer and their
buffered (ca u)'s left on the data stack.

Then SAVE-RESULT simply repeatedly copies a substring and replacement
string to create the final result

REPLACE calls a REPLACE-ALL factor for a single replacement. REPLACE-ALL
should be more efficient than other solutions e.g. those that repeatedly
delete/spread/insert the replacement as it does less string copying.

\ --------------------------
\ download buffer.fth from:
\ https://github.com/gerryjackson/Forth-sprintf/blob/master/buffer.fth
\ Note: <~ opens a new buffer and clears it
\ ~holds ( ca u -- ) appends the string to the current buffer
\ ~><~ ( -- ca u ) returns the buffer contents, closes it and
\ opens a new one

include buffer.fth

here 500 dup allot create~buffer rep-buf

defer search? \ Will be set to simulate a failed SEARCH after the first
\ search when REPLACE is used otherwise SEARCH

: split-all ( ca1 u1 ca2 u2 -- ~cai' ~ui' ... ~ca1 ~u1 )
2>r over swap 2r@ search? ( -- ca1 ca4 ux f ) ( R: -- ca2 u2 )
if
2dup 2>r drop over - 2r> ( -- ca1 u1' ca4 ux )
r@ /string ( -- ca1 u1' ca4' ux' )
2r> 2rot 2>r ( -- ca4' ux' ca2 u2 ) ( R: -- ca1 u1' )
recurse ( -- ) ( R: ca1 u1' )
2r> ~holds ~><~ ( -- ~ca1 ~u1 ) \ (~ca ~u) is ~buffer (ca u)
else ( -- cai' cai' ui' ) ( R: ca2 u2 )
2r> 2drop nip ( -- cai' ui' ) ( R: -- )
~holds ~><~ ( -- ~cai ~ui )
then
;

: source-concat ( ca1 u1 ca2 -- ca2' ) \ where ca2' = ca2 + u1
swap 2dup + >r cmove r>
;

: save-result ( 0 0 ~cai ~ui ... ~ca1 ~u1 ca1 ca3 u3 -- ad )
2>r + >r drop ( -- 0 0 ~cai ~ui ... ~ca2 ~u2) ( R: -- ca3 u3 ad1)
begin
2dup or
while
r> 2r@ rot source-concat ( -- 0 0 ~cai ~ui ... ~ca2 ~u2 ad2)
source-concat >r ( -- 0 0 ~cai ~ui ... ~ca3 ~u3 )
repeat ( 0 0 ) ( R: ca3 u3 ad )
2drop r> 2r> 2drop ( -- ad ) ( R: -- )
;

\ Replace 0 or more occurrences of (ca2 u2) with (ca3 u3) in
\ string (ca1 u1), returning the results in (ca1 u4)
: replace* ( ca1 u1 ca2 u2 ca3 u3 -- ca1 u4 )
2>r 3 pick >r 2>r ( -- ca1 u1 ) ( R: -- ca3 u3 ca1 ca2 u2 )
over swap 0 0 2swap 2r> ( -- ca1 0 0 ca1 u1 ca2 u2 )
rep-buf <~ split-all ( -- ca1 0 0 ~cai ~ui ... ~ca1 ~u1 )
r> 2r> save-result ( -- ca1 caj )
over - ( -- ca1 u4 )
;

: replace ( ca1 u1 ca2 u2 ca3 u3 -- ca1 u )
[: search [: 2drop 0 ;] is search? ;] is search? replace*
;

: replace-all ( ca1 u1 ca2 u2 ca3 u3 -- ca1 u )
2 pick 0= abort" Error: String to be replaced cannot be empty"
['] search is search? replace*
;

--
Gerry

On 10/12/2021 21:58, Gerry Jackson wrote:
> On 11/11/2021 10:07, Howerd Oakford wrote:
>> Hi Forthers,
>>
>> Having announced an update to Cweed4, I just noticed that the
>> Win32Forth word REPLACE uses a 256 byte string buffer and COUNT and
>> APPEND. This means that it cannot handle strings longer than 255 bytes.
>>
>> Does anyone have a (high level?) version of REPLACE that can handle
>> longer strings?
>>
>
> This implementation of REPLACE and REPLACE-ALL was written to test the
> functionality of a simple buffer similar to the standard pictured output
> buffer but without the defects.
>
> The method is straightforward. SPLIT-ALL recursively splits the source
> string into substrings of the text between replacements. When the
> recursion unwinds the substrings are copied to a buffer and their
> buffered (ca u)'s left on the data stack.
>
> Then SAVE-RESULT simply repeatedly copies a substring and replacement
> string to create the final result
>
> REPLACE calls a REPLACE-ALL factor for a single replacement. REPLACE-ALL
> should be more efficient than other solutions e.g. those that repeatedly
> delete/spread/insert the replacement as it does less string copying.
>
> \ --------------------------
> \ download buffer.fth from:
> \ https://github.com/gerryjackson/Forth-sprintf/blob/master/buffer.fth
> \ Note: <~  opens a new buffer and clears it
> \       ~holds ( ca u -- ) appends the string to the current buffer
> \       ~><~   ( -- ca u ) returns the buffer contents, closes it and
> \                          opens a new one
>
> include buffer.fth
>
> here 500 dup allot create~buffer rep-buf
>
> defer search?  \ Will be set to simulate a failed SEARCH after the first
>                \ search when REPLACE is used otherwise SEARCH
>
> : split-all  ( ca1 u1 ca2 u2 -- ~cai' ~ui' ... ~ca1 ~u1 )
>    2>r over swap 2r@ search?  ( -- ca1 ca4 ux f ) ( R: -- ca2 u2 )
>    if
>       2dup 2>r drop over - 2r>   ( -- ca1 u1' ca4 ux )
>       r@ /string        ( -- ca1 u1' ca4' ux' )
>       2r> 2rot 2>r      ( -- ca4' ux' ca2 u2 ) ( R: -- ca1 u1' )
>       recurse           ( -- )  ( R: ca1 u1' )
>       2r> ~holds ~><~   ( -- ~ca1 ~u1 )   \ (~ca ~u) is ~buffer (ca u)
>    else                 ( -- cai' cai' ui' ) ( R: ca2 u2 )
>       2r> 2drop nip     ( -- cai' ui' ) ( R: -- )
>       ~holds ~><~       ( -- ~cai ~ui )
>    then
> ;
>
> : source-concat  ( ca1 u1 ca2 -- ca2' ) \ where ca2' = ca2 + u1
>    swap 2dup + >r cmove r>
> ;
>
> : save-result  ( 0 0 ~cai ~ui ... ~ca1 ~u1 ca1 ca3 u3 -- ad )
>    2>r + >r drop   ( -- 0 0 ~cai ~ui ... ~ca2 ~u2) ( R: -- ca3 u3 ad1)
>    begin
>       2dup or
>    while
>       r> 2r@ rot source-concat ( -- 0 0 ~cai ~ui ... ~ca2 ~u2 ad2)
>       source-concat >r         ( -- 0 0 ~cai ~ui ... ~ca3 ~u3 )
>    repeat                      ( 0 0 ) ( R: ca3 u3 ad )
>    2drop r> 2r> 2drop          ( -- ad )  ( R: -- )
> ;
>
>
> \ Replace 0 or more occurrences of (ca2 u2) with (ca3 u3) in
> \ string (ca1 u1), returning the results in (ca1 u4)
> : replace*  ( ca1 u1 ca2 u2 ca3 u3 -- ca1 u4 )
>    2>r 3 pick >r 2>r          ( -- ca1 u1 ) ( R: -- ca3 u3 ca1 ca2 u2 )
>    over swap 0 0 2swap 2r>    ( -- ca1 0 0 ca1 u1 ca2 u2 )
>    rep-buf <~ split-all       ( -- ca1 0 0 ~cai ~ui ... ~ca1 ~u1 )
>    r> 2r> save-result         ( -- ca1 caj )
>    over -                     ( -- ca1 u4 )
> ;
>
> : replace  ( ca1 u1 ca2 u2 ca3 u3 -- ca1 u )
>    [: search [: 2drop 0 ;] is search? ;] is search? replace*
> ;
>
> : replace-all  ( ca1 u1 ca2 u2 ca3 u3 -- ca1 u )
>    2 pick 0= abort" Error: String to be replaced cannot be empty"
>    ['] search is search? replace*
> ;
>
Hi Gerry,

Thanks for this - I have added it to my Forth collection :-)
It is interesting to compare the different approaches...

Cheers,
Howerd