World: r3wp

and you can easily separate attributes from elements, just by affecting 
them to different types.

Although the XML I'm dealing with doesn't have duplicate elements.

Or name spaces

Have you posted your modifications anywhere??

the most stable engine I built which accepted all xml possibilities 
ended loading xml like so:


[ <element> [<subelement> [#attribute  "attr-value" . "subelement 
content"]]]

the .  is assigned the value of the elements. 

the above would result from the following XML:
<element>
	<subelement attribute="attr-value">
		subelement content
	</subelement>
</element>

And you can access it this way:

document/<element>/<subelement>/#attribute
document/<element>/<subelement>/.

I find working with objects much easier though ...

I guess the duplicate elements could be solved by using blocks for 
them

I've never posted that specific version cause it was closed source 
for a client.   but I have my own new engine, which does the same, 
but attacking the parse rules directly... its probably faster.
I've not released it.

Really? I went positional: ["element" "namespace" ["attribute" "value"] 
["subelement" ...] "text" ...]

with missing namespace or attribute block being #[none], so defaults 
can be done with ANY.

Using tags looks ugly :)

note that in the above, you can replace types within so it could 
be words instead of tags.

My positional version handles multiple subelements of the same type, 
and using strings rather than words lets you use tags that don't 
match word syntax or are case=sensitive.

its just that in my tests, either you can create, read or set some 
of the datatypes via path notation.  so only string based types allow 
full XML qualification.

hahaha

XML can be case sensitive??

but brian, how do you acess it?

by position!

XML *is* case-sensitive. Your paths can't access multiple subelements 
of the same type, or embedded text.

I wrote a simple xpath compiler too (but don't know where it is now).

I wanted direct access to all elements within rebol.

Looks like we need an article on best practices here ...

a later version, using schema validation, understands multiple subelements 
and automatically converts them to blocks IIRC.

so you do document/element/3/subelement/#attribute.

Your paths can't access multiple subelements of the same type, or 
embedded text. It might have worked for that customer but not the 
general case. No namespace support either.

my paths.. namespace works... for sure.  did you know you can have 
colon in word names in R2 !   but i didn;t use that, I just used 
tags directly.  more obvious than strings, and the exact same effort 
and speed.

I was parsing xhtml and other XML of the like. Subelements of mixed 
types in order with text between them than mattered.

my engine does support embedded types, but ignored it by default... 
it was also byte reversible... a loaded xml block loaded through 
the engine was saved back exactly, byte for byte, checksum proofed.

oops.. embedded text I mean.

but all of that is not open source.

And mine is lost :(

my newer version doesn't have the schema validation process.... that 
is a very complex engine to build.   schemas and Parse traversal 
do not follow the same algorythm... so its a bitch to implement.

anyhow... the xml tools I currently have are not yet tested enough 
to be release ready.

Ok, so we have established that everyone does it their own way :)

but the rebxml tools (on rebol.org) as-is are very usefull, so some 
utf-8 support and are less buggy than rebelXML in my previous tests.

rebelxml gets confused if there is more than one path with the same 
name

it accepts the first one it finds

even if the full path is specified.

I suspect the author is no longer reboling

I remeber it also tripping on some of the XML files I gave it... 
don't remember the problems... but its error handling /recovery was 
very shaky IIRC.

You should add a comment to the discussion page if you remember.

as should i.

read above,  I don't  ;-)

at this time .. it may come back to you

that's why I said "if" ...

Using objects means i can store the functions that initialize it 
inside the object.

Not a good idea for data objects, which could number in the thousands, 
each with their own bound copy of the functions.

yes, the best method is to have some form of dtd or schema, and use 
class-based objects.

Class-based objects are emulated in REBOL.

the init is a context with one function, to which you supply the 
outer (instance) which holds the data:

my-tag: context [
	data: "tototo"
	attribute-1: "red"
	class: context [
		init: func [instance][
			instance/data: copy ""
			instance/attribute-1:  copy "blue"
		]
	]
]

to init the an instance of my-tag:

new-tag: make my-tag [class/init self]