Dear List,

and my thanks to Brett Handley and Keith Devens for helping me out with my
'dynamic append' problem

have no idea if parsing a XML file into a javascript array is very easy for 
other people
working with rebol or languages, but i found it to be rather complicated... 
(individual nodes will be dynamically
appended to a block with names like: arMenu1_1_4_3_3_2, depending on the 
level of the
node within the tree, and depending on the number of childs of the parent 
of the current node which have been parsed
and which are still left in the tree to be parsed... stuff like that )


http://131.211.29.218/index.html
and.. http://131.211.29.218/index2.html (for a different color)

my code is very very dirty at the moment (6kb)
if i have the time, i will clean it up off course

it's idea is to create a javascript file with array's which can be used
by the javascript from www.webreference.com (hierarchical menu's)

comments, ideas for improvements .... please

hendrik-jan bosch
REBOL [
    Title:  "hiermenus.r"
    Date:   27-Jul-2000
    Author: "Hendrik-Jan Bosch"
    Version: 1.2.3
]


;---------------------------------------
xml-language/check-version: func [v][return]
xml: first third parse-xml read http://www.scripting.com/xml/currentOutline.xml
;---------------------------------------
clean: func [B [block!] /local res-B] [
        
        res-B: make block! 10
        foreach elem B [
                either = (type? elem) block!
                                                [append/only res-B clean elem]
                                                [if not = (length? trim copy to-string 
elem) 0 [append res-B elem]]
                        ]
        return res-B
]
;---------------------------------------
xml: clean xml
Q: make block! [1 1]
P: ["document"]
levels: copy ["root"]
arraylist: copy ["root" "arMenu1"]
menuarray: copy []
armenu1: copy []
correction: 1
javascript: ""

;---------------------------------------
basic: func [B [block!] P [block!] /local result] [
;---------------------------------------
either all [(= (length? B) 3) (= (type? B/1) string!)]
[X: "T"] [either (= (length? B) 1)[either (= (type? B/1) string!) [X: "V"] [X: "L"]] [ 
either (= (type? B/1) string!) [X: "A"] [X: "L"] ]]
if (X = "L")[append/only Q length? B append Q length? B append/only P B/1/1]
if (X = "T")[reverse Q if (= (first Q) 0) [ if (= (first Q) 0) [ remove Q remove Q 
reverse P remove P reverse P
if (= (first Q) 0) [ remove Q remove Q reverse P remove P reverse P]]] Q/1: Q/1 - 1 
reverse Q]
;---------------------------------------
if (X = "T")
        [
        if (= (B/1) "outline")
                [
                either any [(find B/2/2 "rule>") (find B/2/2 "rules>") (find B/2/2 
"<textStyle>") (find B/2/2 "<internalLink>")(find B/2/2 "rules>")(find B/2/2 
"<rule") (find B/2/2 "rule level")]
                        [
                        QR: Q
                        LQR: (length? QR) - 2
                        if (= (last QR) 0) [reverse QR remove QR remove QR diff: 
(second QR) - (first QR) reverse QR]
                        ]
                        [
                        if (= (correction) 1)
                                [
                                reverse Q
                                Q/2: Q/2 - diff
                                reverse Q
                                correction: 0
                                ]
                either (= (type? B/3) block!)
                        [
                        currentlevel: to-word last arraylist
                        either (= (last Q) 0)
                                [
                                either (= (last arraylist) "arMenu1")
                                        [
                                        string: rejoin [tab {"}B/2/2{","",1,1,^/}]
                                        ]
                                        [
                                        string: rejoin [tab {"}B/2/2{","",1,1^/}]
                                        ]
                                ]
                                [
                                string: rejoin [tab {"}B/2/2{","",1,1,^/}]
                                ]
                                append (get currentlevel) string
                        ]
                        [
                        currentlevel: to-word last arraylist
                        either (= (last Q) 0)
                                [
                                either (= (last arraylist) "arMenu1")
                                        [
                                        string: rejoin [tab {"}B/2/2{","",0,0,^/}]
                                        ]
                                        [
                                        string: rejoin [tab {"}B/2/2{","",0,0^/}]
                                        ]
                                ]
                                [
                                string: rejoin [tab {"}B/2/2{","",0,0,^/}]
                                ]
                                append (get currentlevel) string
                        if (= (last Q) 0)
                                [
                                currentlevel: to-word last arraylist
                                        either (= (last arraylist) "arMenu1")
                                                [
                                                append javascript rejoin ["^/"last 
arraylist" = [^/"]
                                                append javascript {"",^/}
                                                append javascript {"50","100",^/}
                                                append javascript {"","",^/}
                                                append javascript {"","",^/}
                                                append javascript {"","",^/}
                                                append javascript {true,^/}
                                                append javascript (get currentlevel)
                                                append javascript "]^/"
                                                ]
                                                [
                                                append javascript newline
                                                append javascript rejoin [last 
arraylist" = ["]
                                                append javascript newline
                                                append javascript (get currentlevel)
                                                append javascript "]"
                                                ]
                                reverse levels remove levels reverse levels
                                reverse arraylist remove arraylist reverse arraylist
                                reverse Q
                                if (= (third Q) 0 )
                                        [
                                        currentlevel: to-word last arraylist
                                        either (= (last arraylist) "arMenu1")
                                                [
                                                append javascript rejoin ["^/"last 
arraylist" = [^/"]
                                                append javascript {"",^/}
                                                append javascript {"50","100",^/}
                                                append javascript {"","",^/}
                                                append javascript {"","",^/}
                                                append javascript {"","",^/}
                                                append javascript {true,^/}
                                                append javascript (get currentlevel)
                                                append javascript "]^/"
                                                ]
                                                [
                                                append javascript newline
                                                append javascript rejoin [last 
arraylist" = ["]
                                                append javascript newline
                                                append javascript (get currentlevel)
                                                append javascript "]"
                                                ]
                                        reverse levels remove levels reverse levels
                                        reverse arraylist remove arraylist reverse 
arraylist
                                        ]
                                reverse Q
                                ]
                        ]
                ]
                ]
        ]
if (X = "T")
        [
        if (= (B/1) "outline")
                [
                either any [(find B/2/2 "rule>") (find B/2/2 "rules>") (find B/2/2 
"<textStyle>") (find B/2/2 "<internalLink>")(find B/2/2 "rules>")(find B/2/2 
"<rule") (find B/2/2 "rule level")]
                        []
                        [
                either (= (type? B/3) block!)
                        [
                        reverse arraylist LA: first arraylist reverse arraylist
                        reverse Q NN: (Q/2 - Q/1) reverse Q
                        append/only levels B/2/2
                        append/only arraylist rejoin [LA"_"NN]
                        append/only menuarray rejoin [LA"_"NN": copy []"]
                        do last menuarray
                        ]
                        [
                        reverse arraylist LA: first arraylist reverse arraylist
                        ]
                        ]
                ]
        ]
;---------------------------------------
foreach E B [either = (type? E) block! [basic E P ] [] ]
]
;---------------------------------------
basic xml P 
write %array.js javascript

Reply via email to