On 6/07/2022 01:32, Anton Ertl wrote:
> Stephen Pelc <stephen@vfxforth.com> writes:
>>The behaviour come from when we swtched from block files to text files.
>>We wished to retain the ability to keep source in chunks, and to keep the
>>text small, so we treated ^L (12) as a page separator and TAB (9) as white
>>space. At that time many text editors behaved the same way.
>
> 11.3.5
> |When parsing from a text file using a space delimiter, control
> |characters shall be treated the same as the space character.
>
> [funky behaviour of SKIP and SCAN in VFX]
>>I believe it is in the spirit of the ANS
>
> It certainly does: Systems are allowed to implement non-standard words
> like SKIP and SCAN with whatever semantics they like.

The standard for SKIP SCAN had been set by L&P F83. Anyone implementing
it would have been aware of what it was, and the consequences of departing.

On Wednesday, 6 July 2022 at 00:31:56 UTC+1, dxforth wrote:
> On 6/07/2022 01:32, Anton Ertl wrote:
> > Stephen Pelc <ste...@vfxforth.com> writes:
> >>The behaviour come from when we swtched from block files to text files.
> >>We wished to retain the ability to keep source in chunks, and to keep the
> >>text small, so we treated ^L (12) as a page separator and TAB (9) as white
> >>space. At that time many text editors behaved the same way.
> >
> > 11.3.5
> > |When parsing from a text file using a space delimiter, control
> > |characters shall be treated the same as the space character.
> >
> > [funky behaviour of SKIP and SCAN in VFX]
> >>I believe it is in the spirit of the ANS
> >
> > It certainly does: Systems are allowed to implement non-standard words
> > like SKIP and SCAN with whatever semantics they like.
> The standard for SKIP SCAN had been set by L&P F83. Anyone implementing
> it would have been aware of what it was, and the consequences of departing.

I implemented a forth-like scanner and parser
in python once and found that the ability to just pass an
array of chars was useful. Meant I could look [' ','\t','\n','\r']
more easily.

If the need had arisen in forth then we would have these
filed under common usage.

( ---------------------------------------------------------- )
: searchchar ( a u c -- f )
over 0> if
scan nip 0> if true else false then
else drop drop drop false then ;
( ---------------------------------------------------------- )
: skip[] ( a1 u1 a2 u2 -- a3 u3 )
2>r begin eol? 0= while
rch 2r@ rot searchchar while
nch repeat
then 2r> 2drop ;
( ---------------------------------------------------------- )
: scan[] ( a1 u1 a2 u2 -- a3 u3 )
2>r begin eol? 0= while
rch 2r@ rot searchchar 0= while
nch repeat
then 2r> 2drop ;
( ---------------------------------------------------------- )

Notes
(1) searchchar is used because standard search requires a string
and I needed a char

so in gforth you would pass a string eg s\" \t \n\r" and search
for bl, tab, cr and nl all at once.
or any other combination you seek to skip[] and scan[] over

NN

On Wednesday, 6 July 2022 at 19:26:47 UTC+1, NN wrote:
> On Wednesday, 6 July 2022 at 00:31:56 UTC+1, dxforth wrote:
> > On 6/07/2022 01:32, Anton Ertl wrote:
> > > Stephen Pelc <ste...@vfxforth.com> writes:
> > >>The behaviour come from when we swtched from block files to text files.
> > >>We wished to retain the ability to keep source in chunks, and to keep the
> > >>text small, so we treated ^L (12) as a page separator and TAB (9) as white
> > >>space. At that time many text editors behaved the same way.
> > >
> > > 11.3.5
> > > |When parsing from a text file using a space delimiter, control
> > > |characters shall be treated the same as the space character.
> > >
> > > [funky behaviour of SKIP and SCAN in VFX]
> > >>I believe it is in the spirit of the ANS
> > >
> > > It certainly does: Systems are allowed to implement non-standard words
> > > like SKIP and SCAN with whatever semantics they like.
> > The standard for SKIP SCAN had been set by L&P F83. Anyone implementing
> > it would have been aware of what it was, and the consequences of departing.
> I implemented a forth-like scanner and parser
> in python once and found that the ability to just pass an
> array of chars was useful. Meant I could look [' ','\t','\n','\r']
> more easily.
>
> If the need had arisen in forth then we would have these
> filed under common usage.
>
> ( ---------------------------------------------------------- )
> : searchchar ( a u c -- f )
> over 0> if
> scan nip 0> if true else false then
> else drop drop drop false then ;
> ( ---------------------------------------------------------- )
> : skip[] ( a1 u1 a2 u2 -- a3 u3 )
> 2>r begin eol? 0= while
> rch 2r@ rot searchchar while
> nch repeat
> then 2r> 2drop ;
>
> ( ---------------------------------------------------------- )
> : scan[] ( a1 u1 a2 u2 -- a3 u3 )
> 2>r begin eol? 0= while
> rch 2r@ rot searchchar 0= while
> nch repeat
> then 2r> 2drop ;
> ( ---------------------------------------------------------- )
>
> Notes
> (1) searchchar is used because standard search requires a string
> and I needed a char
>
>
>
> so in gforth you would pass a string eg s\" \t \n\r" and search
> for bl, tab, cr and nl all at once.
>
> or any other combination you seek to skip[] and scan[] over
>
>
> NN

