Why no reg exp in Forth? 
Author Message
 Why no reg exp in Forth?

Why don't we have a nice package for regular expressions in Forth?

I finally seem to understand why.
The reason is implementation problems. I just don't grok all the
talk about "not useful" or " not Forth like" or "Gray is better"

Let us look at the traditional way to handle regular expressions.

Say we have
   [abc]*b
For those not in the know: this matches
   a sequence of characters matching 'a' or 'b' or 'c'   followed by
    'b'.

So the following string are matched :
  b ab bb cb cbab

Note that in matching "bb" we first match "bb" to "[abc]*". Then we discover
that the string is exhausted so we retry by only matching "b" to "[abc]*".
This is called backtracking. Because this solves a real problem for you,
implementing it presents a real problem too.

This is handled in fortran (Kernighan and Pike) by first translating the
reg exp in a buffer with a mixed content (tokens count and characters).

token: CHARACTER CLOSURE
count: 3
char:  a
char:  b
char: c
token: CHARACTER EXACT MATCH
char: b

Afterwards this buffer is interpreted, during the checking of the
target string.

In Forth of course we have but one interpreter so
naturally this translates in Forth into :

xt for CHARACTER CLOSURE
count: 3
char:  a
char:  b
char: c
xt for: CHARACTER EXACT MATCH
char: b
xt for EXIT

HOWEVER!
This is a design error of the worst kind, and everybody going  there
gets into problems without ever recovering.
On the other hand nobody ever seems to try out a different way to do it.

The reason is the following:
1. we have to handle the inline data, which is inhomogeneous as well
2. for backtracking purposes we must remember (in this example) the
position of " xt for: CHARACTER EXACT MATCH" to execute this and the following
code again and again.
3. for backtracking purposes we must remember where we started matching,
probably on the return stack.

These three uses of the return stack (two of them non portable at that!) get
entangled to the point of no return.

Bottom line: no regular expressions in Forth.

----------------------------------------------------------------------------

Interestingly, a straightforward port of my c++-code for regular expressions
appeared quite feasible (thus far, i.e. short of debugging).

This will lead to code in the following style that many will find
offensive. However it only requires CORE set words.
All the IF branches put a backtrack-to-where? pointer on the return stack.
So replacing the multiple IF's with a jump table is not straightforward.

\ **************************************************************************
\     WARNING: THIS IS NOWHERE WORKING CODE
\     IT IS THE RESULT OF A CONVERSION FROM c++ TO SEE HOW IT LOOKS
\     THE c++-CODE IS NOT STANDARD REG EXP TO BEGIN WITH
\ **************************************************************************

2    CONSTANT CCHAR      \ Specific character
4    CONSTANT CANY       \ Any character
6    CONSTANT CSET       \ A character set
8    CONSTANT CSETC      \ A character set, characterized by its complement
01   CONSTANT CLOS       \ And this in to get the closure of one of the above
10   CONSTANT CEOF       \ Marks the separation between fields
12   CONSTANT CSYNC      \ Match as few characters as possible
0    CONSTANT CEND       \ Marks the end of the regular expression

\ Layout of expression in ``patternE''.
\ NOTE: THIS IS A SEQUENTIAL LAYOUT!
\ It consists of the following elements (separated by ',' | is bitwise or )
\ CCHAR c , CLOS|CCHAR c , CANY , CLOS|CANY , CEOF #field ,
\ CSET count (count-1)*c , CSETC count (count-1)*c ,
\ CLOS|CSET count (count-1)*c , CLOS|CSETC count (count-1)*c ,
\ CSYNC , CEND
\ ``c'' means any character except null ('\000'). Null is not allowed,
\ because it must not be present in the expression to be matched, it is
\ needed as a terminator. ``count'' and ``#field'' are integers.
\ #field 0 matches the beginning of the record (say '^') and 1 ..

