World: r3wp

I agree.

hi,  yesterday I realized I have a 1400 line single parse ruleset 
 which amounts to ~40kb of code !   :-)  I was wondering what are 
your largest Parse rulesets,  I'm just curious at how people here 
are pushing REBOL into extremes.


I might also say that parse is wildly efficient in this case, allowing 
my server to decipher 600 bytes of binary data through all of this 
huge parse rule within 0.01 - 0.02 seconds (spitting out a nested 
rebol block tree of  rebxml2xml ready data).

to anyone not yet accustomed to 'PARSE, really do take the time to 
look it through and use it.

when working so extensively with Parse, you migt try to write down 
your enhancement/fixes proposal and submit it to R3 team :-)

The one real limitation I always saw which makes some rules harder 
to write for nothing  is the first-of-any  search (to and through)

and THE MOST PROFOUND limitiation... why the hell is 'NOT within 
the dialect?

50% of the time its easier to match something which is not and then 
within that choice select something which is.

like bounds checking, making sure some items are not within a specific 
area, etc.

My largest Parse rulesets are in NicomDoc. The scripts nicomdoc.r 
and ndmath.r parse from text to rebxml format. They are 20k and 24k. 
ndrebxml2html.r parse from NicomDoc rebxml format til html, and that 
is a 28k script mostly parse rules. I once build a html dialect, 
and that was 24k.

And yes, parse is a great tool!

The html dialect can be found on the View desktop under REBOL/Public/Sites/Nicom/

Max complement charset  ...  can often be used as a sort of NOT

true, but that does not match many cases. obviously one can built 
NOT-A NOT-B and so one.. but man.. that gets tedious, which is not 
what parse should be.

I'm pretty sure my biggest parser so far is the one for Qtask's iCal 
importer: ~75K, ~2,900 lines. It's growing right now, to support 
recurrence rules and timezones.

I didn't write the whole thing manually though. I bootstrapped it 
by writing an ABNF parser, marking up the RFC spec, and generating 
as much as I could from that.

And don't forget to take a look at Gab's compile-rule function.

what does Gabriele's compile-rule function do ?

It's an extension to PARSE so you can use things like IF etc. in 
parse rules.

Sounds useful.

VERY useful... several times I've wanted something like that, but 
wasn't experienced enough in parse to figure something easy out...

why default parse is not extended in native level to support such 
constructs as IF, to-first, thru first, etc., if many ppl find them 
usefull?

lad, maybe, but if you change the name of the variable to copy to 
you have then to change it twice in the rule.

 - right. That is a general problem of procedural programming style. 
 OTOH, the "opt skip" variant has got another problem - the "opt skip" 
 code is related only to the first alternative, which seems to me 
 like the reason why Joe doesn't like it

and where is the compile-rule func?  on rebol.org?

have a look at: http://www.compkarori.com/vanilla/display/compile-rules.r

my contribution is at: http://www.compkarori.com/vanilla/display/TO%2C+THRU+And+NOT+PARSE+Rules

oh dear .. vanilla has died on me.  I get server error ...

strange, it works for me

still?

yes

I get server error still.

now that is bizarre!

unless the cookie is corrupting it somehow.

must be .. just tried IE and it works fine.

I am using Firefox 2.0.0.1

Me too .. but it must be a vanilla problem. Are you logged in when 
you read the page, or as guest?

strange - I was logged in originally, but am not now, without logging 
out...

...and I am unable to login

guess my vanilla instance is dying ...

or, I have run out of server space and so all my scripts are dying 
...

most up to date version: http://www.colellachiara.com/soft/PDFM2/compile-rules.r

thanks.

Isn't this a bug?

>> b: "1234^@567" parse/all b [copy i to {^@} 1 skip b: to end] probe 
i probe b
1234
567

BUT:

>> b: "1234^@567" parse/all b [copy i to #{00} 1 skip b: to end] 
probe i probe b
1234
1234^@567

Ah... my fault, parse is not supporting binary format:(

I wish it did too.  it would make some things simple a little bit.

>> b: "1234^@567" parse/all b [copy i to "^(0)" 1 skip b: to end]
== true
>> i
== "1234"

notperfect, but a way to use numbers

how to parse such a string:
   {some.string/(a + (b.a * c()))/end} 
to get:
   ["some" "string" "(a + (b.a * c()))" "end"]

where the 'slash' can be in the paren as well (so I cannot use just 
parse str "/")

here is a full script  :-) 


rebol []

paren-start: charset "("
paren-end: charset ")"
parens: union paren-start paren-end

separator: charset [#"/" #"."]
label: complement union separator parens

content: complement parens
blk: copy []

str: {some.string/(a + 1 / 2 (b.a * c()))/end}

expression: [paren-start  any [content | expression] paren-end]

parse/all str [some [ separator | here: some [label] there:  (append 
blk copy/part here there) | here:   expression there: (append blk 
copy/part here there)]]


probe blk


ask "..."

Thank you Maxim:-]

IIRC someone created an inference motor using parse, unfortunalty 
i'm unable to recover the sources, someone can help me ?