Before someone asks

a1 u1 is the string we are searching over
a2 u2 is the character array of chars we are looking for
and
a3 u3 is what is returned as a result of searching thru a1 u1

NN schrieb am Mittwoch, 6. Juli 2022 um 20:26:47 UTC+2:
> On Wednesday, 6 July 2022 at 00:31:56 UTC+1, dxforth wrote:
> > On 6/07/2022 01:32, Anton Ertl wrote:
> > > Stephen Pelc <ste...@vfxforth.com> writes:
> > >>The behaviour come from when we swtched from block files to text files.
> > >>We wished to retain the ability to keep source in chunks, and to keep the
> > >>text small, so we treated ^L (12) as a page separator and TAB (9) as white
> > >>space. At that time many text editors behaved the same way.
> > >
> > > 11.3.5
> > > |When parsing from a text file using a space delimiter, control
> > > |characters shall be treated the same as the space character.
> > >
> > > [funky behaviour of SKIP and SCAN in VFX]
> > >>I believe it is in the spirit of the ANS
> > >
> > > It certainly does: Systems are allowed to implement non-standard words
> > > like SKIP and SCAN with whatever semantics they like.
> > The standard for SKIP SCAN had been set by L&P F83. Anyone implementing
> > it would have been aware of what it was, and the consequences of departing.
> I implemented a forth-like scanner and parser
> in python once and found that the ability to just pass an
> array of chars was useful. Meant I could look [' ','\t','\n','\r']
> more easily.
>
> If the need had arisen in forth then we would have these
> filed under common usage.
>
> ( ---------------------------------------------------------- )
> : searchchar ( a u c -- f )
> over 0> if
> scan nip 0> if true else false then
> else drop drop drop false then ;
> ( ---------------------------------------------------------- )
> : skip[] ( a1 u1 a2 u2 -- a3 u3 )
> 2>r begin eol? 0= while
> rch 2r@ rot searchchar while
> nch repeat
> then 2r> 2drop ;
>
> ( ---------------------------------------------------------- )
> : scan[] ( a1 u1 a2 u2 -- a3 u3 )
> 2>r begin eol? 0= while
> rch 2r@ rot searchchar 0= while
> nch repeat
> then 2r> 2drop ;
> ( ---------------------------------------------------------- )
>
> Notes
> (1) searchchar is used because standard search requires a string
> and I needed a char
>
>
>
> so in gforth you would pass a string eg s\" \t \n\r" and search
> for bl, tab, cr and nl all at once.
>
> or any other combination you seek to skip[] and scan[] over

In C the string library functions strpbrk and strcspn do that job.

On 7/07/2022 04:26, NN wrote:
> ...
> I implemented a forth-like scanner and parser
> in python once and found that the ability to just pass an
> array of chars was useful. Meant I could look [' ','\t','\n','\r']
> more easily.
>
> If the need had arisen in forth then we would have these
> filed under common usage.
>
> ( ---------------------------------------------------------- )
> : searchchar ( a u c -- f )
> over 0> if
> scan nip 0> if true else false then
> else drop drop drop false then ;
> ( ---------------------------------------------------------- )
> : skip[] ( a1 u1 a2 u2 -- a3 u3 )
> 2>r begin eol? 0= while
> rch 2r@ rot searchchar while
> nch repeat
> then 2r> 2drop ;
>
> ( ---------------------------------------------------------- )
> : scan[] ( a1 u1 a2 u2 -- a3 u3 )
> 2>r begin eol? 0= while
> rch 2r@ rot searchchar 0= while
> nch repeat
> then 2r> 2drop ;
> ( ---------------------------------------------------------- )
>
> Notes
> (1) searchchar is used because standard search requires a string
> and I needed a char
>
>
>
> so in gforth you would pass a string eg s\" \t \n\r" and search
> for bl, tab, cr and nl all at once.
>
> or any other combination you seek to skip[] and scan[] over

