eu.bandm.tools.d2d2.base

Class Dtd2Def

java.lang.Object

eu.bandm.tools.d2d2.base.Dtd2Def

public class Dtd2Def
extends Object

Simple dtd to d2d2 module converter, returns an instantiated Module (FIXME change to ResolvedModule !!) or null in case of error.
Usage: Create an instance (always anew, no re-usage) and call convert(MessageReceiver,DTD.Dtd,String).

Currently called by the ModuleRegistry, when a file (or resource) with ".dtd" is found relevant as a text format governor, and by Main directly when "task==dtd2def", because error handling is slightly different.

This code works on the DTM model of a dtd. It accepts a dtd in two cases

1. No single name contains a colon character.
2. Otherwise: No single name contains more than one(1) colon character. The pre-colon parts are considered namespace prefices. All occuring namespace prefices p are declared by a <?tdom xmlns:p="name_space_uri" ?> declaration. These declarations have the whole dtd (incl. all inclusions) as their scope, and do not conflict.

In the second mode, we need dis-ambiguation w.r.t. tags and w.r.t. names. In THIS approach BOTH is done by MANGLING:

       xml:lang   --> xml_lang or xml_0_lang or xml_1_lang etc.
 

Currently, the "namespace" declarations on the ddf-module-level are indeed reconstructed, but they are not needed since explicit "xmlrep" modifiers are added to each constructed definition.

A different approach would generate local modules and import them again, but this would only avoid clashes of definition names, not of input tags!

=?? FIXME RAUS?? WAS SOLL DAS: Additionally, all namespace prefices which are linked to the default namespace uri are reduced to this default, ie. eliminated as a prefix.

What is done, is

1. create top-level tags-parser for every element
2. create one top-level dummy definition as container for local definitions for attributes.
3. create a global attribute definition in this global container, if this is possible without a name clash.
4. otherwise create a local definition.
5. if the attribute's tag conflicts with the tag of a child element in the "first set" of the element's content model, than disambiguate by adding some prefix to the attribute's name to create an unambiguous tag.

   There are some proposals for a more sophisticated treatment of attributes in the old d2d or java-tools version. These should be considered in future versions, because LATER we should support

   1. sharing of content models given by entities
   2. sharing of attribute definitions
   3. mapping enumeration type attributes to d2d enumerations
   4. mapping nmtoken attributes to corresponding character parsers
   FIXME mode suppressFragmentedAttlistWarning FIXME replaceDotCharacterBy "-" "_" ??? FIXME The local part of a NamespaceName may contain dot (='.') or "CombiningChar" or "Extender". Then it can currently not be mapped to a d2d identifier, which must adhere to

     ('A'..'Z'|'a'..'z')  (   ('a'..'z')|('A'..'Z')|('0'..'9') | '_' | '-' )* ;
     

   see file d2d2/parser/d2d.g

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
protected class	Dtd2Def.Phase1

Field Summary

Fields

Modifier and Type	Field and Description
protected TagsRegExp	attContainer
protected @Opt String	defaultNamespaceURI
protected Map<NamespaceName,String>	dtdname2ddfname
protected MessageReceiver<SimpleMessage<XMLDocumentIdentifier>>	msg
protected MessageCounter<SimpleMessage<XMLDocumentIdentifier>>	msgCounter
protected Map<String,String>	namespacePrefices
protected boolean	namespacesDeclared
protected Module	result
protected TagsRegExp	targetEl

Constructor Summary

Constructors

Constructor and Description
Dtd2Def()

Method Summary

Modifier and Type	Method and Description
protected boolean	checkName(String s, Location<XMLDocumentIdentifier> elloc) Checks that not illegal characters are in the name of the ddf definition to create.
@Opt Module	convert(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> p_msg, DTD.Dtd input_dtd, String name) Convert one DTD.Dtd to a ddf module.
protected void	makeElementNameTranslations_namespaceMode(DTM.Dtd dtd) Make element name translation map.
protected void	makeElementNameTranslations_nonNamespaceMode(DTM.Dtd dtd)
protected void	mapNames(NamespaceName nn, String s, Location<XMLDocumentIdentifier> elloc) Maps the dtd NamespaceName to an internal element name, after checking that not illegal characters are in the latter by calling checkName(String, Location).
protected boolean	tryMangle(NamespaceName nn, String name, Location<XMLDocumentIdentifier> elloc) If the name is already used, return false.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Detail

msg

protected MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> msg

msgCounter

protected MessageCounter<SimpleMessage<XMLDocumentIdentifier>> msgCounter

result

protected Module result

attContainer

protected TagsRegExp attContainer

namespacePrefices

protected final Map<String,String> namespacePrefices

defaultNamespaceURI

@Opt
protected @Opt String defaultNamespaceURI

dtdname2ddfname

protected final Map<NamespaceName,String> dtdname2ddfname

namespacesDeclared

protected boolean namespacesDeclared

targetEl

protected TagsRegExp targetEl

Constructor Detail

Dtd2Def

public Dtd2Def()

Method Detail

convert

@Opt
public @Opt Module convert(MessageReceiver<SimpleMessage<XMLDocumentIdentifier>> p_msg,
                                DTD.Dtd input_dtd,
                                String name)

Convert one DTD.Dtd to a ddf module.

1. Decide whether we are in namespace mode by collecting the corresponding tdom pi-s.
2. Convert the DTD.Dtd to a DTM.Dtd, which may fail.
3. Create a translation table for all namespace names in the Dtd.
4. Visit all elements and translate their content model and attribute declaratiosn.

Parameters:

name - the name for the ddf definition module to create

checkName

protected boolean checkName(String s,
                            Location<XMLDocumentIdentifier> elloc)

Checks that not illegal characters are in the name of the ddf definition to create. An d2d ident must follow the grammar ('A'..'Z'|'a'..'z') ( ('a'..'z')|('A'..'Z')|('0'..'9')| '_' | '-' )*. "Extender" characters allowed in XML tags are detected, and colons not removed because namespace mode has not been declared by PIs.

Parameters:

s - the name for the constructed ddf definition

elloc - the location of the source element declaration, for error messages.

mapNames

protected void mapNames(NamespaceName nn,
                        String s,
                        Location<XMLDocumentIdentifier> elloc)

Maps the dtd NamespaceName to an internal element name, after checking that not illegal characters are in the latter by calling checkName(String, Location).

Parameters:

nn - the name as occuring in the dtd

s - the name as occuring in the constructed ddf

elloc - the location of the source element declaration, for error messages.

tryMangle

protected boolean tryMangle(NamespaceName nn,
                            String name,
                            Location<XMLDocumentIdentifier> elloc)

If the name is already used, return false. Then the caller can try a different disambiguation mangling. Otherwise store it as a counterpart of the namespace name. Only called locally from makeElementNameTranslations_namespaceMode.
FIXME mode "prefixIffNecessary".

makeElementNameTranslations_namespaceMode

protected void makeElementNameTranslations_namespaceMode(DTM.Dtd dtd)

Make element name translation map. First add all names without uri (non-namespace name) and with the uri selected as default (no prefix) as one-to-one. Afterwards mangle all those with different uris, using the prefices as hint for disambiguation mangling.

ASSUME that a prefix carries semantics, namely refers to the mapping which was in effect when reading the dtd! (Normally we ignore "prefix" and consider only uri and localName!)

makeElementNameTranslations_nonNamespaceMode

protected void makeElementNameTranslations_nonNamespaceMode(DTM.Dtd dtd)