xml-dev - Re: <XML:SCRIPT>

["W. Eliot Kimber" <eliot@isogen.com>]

At 09:59 PM 7/8/98, Peter Murray-Rust wrote:

>What automatic mechanism is available for finding a document at the end of:
>	"+//IDN netscape.com//NOTATION JavaScript//EN"
>Is there a set of maintained FPI servers like DNS? Because if not, an FPI
>isn't very useful to me.

You would use the same mechanism you use for SGML normally: some sort of
catalog file, such as the SGML Open catalog, which is supported by all the
SGML tools I use. E.g.:

-- Catalog file --
PUBLIC "+//IDN netscape.com//NOTATION JavaScript//EN"
       "http://www.netscape.com/docs/javascript.html"

XML doesn't specify such a mechanism any more than SGML does, because the
facility is too general. It would be entirely appropriate and useful for
the Web community to define such a mechanism (perhaps by accepting SGML
Open catalogs for this purpose generally--it's certainly a
well-established, widely-implemented convention).

This is identical in function to the MIME mapping file discussed not too
long ago.  You always have to have some sort of local mapping between data
types and the software you want to use to manage them.

Alternatively, you could just use a URL (I use FPIs because I'm an SGML
wonk and because I live in a world that includes more than the Web :-):

<?XML version="1.0"?>
<!DOCTYPE MyDoc [
  <!NOTATION JavaScript SYSTEM
"http://www.netscape.com/docs/javascript.html" >
]>

As Dan C. and TimBL have pointed out, a URL can be just as persistent as a
URN (or FPI) if the maintainer of the resource causes it to be, so there's
no reason not to use it as an identifier if you have confidence in its
persistence.

>>When this document is processed, a processor can see that there is a
>>notation attribute (that is an, attribute whose data type is "NOTATION"; by
>>convention we normally use the attribute name "notation" as well, but
>>that's not required).  It knows by the rules of XML/SGML that the named
>>notation governs the interpretation of the element.  It looks up the
>>notation information and sees the external ID for JavaScript (it must key
>>off the external ID because the notation name JavaScript is a local name
>>and could be anything--you can't depend on authors using the string
>>"JavaScript", even though most will).  
>
>Agreed. Is there a generally agreed way of writing portable code to do this? 

It's just a lookup table where the left hand side is whatever part of the
external ID for the notation you have or prefer (if you have both a public
and system identifier). I'm not sure what you mean by "portable". 

>>It sees that there is a dll function or plug in or module or COM object or
>>JavaBean associated with that name and passes the element to it (presumably
>
>How does it do this (algorithmically)? This is the key question to which I
>have been trying to get an answer - (although I want Java classes rather
>than *.COM or *.dll which are platform-dependent). 

Again it's a lookup table. In PHyLIS (www.phylis.com), I have code that
registers ActiveX controls by the public ID or notation name (as a backup)
for the notations they can operate on. The registration function just
builds a lookup table that can resolve a string to a pointer to an ActiveX
object. To call the right processor, I use the notation information to look
up the processor and call the appropriate method of the object at the end
of the pointer.  Should work the same way in a Java context.

>The advantage of MIME types is that there is a well-defined mechanism in
>current software for associating MIME types with software. 

I think you need to qualify this statement--I use a lot of software that
does not have any MIME awareness.  It may be the case that Web-specific or
Web-aware tools do, but that's not all tools.

                                                           AFAIK there is
>no generally agreed and implemented mechanism for associating FPIs with
>software. 

I don't think it's an issue of associating FPIs with software, it's an
issue of associating notations with software. You could probably use the
existing MIME mechanism by treating the notation external ID as a MIME type
(assuming the software doesn't enforce some sort of syntactic constraints
on MIME types, which I can't see any point in, as they're just identifiers).

In any case, I'm not sure it's a fair question because the only generalized
XML tools I'm aware of are either parsers, which wouldn't do this anyway
(it's not their job) or SGML applications that already have such a
mechanism. I don't know of any general-purpose XML-only applications in
which this would be relevant (either because it's something they just
wouldn't do by the nature of their purpose or because they're not
sufficiently general).

Certainly PHyLIS stands as a minimal example of how it might done. Because
I wrote it in VB, it fails your platform independent requirement, but if I
rewrote it in Java, it would meet all your requirements.

If somebody wanted to write the two-page spec for the mechanism, I'd be
happy to learn Java sufficient to write a reference implementation.

Cheers,

E.
--
<Address HyTime=bibloc>
W. Eliot Kimber, Senior Consulting SGML Engineer
ISOGEN International Corp.
2200 N. Lamar St., Suite 230, Dallas, TX 75202.  214.953.0004
www.isogen.com
</Address>

xml-dev: A list for W3C XML Developers. To post, mailto:xml-dev@ic.ac.uk
Archived as: http://www.lists.ic.ac.uk/hypermail/xml-dev/
To (un)subscribe, mailto:majordomo@ic.ac.uk the following message;
(un)subscribe xml-dev
To subscribe to the digests, mailto:majordomo@ic.ac.uk the following message;
subscribe xml-dev-digest
List coordinator, Henry Rzepa (mailto:rzepa@ic.ac.uk)