We all have routines squirrelled away but primitives SKIP SCAN
is what's common to all. Henry is correct to assert they be kept
primitive. Sometimes we don't see the woods for the trees.

: searchchar ( a u c -- f )
over ( 0>) if scan nip ( 0>) exit then
drop nip ;

On 7/07/2022 04:47, minf...@arcor.de wrote:
> NN schrieb am Mittwoch, 6. Juli 2022 um 20:26:47 UTC+2:
>>
>> so in gforth you would pass a string eg s\" \t \n\r" and search
>> for bl, tab, cr and nl all at once.
>>
>> or any other combination you seek to skip[] and scan[] over
>
> In C the string library functions strpbrk and strcspn do that job.

As would these in the case of blanks & control characters and more
efficiently.

\ Scan blank or control character
code BL-SCAN ( c-addr1 u1 -- c-addr2 u2 )
cx pop di pop $20 # al mov sseg ) es mov 2 $ jcxz
1 $: es: 0 [di] al cmp 2 $ jnc di inc 1 $ loop
2 $: di push cx push next
end-code

\ Skip blank or control character
code BL-SKIP ( c-addr1 u1 -- c-addr2 u2 )
cx pop di pop $20 # al mov sseg ) es mov 2 $ jcxz
1 $: es: 0 [di] al cmp 2 $ jc di inc 1 $ loop
2 $: di push cx push next
end-code

On Tuesday, July 5, 2022 at 6:42:35 PM UTC+2, Marcel Hendrix wrote:
> This means BL SCAN is a special case.
I hate special cases. Because they tend to lead to ugly code and
unintuitive behavior.

Hans Bezemer

In article <78faec9f-6732-4144-84d3-edf9d197311dn@googlegroups.com>,
Hans Bezemer <the.beez.speaks@gmail.com> wrote:
>On Tuesday, July 5, 2022 at 6:42:35 PM UTC+2, Marcel Hendrix wrote:
>> This means BL SCAN is a special case.
>I hate special cases. Because they tend to lead to ugly code and
>unintuitive behavior.

+1
Sufficient reason to not implement SCAN .
WORD forces two different behaviours : PARSE-NAME / TOKEN / NAME
and PARSE.
So WORD is banned from the core implementation, and becomes
a loadable extension.
BL SCAN is inheriting a 70's design error from WORD .

[In my book]

>
>Hans Bezemer
>

Groetjes Albert
--
"in our communism country Viet Nam, people are forced to be
alive and in the western country like US, people are free to
die from Covid 19 lol" duc ha
albert@spe&ar&c.xs4all.nl &=n http://home.hccnet.nl/a.w.m.van.der.horst

On 9/07/2022 05:41, albert wrote:
> In article <78faec9f-6732-4144-84d3-edf9d197311dn@googlegroups.com>,
> Hans Bezemer <the.beez.speaks@gmail.com> wrote:
>>On Tuesday, July 5, 2022 at 6:42:35 PM UTC+2, Marcel Hendrix wrote:
>>> This means BL SCAN is a special case.
>>I hate special cases. Because they tend to lead to ugly code and
>>unintuitive behavior.
>
> +1
> Sufficient reason to not implement SCAN .
> WORD forces two different behaviours : PARSE-NAME / TOKEN / NAME
> and PARSE.
> So WORD is banned from the core implementation, and becomes
> a loadable extension.
> BL SCAN is inheriting a 70's design error from WORD .

Use of SCAN extends beyond WORD etc e.g.

; -PATH ( c-addr1 u1 -- c-addr2 u2 )
; 2dup [char] : scan dup if 1 /string 2swap
; then begin 2drop 2dup [char] \ scan dup
; while 1 /string 2swap repeat 2drop

; /ext ( c-addr1 u1 -- u2 ) -path [char] . scan nip

; +EXT ( c-addr1 u1 c-addr2 u2 -- c-addr3 u3 )
; 2over /ext if 2drop end 3 min
; s" ." 2rot -trailing (pfsiz-5) min zbuf
; @ 1+ 0 +string +string +string

; -EXT ( c-addr u1 -- c-addr u2 ) 2dup /ext -