Documention for: load-parse-tree.r
Created by: brett
 on: 17-Jun-2006
Last updated by: brett on: 6-Mar-2013
Format: text/editable
Downloaded on: 16-Apr-2024

Load-Parse-Tree

===What is this all about?

It is a function that returns nested blocks and words that represent the structure of your input, based
upon parse rules that you give it.

===How is it useful?

If you have parse rules that validate some input, you can use this function to give you a REBOL representation
of that input, without coding any actions in your parse rules.

---How can you use the output?

*Use it as you would normal REBOL data.

*You could bind the output to functions and reduce the result.

*You could try rewriting the structure with Gabriele Santilli's Rewrite function. For example, parse a
pascal program say, rewriting the structure into executable REBOL code.

===Example

For example, this code:

	; Parse rules
	digit: charset {0123456789}
	hex-digit: charset {0123456789ABCDEF}
	letter: charset [#"a" - #"z" #"A" - #"Z"]
	word: [some letter]
	phrase: [some [word | { }]]
	number: [some digit]
	hex-literal: [#"$" some hex-digit]
	item: [phrase | hex-literal | number | { }]

	; The information we want to appear in the structure.
	structure-terms: [phrase word hex-literal number]

	data: {There were 374 brown foxes and $0001 mottley one.}
	print mold load-parse-stree structure-terms [parse/all data [any item]]

Produces this output:

    [
        phrase [
        word "There"
        word "were"
        ]
        number "374"
        phrase [
        word "brown"
        word "foxes"
        word "and"
        ]
        hex-literal "$0001"
        phrase [
        word "mottley"
        word "one"
        ]
    ]

===How do you use the functions?

*The script starts by calling a function I have set in my REBOL environment called SCRIPT-MANAGER. Here's a simplified stand-in for that function you can
use - just put it in your calling script:

        if not value? 'script-manager [
            script-manager: func ['word /local needs][
                if any [
                    :word <> 'do-needs
                    none? in system/script/header 'needs
                    none? needs: system/script/header/needs
                ][return]
                if not parse needs: compose [(:needs)] [some file!][make error! {Expected a NEEDS block consisting of file!.}]
                foreach [file] needs [do file]
            ]
        ]

*You need the parse-analysis.r in the same directory.


===When will this function not work?

As for the parse-analysis.r functions on which this function is based:

*Standard parse programming rules and even some dynamic parse programming should be fine. Some advanced dynamic parse programming may not work with these functions.

*You might hit an internal recursion limit.

*Obviously a bug could cause an infinite loop - there is a lot of work going on and a few assumptions being made.

Therefore the best use of this script is in an ad-hoc fashion by developers, I'm not sure how it would go as part of production programs.

---What do you mean by dynamic parse programming?

Changing the input or the rules as parse executes. If you have the skills to do this you should be able to work out if you can use this function with your dynamic parse programming.

===About the script author

Brett Handley started programming REBOL early 2000 and maintains a site of REBOL information and scripts at:

=url http://www.codeconscious.com/rebol/ http://www.codeconscious.com/rebol/