\ separator is the CEOF 0 of the next record.
\ CEOF and CEND are restricted
\ Note: the position in ``patternE'' determines whether it is a
\ ``charclass'', a count or a character. If sequentially parsed this
\ does not lead to ambiguity despite overlapping ranges
\ (All unsigned char's are acceptable in the expression as c.)

\ ***************************************************************************/
\                                                                           */
\  Returns "the string at ``lp'' matches the whole of the regular           */
\  expression ``ep''"                                                       */
\                                                                           */
\ ***************************************************************************/

: matchE            ( CHAR *lp   VARIABLE *ep -- fl )
   \ Each pass through this loop handles an element of the compiled
   \ expression (where ``ep'' points), including its closure (if any).
   \ Returns as soon as a mismatch is detected.
   BEGIN
      COUNT
      DUP CEND = IF DROP 2DROP TRUE EXIT
      ELSE DUP CEOF = IF DROP
         OVER >R COUNT  R> !SEPPOSITION
         0 >R
      ELSE DUP CCHAR = IF DROP
         \ Special action needed for matchee exhausted
         COUNT >R SWAP COUNT R> <> IF 2DROP FALSE EXIT THEN
         SWAP
         0 >R
      ELSE DUP CCHAR CLOS OR = IF DROP
         OVER >R
         COUNT >R SWAP

      ELSE DUP CANY = IF DROP
         SWAP COUNT 0= IF 2DROP FALSE EXIT THEN
         SWAP
         0 >R
      ELSE DUP CSYNC = IF DROP
         \ Special action needed for matchee exhausted

            \ Adaption for 3 param matchE
            2DUP RECURSE IF 2DROP TRUE EXIT THEN
            SWAP 1+ SWAP
         REPEAT
         2DROP FALSE EXIT
      ELSE DUP CSET = IF DROP
         >R

        COUNT + R> SWAP
         0 >R
      ELSE DUP CSET CLOS OR = IF DROP
         OVER >R
         >R

        COUNT + R> SWAP
      ELSE DUP CSETC = IF DROP
         \ Special action needed for matchee exhausted

         >R

        COUNT + R> SWAP
         0 >R
      ELSE DUP CSETC CLOS OR = IF DROP
         OVER >R
         >R

        COUNT + R> SWAP
      THEN THEN THEN THEN THEN THEN THEN THEN THEN THEN

         \ `lp' points to the first non-matching character
         \ At this point we have matched as much patterns as possible
         \ Backtrack if we have matched too much

             BEGIN
                \ Adaption for 3 param matchE
                2DUP RECURSE IF RDROP 2DROP TRUE EXIT THEN

                SWAP 1- SWAP
             REPEAT
             2DROP RDROP FALSE EXIT
         THEN
         RDROP
   AGAIN
;

\ **************************************************************************
\     WARNING: THIS IS NOWHERE WORKING CODE
\     IT IS THE RESULT OF A CONVERSION FROM C TO SEE HOW IT LOOKS
\     THE C-CODE IS NOT STANDARD REG EXP TO BEGIN WITH
\ **************************************************************************
--
Albert van der Horst,Oranjestr 8,3511 RA UTRECHT,THE NETHERLANDS
To suffer is the prerogative of the strong. The weak -- perish.



Mon, 17 Jan 2005 05:48:02 GMT  
 Why no reg exp in Forth?

Albert van der Horst writes:

Quote:
> Why don't we have a nice package for regular expressions in Forth?

Because you don't take the trouble to search for it?

The iForth distribution has the Hawk language implementation which sports
regexps and associative arrays. And there is FOSM. And our Australian friend
whose name escapes me (Monty Python: it must be a Bruce) had also a lot of
postings on it 1 or 2 years ago.

But a certain hot-headed ignorance of the past is of course necessary to
embark on any project :-)

-marcel



Tue, 18 Jan 2005 12:49:24 GMT  
 Why no reg exp in Forth?


Quote:

> Albert van der Horst writes:

> > Why don't we have a nice package for regular expressions in Forth?

> Because you don't take the trouble to search for it?

> The iForth distribution has the Hawk language implementation which sports
> regexps and associative arrays. And there is FOSM. And our Australian
friend
> whose name escapes me (Monty Python: it must be a Bruce) had also a lot of
> postings on it 1 or 2 years ago.

> But a certain hot-headed ignorance of the past is of course necessary to
> embark on any project :-)

    Quest32 has a regular expression engine, too (both a library and in the
editor).

--

-Gary Chanson (MVP for Windows SDK)
-Software Consultant (Embedded systems and Real Time Controls)

-Abolish public schools



Tue, 18 Jan 2005 13:24:16 GMT  
 Why no reg exp in Forth?
Es schrieb Marcel Hendrix:

Quote:

> Albert van der Horst writes:

> > Why don't we have a nice package for regular expressions in Forth?

> Because you don't take the trouble to search for it?

> The iForth distribution has the Hawk language implementation which sports
> regexps and associative arrays. And there is FOSM. And our Australian friend
> whose name escapes me (Monty Python: it must be a Bruce) had also a lot of
> postings on it 1 or 2 years ago.

> But a certain hot-headed ignorance of the past is of course necessary to
> embark on any project :-)

I did find FOSM and dumped it for being too unusual in syntax.

Apart from iForth special or Quest32 specials, is there are portable
regex package for forth that comes to your mind, and one that
derives from some established regex syntax? That would be fantastic!



Tue, 18 Jan 2005 22:40:16 GMT  
 Why no reg exp in Forth?

Quote:

> is there are portable
> regex package for forth that comes to your mind, and one that
> derives from some established regex syntax? That would be fantastic!

ThisForth has standard regexpr. It is Tatu Ylonen's free 1991 version
in  C with Forth linkage. Any Forth-in-C can easily have standard
regexpr.

I thought that it would be fantastic.

However my experience showed that generalized SKIP and SCAN is more
powerful.  For example: Text to HTML; HTML to text.

My basic functions are:

    SKIP[ <character test> ]SKIP
    SCAN[ <character test> ]SCAN
    BACK[ <character test> ]BACK
    Is-Upper
    Is-Lower
    Is-Alpha
    Is-Digit
    Is-Alnum
    Is-White
    View-Next-Line

--
Wil Baden



Wed, 19 Jan 2005 00:23:20 GMT  
 Why no reg exp in Forth?

Quote:
> Why don't we have a nice package for regular expressions in Forth?

> I finally seem to understand why.
> The reason is implementation problems. I just don't grok all the
> talk about "not useful" or " not Forth like" or "Gray is better"

I'm happy to hear from some other posts in this thread that there are several
versions of regular expression parsers in Forth around.

As for us, we don't have a version in our products for the simple
reason that we've never encountered a need for it and our customers
have never asked for it (this is based on 30 yrs experience, primarily
in embedded systems but with some data base work along the way).

I'm certainly not saying that it "isn't useful", obviously there's a class
of problems for which it's quite useful.  We just haven't run into it.
Our priorities must be to solve our customers problems as effectively
as possible, and to provide tools relevant to solving those problems.

Perl, which has been much under discussion here, is a special-
purpose language for a certain class of problems.  That's fine,
if you have that kind of problem you should probably use Perl.
I don't see the logic of complaining that Forth (which was also
designed to address a certain class of problems, specifically
embedded & real-time apps, although it's certainly been
found useful in other application domains) should be able
to reproduce the functionality of a language designed to
address a different, special class of problems.

Cheers,
Elizabeth



Wed, 19 Jan 2005 03:22:07 GMT  
 Why no reg exp in Forth?


Quote:

>Albert van der Horst writes:

>> Why don't we have a nice package for regular expressions in Forth?

>Because you don't take the trouble to search for it?

>The iForth distribution has the Hawk language implementation which sports
>regexps and associative arrays. And there is FOSM.

FoSM is neat because it is not a package layered on top of Forth as
you might expect but an extension of Forth as a pattern-matching
language. FoSM's patterns are Forth words that can be compiled,
executed and combined with ANS Forth words.

Bye for now                       ____/  /  __  /   /   /   /   /
                                 /      /  /  _/   /   /   /  /
Chris Jakeman                   __/    /  / __    /   /   /_/
                               /      /  /   /   /   /   /  \
[To reply, please           __/    __/  ____/    ___/ __/   _\
 unspam my address]
                           Forth Interest Group United Kingdom
Voice +44 (0)1733 753489   chapter at http://www.fig-uk.org



Wed, 19 Jan 2005 04:51:09 GMT  
 Why no reg exp in Forth?

Quote:
> Why don't we have a nice package for regular expressions in Forth?
> I finally seem to understand why.
> The reason is implementation problems.

I don't think so.

Quote:
> I just don't grok all the talk about "not useful" or
> "not Forth like" or "Gray is better"

We started out with a variant of the Gray parser for parsing HTML
files in our Forth browser at iTV.  The second version was greatly
improved in performance, complexity, and size by removing the parser.
It was much better to treat HTML as Forth. It was "more Forth-like"
to throw out the stuff that was "not useful" for that problem
and use the stuff that was built into Forth for the purpose.
That seems to be the hardest thing for people to grok about Forth.

best wishes,
Jeff



Wed, 19 Jan 2005 05:37:10 GMT  
 Why no reg exp in Forth?

Quote:

> We started out with a variant of the Gray parser for parsing HTML
> files in our Forth browser at iTV.  The second version was greatly
> improved in performance, complexity, and size by removing the parser.
> It was much better to treat HTML as Forth.

Could you expand on what you mean by "treat HTML as Forth"?  Do you
mean altering what the outer interpreter considers to be a word
terminator so that '>' and/or perhaps '<' are considered terminators
so that you can "parse" something like :-

 <HTML><HEAD><TITLE>Example</TITLE></HEAD><BODY><P>Hello</P></BODY></HTML>

or do you use some other mechanism?  If that is the case, or some
other use is made of the outer interpreter, I'm curious as to what
approach would be taken in ColorForth.



Wed, 19 Jan 2005 06:23:28 GMT  
 Why no reg exp in Forth?

Quote:

> Could you expand on what you mean by "treat HTML as Forth"?  Do you
> mean altering what the outer interpreter considers to be a word
> terminator so that '>' and/or perhaps '<' are considered terminators
> so that you can "parse" something like :-

>  <HTML><HEAD><TITLE>Example</TITLE></HEAD><BODY><P>Hello</P></BODY></HTML>

Yes.  A big problem in a browser is that most HTML pages have errors.
Different browsers handle them in different ways.  Trying to apply
formal parsing methods to unravel the various errors was not as
nice as extending Forth to execute HTML to parse a file and format
a page for display.

Quote:
> I'm curious as to what approach would be taken in ColorForth.

Chuck talked a bit about his vision of Forth Markup Language
in his chatroom interview this May.  Interesting question.
http://www.ultratechnology.com/chatlog.htm

best wishes,
Jeff



Wed, 19 Jan 2005 07:28:05 GMT  
 Why no reg exp in Forth?

Quote:

> > I'm curious as to what approach would be taken in ColorForth.

> Chuck talked a bit about his vision of Forth Markup Language
> in his chatroom interview this May.  Interesting question.
> http://www.ultratechnology.com/chatlog.htm

There he mentions converting HTML->FML and then driving the display by
interpreting the FML.  No mention of how the HTML->FML translation
would be done though.  Assuming this is done using the same technique
as you used, then it would seem that something very much like the
outer interpreter would form part of HTML->FML converter.  However,
Chuck's approach with ColorForth seems to be that the outer
interpreter is not needed at runtime -- most of its work having been
done by the editor.  I'll be interested to hear what direction he
takes for HTML->FML.


Wed, 19 Jan 2005 11:24:48 GMT  
 Why no reg exp in Forth?

Quote:
> Why don't we have a nice package for regular expressions in Forth?

We do, as many have pointed out.

But that's not what I want to address here.  As a result of your
posting I've been studying the pcre package and it strikes me that
although very nice and convenient, perhaps such a powerful regular
expression syntax is overkill for many Forth applications.  pcre is
5000 lines of code.  Maybe full regular expressions are an
over-generalized solution to many classes of parsing problems.

On the other hand, perhaps it's nice not to have to worry about such
things when I need a quick 'n dirty job done.

Andrew.



Wed, 19 Jan 2005 21:36:08 GMT  
 Why no reg exp in Forth?



Quote:
> Perl, which has been much under discussion here, is
> a special-purpose language for a certain class of
> problems.

I wouldn't class Perl as a "special purpose language."  Like any language,
it has strengths and weaknesses, but that alone doesn't make it a "special
purpose" language.  Examples of what I would consider as special purpose
languages include things like SQL, Pilot, resource compilers for GUIs, JCL,
VHDL, tbl, pic, roff, and the endless "little languages" that we all come up
with to solve very specific problems.

I see Perl as a general purpose language that happens to have good support
for processing textual data.  Because of that, it is commonly seen where
text processing is useful and interesting, such as CGI, system
administration, and increasingly bioinformatics.  But there is more to the
language than processing text.

Quote:
> I don't see the logic of complaining that Forth (which was
> also designed to address a certain class of problems,
> specifically embedded & real-time apps, although it's
> certainly been found useful in other application domains)
> should be able to reproduce the functionality of a language
> designed to address a different, special class of problems.

When Larry Wall first created Perl, he designed it as a language that he
thought was good for report generation and system administration tasks.  He
took features from other languages (and a few new ideas), put it in a
blender, and came up with a language that for a few years was rarely used
for anything but the tasks he designed it for.

Several years later when the World Wide Web became a big deal, programmers
discovered that Perl is a fine language for doing CGI work.  None of this
was planned or designed-- it just so happened that the text processing
features in Perl were a good match for CGI work.  Now several years later,
people who work with bioinformatic databases (such as genetic researchers)
are finding that the language (and add on modules that are available) work
well for them.

Who knows who will use Perl 5, 10, or 20 years from now.

I frankly don't believe Forth was *designed* for the niches it now finds
itself in.  Certainly my reading of Forth's early history doesn't suggest
that Mr. Moore (and you, or others) ever sat down and said, "I'm going to
*design* a language that will have limited applicability for these specific
application domains."  I see no special constructs in Forth that are
specific to embedded work.

Instead, what happened was that programmers found Forth's attributes of
small size, speed, interactivity, and extensibility to be suitable for
embedded work.  And like CGI programmers who latched on to Perl, embedded
programmers latched on to Forth.

You state that Forth, Inc. never had the need for regular expressions and
customers never asked you for it.  The conclusion you drew from that was
that such a language feature wasn't important for your work.  Fine-- but
another conclusion might be that Forth, Inc. has a reputation of working
primarily in certain application domains and so only draws customers that
have needs similar to other customers you have served.  In other words,
"Forth is for embedded and real-time systems" became a self-fulfilling
self-selecting prophecy.

Maybe Forth, Inc. isn't interested in seeking out other application domains
where Forth can be useful.  Or maybe there is a lack of vision here-- that
if Forth did have some language facilities programmers have found useful in
other application domains, then perhaps Forth wouldn't be marginalized to
embedded systems.  Of course, we'll never know, because plenty of people
(including yourself) seem perfectly happy limiting Forth to specific
application domains.



Thu, 20 Jan 2005 01:31:02 GMT  
 Why no reg exp in Forth?

Quote:



> > Perl, which has been much under discussion here, is
> > a special-purpose language for a certain class of
> > problems.

> I wouldn't class Perl as a "special purpose language."  Like any language,
> it has strengths and weaknesses, but that alone doesn't make it a "special
> purpose" language.  Examples of what I would consider as special purpose
> languages include things like SQL, Pilot, resource compilers for GUIs, JCL,
> VHDL, tbl, pic, roff, and the endless "little languages" that we all come up
> with to solve very specific problems.

> I see Perl as a general purpose language that happens to have good support
> for processing textual data.  Because of that, it is commonly seen where
> text processing is useful and interesting, such as CGI, system
> administration, and increasingly bioinformatics.  But there is more to the
> language than processing text.
> ...

> When Larry Wall first created Perl, he designed it as a language that he
> thought was good for report generation and system administration tasks.  He
> took features from other languages (and a few new ideas), put it in a
> blender, and came up with a language that for a few years was rarely used
> for anything but the tasks he designed it for.

> Several years later when the World Wide Web became a big deal, programmers
> discovered that Perl is a fine language for doing CGI work.  None of this
> was planned or designed-- it just so happened that the text processing
> features in Perl were a good match for CGI work.  Now several years later,
> people who work with bioinformatic databases (such as genetic researchers)
> are finding that the language (and add on modules that are available) work
> well for them.

Ok, I think the only place we disagree is in the interpretation of "special
purpose language."  What I meant by that is a language optimized for
certain classes of problems; your description of Perl above matches that
definition for me.  I do not mean "limited to certain applications."

Quote:
> ...
> I frankly don't believe Forth was *designed* for the niches it now finds
> itself in.  Certainly my reading of Forth's early history doesn't suggest
> that Mr. Moore (and you, or others) ever sat down and said, "I'm going to
> *design* a language that will have limited applicability for these specific
> application domains."  I see no special constructs in Forth that are
> specific to embedded work.

Well, I was there.  Again, I think our definitions are differing, not the
facts.  Forth wasn't designed to be "limited" in any way, but it
certainly was _optimized_ to solve certain problems found in the
embedded applications for which it was designed and developed.

- Show quoted text -

Quote:
> You state that Forth, Inc. never had the need for regular expressions and
> customers never asked you for it.  The conclusion you drew from that was
> that such a language feature wasn't important for your work.  Fine-- but
> another conclusion might be that Forth, Inc. has a reputation of working
> primarily in certain application domains and so only draws customers that
> have needs similar to other customers you have served.  In other words,
> "Forth is for embedded and real-time systems" became a self-fulfilling
> self-selecting prophecy.

> Maybe Forth, Inc. isn't interested in seeking out other application domains
> where Forth can be useful.  Or maybe there is a lack of vision here-- that
> if Forth did have some language facilities programmers have found useful in
> other application domains, then perhaps Forth wouldn't be marginalized to
> embedded systems.  Of course, we'll never know, because plenty of people
> (including yourself) seem perfectly happy limiting Forth to specific
> application domains.

One of the basic principles in marketing for a small business with
limited resources is to identify a niche that is well-matched to your
strengths and focus on that niche.  A marketing message that asserts
"My product [technology, ...] is good for everything" is actually a
weak and ineffective message, and attempting to field a product
that is attempting to be "all things to all people" is more likely to
produce a product that is only moderately good at anything, and
which has a poorly focused image to potential users.

FORTH, Inc. is very good at embedded & real-time applications.
We do not find that focus limiting, we find it presents a clear
picture of capabilities to potential customers.  If someone who
is expert at another field (e.g. text processing) wants to tailor a
version of Forth to that and market it to folks in that arena that's
fine with me.

Cheers,
Elizabeth



Thu, 20 Jan 2005 04:46:01 GMT  
 Why no reg exp in Forth?

Quote:
> There he mentions converting HTML->FML and then driving the display by
> interpreting the FML.  No mention of how the HTML->FML translation
> would be done though.  Assuming this is done using the same technique

The technique I would use to process HTML text is to treat it
character by character (because of the free-form formatting of an HTML
and XML source file, you have no other choice).  It's important to
realize that you have two basic modes of operation inside an HTML
file: text and tag.

When "interpreting text," you basically pass each character you find
into a buffer belonging to the last opened tag's container.  Thus,
some buffer management will be needed if you do this (even if it's
just ',').  An alternative is to actually render the characters
directly to the screen, clipping permitting, of course.  I like the
former approach better, as a tree containing the structure of the
document can be built, and processed afterwards.

When a < character is found, however, the text interpretter knows that
what follows is going to be a command of some sort (e.g., bold,
italics, definition of a table, etc).  Thus, we parse the word from
the succeeding text, delimited by either space, a /, or >, and treat
that as a directly executable Forth word.  Look it up in the
dictionary, and EXECUTE.

NOTE: It's important to note that when processing XML documents, words
that start with / will have the leading / in the name.  Thus, <B></B>
will call B and /B, respectively.  However, <P/> will **ONLY** call P
(because parsing stops at the /).  In software that I'd write, it'd be
up to the implementation of P to properly handle the empty-container
condition.

To facilitate processing of arguments, enough input context is exposed
to the called words to be able to parse out the arguments.

Once the word corresponding to an HTML tag has been executed, control
is returned to the character interpretter where the cycle repeats.
Only when the end of the input file has been reached will the
character interpretter exit.

But, that's how I'd do it.  That's not necessarily how Chuck or Jeff
would do it.  :)

\ HYPOTHETICAL CODE FOR ILLUSTRATION PURPOSES ONLY

CREATE Context   2 CELLS ALLOT

: Context! ( caddr u -- )
  Context 2DUP CELL+ ! NIP ! ;



: HashWord
\  If necessary, massage the name of the word here to include a
standard
\  prefix or postfix, so that tag names are "unique" from normal Forth
words.
\  We wouldn't want people to enter <BYE> in our XML and have it work,
now
\  would we?  :)
\
\  Alternatively, you could just search for the word in a special
word-list
\  guaranteed to be separate from the normal Forth dictionary.
  ;

DEFER UnsupportedTag ( -- ) ( or define it here if you wish )

: XMLTag
  ParseTag HashWord FIND IF EXECUTE ELSE UnsupportedTag THEN ;

DEFER Datum ( ch -- )  ( or define it here if you wish )

: Bump

: XMLChar

: NotEOF?

: XML ( caddr u -- )
  Context! BEGIN NotEOF? WHILE XMLChar REPEAT ;

--
Samuel A. Falvo II



Thu, 20 Jan 2005 06:16:30 GMT  
 
 [ 42 post ]  Go to page: [1] [2] [3]

 Relevant Pages 

1. Reg Exp Search in Asm?

2. Is // a reg exp?

3. reg exp help needed

4. Reg Exp in awk

5. variables in reg exp repetition

6. Reg-exp library?

7. Newbie Generic Reg Exp Pattern Matching Question

8. Newbie: searching an English dictionary for a reg exp

9. Reg Exp. Problem

10. Reg Exp: Need advice concerning "greediness"

11. Expect reg-exp trouble

12. IA - Satellite Commun Project, sw engr exp., satellite com exp, ADA

 

 
Powered by phpBB® Forum Software