"Sean B. Palmer" wrote:
> Murray Altheim <>
> > We could add a empty parameter entity to allow it to be
> > extended in a document's internal subset for custom or
> > development use, [...]
> >    <!ENTITY % Metadata.ext "">
> >    <!ATTLIST  metadata
> >        type  NOTATION  (dc|rdf|blat %Metadata.ext;)
> >    >
> Hmm... you've done this before, haven't you :-) That's very neat
> indeed. So I could declare something like:-

Yup. For some reason this markup stuff and my brain seem to get along
pretty well. Wish I could translate a bit of this expertise into being
a better musician or getting my laundry done on time...

>    <!NOTATION n3
>      PUBLIC "-//W3C//NOTATION Notation3//EN""
>      "">
>    <!ENTITY % Metadata.ext "| n3" >
> To add Notation3 to the element as a notation (er... it's a bit
> confusing that I'm using Notation3 as an SGML notation here). Still
> putting information like that in the schema (lower case "s") still
> seems odd to someone that likes to make first party assertinos in the
> documents conformaing to the schemas... e.g. with namespaces, and type
> attributes, and so on. I could get used to it though!

As I responded to Jonathan, don't worry about NOTATION declarations in
this sense. They use an ExternalId production, so they point to things
just like any other XML production. The only difference is that the
SystemLiteral is optional, which in our case is less than useful. We
want to provide merely a canonical identifier for a notation. We still
need to provide the application with the notation processor, which doesn't
happen via this mechanism. The NOTATION declaration merely declares what
people would now call a "namespace identifier", so that other applications
can likewise identify the same notation, such as GIF89A vs. GIF, JPEG,
MPEG, etc.

> > Then, as I mentioned above, the CDATA section DOM node
> > [...] would be passed off to processor which would strip off the
> > CDATA section wrapper and pass it to another XML parser
> > process, which would first well-formedness check it before
> > sending it off to the RDF processor.
> The trouble I see here is that the processor relies upon getting a
> correct list of notation types from the DTD, and being able to
> understand and grok the FPIs and system identifiers. Does that
> actually work in practise?

As I said above, the FPIs and SystemLiterals are only used to identify
the notations. The application still needs a way (once it's recognized
that it'll have to process a specific notation) to process each datatype.
I think "notation" and "datatype" are synonyms for our purposes, since
we're using higher level concepts of datatypes (eg., rather than an int).

> > [...] I do maintain that the solution I've described above is likely
> > unpalatable to the W3C. I'd be happy to be shown wrong, though.
> Well, I hope you will be too. I'm not all that certian about the state
> of play of notations in the current XML architecture, but you seem to
> outline that making something like the above possible in XHTML would
> require a major structural change to XML itself - am I correct? In
> that case, I wouldn't be all that optimistic.

Maybe we can sell everyone on the idea that notations are merely 
monikers for datatypes. The key here is that a properly-written XML
parser will provide the list of declared notations, and hopefully
tag unparsed entities and DOM nodes with the notations they've been
identified as their type. This makes the application designer's 
task merely of assigning processors to well known notations,
watching across the API for nodes or entities having those notations,
and then sending the content on to the notation/datatype processor.
Our task is to canonicalize identifiers for notations we're interested
in, and promote the processing solution. I think Xerces could probably
already do its part, for example, though I've never tried this on it.


Murray Altheim                            <mailto:altheim&#x40;>
XML Technology Center
Sun Microsystems, Inc., MS MPK17-102, 1601 Willow Rd., Menlo Park, CA 94025

      In the evening
      The rice leaves in the garden
      Rustle in the autumn wind
      That blows through my reed hut.  -- Minamoto no Tsunenobu

Received on Wednesday, 18 April 2001 04:54:45 UTC