The "include" element is only supported with MSXSL and SAXON.
jing-trang-20181222+dfsg2/convert/from-trex.xsl 0000664 0000000 0000000 00000004475 13520105541 0021157 0 ustar 00root root 0000000 0000000
http://www.w3.org/2001/XMLSchema-datatypesinterleave
jing-trang-20181222+dfsg2/convert/simplify.xsl 0000664 0000000 0000000 00000001433 13520105541 0021057 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/copying.html 0000664 0000000 0000000 00000003360 13520105541 0017352 0 ustar 00root root 0000000 0000000
Jing Copying Conditions
Jing Copying Conditions
Copyright (c) 2001-2003 Thai Open Source Software Center Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
Neither the name of the Thai Open Source Software Center Ltd nor
the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
jing-trang-20181222+dfsg2/copying.txt 0000664 0000000 0000000 00000003021 13520105541 0017217 0 ustar 00root root 0000000 0000000 Copyright (c) 2001-2003 Thai Open Source Software Center Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
Neither the name of the Thai Open Source Software Center Ltd nor
the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
jing-trang-20181222+dfsg2/datatype-sample/ 0000775 0000000 0000000 00000000000 13520105541 0020104 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/build.xml 0000664 0000000 0000000 00000001135 13520105541 0021725 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/datatype-sample/datatype-sample.rng 0000664 0000000 0000000 00000000307 13520105541 0023706 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/datatype-sample/index.html 0000664 0000000 0000000 00000003177 13520105541 0022111 0 ustar 00root root 0000000 0000000
RELAX NG Pluggable Datatype Library Example
RELAX NG Pluggable Datatype Library Example
This package contains a very simple example of a pluggable datatype library.
The datatype library is implemented by the class
com.thaiopensource.datatype.sample.BalancedString. The
bulk of the implementation is inherited from the abstract class
com.thaiopensource.datatype.sample.SimpleDatatypeLibrary,
which provides default implementations for the methods in the
interfaces which a datatype library must implement. A class that
derives from SimpleDatatypeLibrary has only to implement
a boolean isValid(String literal) method. The datatype
library has the URI
http://www.thaiopensource.com/relaxng/datatypes/sample,
and contains exactly one datatype, which is called
balancedString. This datatype allows any string in which
parentheses are properly balanced (nested). To use this sample
datatype library, simply include datatype-sample.jar in
your CLASSPATH. You will then be able to validate against schemas
using this additional datatype. The file datatype-sample.rng is a simple RELAX
NG schema using this datatype; valid.xml is an
instance that is valid with respect to this schema; invalid.xml is an instance that is not valid
with respect to this schema.
James Clark
jing-trang-20181222+dfsg2/datatype-sample/invalid.xml 0000664 0000000 0000000 00000000056 13520105541 0022255 0 ustar 00root root 0000000 0000000 foo(bar(baz)
jing-trang-20181222+dfsg2/datatype-sample/src/ 0000775 0000000 0000000 00000000000 13520105541 0020673 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/META-INF/ 0000775 0000000 0000000 00000000000 13520105541 0022033 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/META-INF/services/ 0000775 0000000 0000000 00000000000 13520105541 0023656 5 ustar 00root root 0000000 0000000 org.relaxng.datatype.DatatypeLibraryFactory 0000664 0000000 0000000 00000000062 13520105541 0034207 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/META-INF/services com.thaiopensource.datatype.sample.BalancedString
jing-trang-20181222+dfsg2/datatype-sample/src/com/ 0000775 0000000 0000000 00000000000 13520105541 0021451 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0024501 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/com/thaiopensource/datatype/ 0000775 0000000 0000000 00000000000 13520105541 0026314 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/com/thaiopensource/datatype/sample/ 0000775 0000000 0000000 00000000000 13520105541 0027575 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/com/thaiopensource/datatype/sample/BalancedString.java0000664 0000000 0000000 00000001270 13520105541 0033320 0 ustar 00root root 0000000 0000000 package com.thaiopensource.datatype.sample;
public class BalancedString extends SimpleDatatypeLibrary {
private static final String DATATYPE_LIBRARY
= "http://www.thaiopensource.com/relaxng/datatypes/sample";
private static final String TYPE = "balancedString";
public BalancedString() {
super(DATATYPE_LIBRARY, TYPE);
System.err.println("Loaded balanced string");
}
protected boolean isValid(String literal) {
int len = literal.length();
int level = 0;
for (int i = 0; i < len; i++) {
switch (literal.charAt(i)) {
case '(':
++level;
break;
case ')':
if (--level < 0)
return false;
break;
}
}
return level == 0;
}
}
SimpleDatatypeLibrary.java 0000664 0000000 0000000 00000003757 13520105541 0034647 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/datatype-sample/src/com/thaiopensource/datatype/sample package com.thaiopensource.datatype.sample;
import org.relaxng.datatype.*;
import org.relaxng.datatype.helpers.ParameterlessDatatypeBuilder;
import org.relaxng.datatype.helpers.StreamingValidatorImpl;
public abstract class SimpleDatatypeLibrary implements Datatype,
DatatypeLibrary,
DatatypeLibraryFactory {
private final String uri;
private final String localName;
private final DatatypeBuilder datatypeBuilder;
protected SimpleDatatypeLibrary(String uri, String localName) {
this.uri = uri;
this.localName = localName;
this.datatypeBuilder = new ParameterlessDatatypeBuilder(this);
}
public DatatypeLibrary createDatatypeLibrary(String uri) {
return this.uri.equals(uri) ? this : null;
}
public DatatypeBuilder createDatatypeBuilder(String localName)
throws DatatypeException {
if (!this.localName.equals(localName))
throw new DatatypeException();
return datatypeBuilder;
}
public Datatype createDatatype(String localName)
throws DatatypeException {
return createDatatypeBuilder(localName).createDatatype();
}
protected abstract boolean isValid(String literal);
public void checkValid(String literal, ValidationContext context)
throws DatatypeException {
if (!isValid(literal, context))
throw new DatatypeException();
}
public boolean isValid(String literal, ValidationContext context) {
return isValid(literal);
}
public DatatypeStreamingValidator createStreamingValidator(ValidationContext context) {
return new StreamingValidatorImpl(this, context);
}
public Object createValue(String literal, ValidationContext context) {
if (!isValid(literal, context))
return null;
return literal;
}
public boolean sameValue(Object obj1, Object obj2) {
return obj1.equals(obj2);
}
public int valueHashCode(Object obj) {
return obj.hashCode();
}
public int getIdType() {
return ID_TYPE_NULL;
}
public boolean isContextDependent() {
return false;
}
}
jing-trang-20181222+dfsg2/datatype-sample/valid.xml 0000664 0000000 0000000 00000000057 13520105541 0021727 0 ustar 00root root 0000000 0000000 foo(bar(baz))
jing-trang-20181222+dfsg2/doc/ 0000775 0000000 0000000 00000000000 13520105541 0015557 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/doc/README.md 0000664 0000000 0000000 00000000344 13520105541 0017037 0 ustar 00root root 0000000 0000000 # Moved
On 2 December, 2018, these files were moved to the website repository:
> https://github.com/relaxng/relaxng.org
where they appear under the `/jclark/` directory. The are also available
at https://relaxng.org/jclark/
jing-trang-20181222+dfsg2/dtdinst/ 0000775 0000000 0000000 00000000000 13520105541 0016463 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/dtdinst/copying.txt 0000664 0000000 0000000 00000003021 13520105541 0020670 0 ustar 00root root 0000000 0000000 Copyright (c) 2001-2003 Thai Open Source Software Center Ltd
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are
met:
Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
Neither the name of the Thai Open Source Software Center Ltd nor
the names of its contributors may be used to endorse or promote
products derived from this software without specific prior written
permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
jing-trang-20181222+dfsg2/dtdinst/dtdinst.rnc 0000664 0000000 0000000 00000005726 13520105541 0020652 0 ustar 00root root 0000000 0000000 datatypes xsd = "http://www.w3.org/2001/XMLSchema-datatypes"
start = element doctype { decl* }
decl =
elementDecl
| attlistDecl
| def
| overriddenDef
| externalIdRef
| includedSection
| ignoredSection
| internalEntityDecl
| externalEntityDecl
| notationDecl
| processingInstruction
| comment
def =
modelGroupDef
| attributeGroupDef
| enumGroupDef
| datatypeDef
| attributeDefaultDef
| flagDef
| nameSpecDef
| externalIdDef
| paramDef
elementDecl = element element { nameSpec, modelGroup }
modelGroupDef = element modelGroup { name, modelGroup }
datatypeDef = element datatype { name, datatype }
attributeDefaultDef = element attributeDefault { name, attributeDefault }
flagDef = element flag { name, flag }
nameSpecDef = element nameSpec { name, nameSpec }
externalIdDef = element externalId { name, externalId }
paramDef = element param { name, text }
overriddenDef = element overridden { def | duplicateDef }
duplicateDef = element duplicate { name }
includedSection =
element includedSection { attribute flag { xsd:NCName }?, decl* }
ignoredSection =
element ignoredSection { attribute flag { xsd:NCName }?, text }
externalIdRef = element externalIdRef { name, decl* }
internalEntityDecl = element internalEntity { name, text }
externalEntityDecl = element externalEntity { name, externalId }
notationDecl = element notation { name, externalId }
processingInstruction =
element processingInstruction { attribute target { xsd:NCName }, text }
comment = element comment { text }
datatype =
element tokenized {
attribute name { "NMTOKEN" | "NMTOKENS"
| "ENTITY" | "ENTITIES"
| "ID" | "IDREF" | "IDREFS" }
| (attribute name { "NOTATION" }?, enumGroup)
}
| element cdata { empty }
| element datatypeRef { name }
enumGroup =
(element enum { xsd:NMTOKEN }
| element enumGroupRef { name } )*
enumGroupDef = element enumGroup { name, enumGroup }
flag =
element include { empty }
| element ignore { empty }
| element flagRef { name }
attlistDecl = element attlist { nameSpec, attributeGroup }
attributeGroupDef = element attributeGroup { name, attributeGroup }
attributeGroup =
(element attribute { nameSpec, datatype, attributeDefault }
| element attributeGroupRef { name } )*
attributeDefault =
element implied { empty }
| element required { empty }
| element default|fixed { text }
| element attributeDefaultRef { name }
modelGroup =
element modelGroupRef { name }
| element elementRef { nameSpec }
| element oneOrMore { modelGroup }
| element zeroOrMore { modelGroup }
| element optional { modelGroup }
| element pcdata { empty }
| element choice { (modelGroup, modelGroup+)? }
| element sequence { (modelGroup, modelGroup+)? }
externalId =
attribute system { xsd:anyURI }?,
attribute public { text }?,
attribute xml:base { xsd:anyURI }?
name = attribute name { xsd:NCName }
nameSpec = element name { xsd:Name } | element nameSpecRef { name }
jing-trang-20181222+dfsg2/dtdinst/dtdinst2rng.xsl 0000664 0000000 0000000 00000012643 13520105541 0021463 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/ 0000775 0000000 0000000 00000000000 13520105541 0020116 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/dtdinst/example/attributeDefault.dtd 0000664 0000000 0000000 00000000302 13520105541 0024116 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/attributeDefault.xml 0000664 0000000 0000000 00000001537 13520105541 0024156 0 ustar 00root root 0000000 0000000
securitydivparadivparadivpara
jing-trang-20181222+dfsg2/dtdinst/example/attributeGroup.dtd 0000664 0000000 0000000 00000000311 13520105541 0023626 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/attributeGroup.xml 0000664 0000000 0000000 00000001421 13520105541 0023656 0 ustar 00root root 0000000 0000000
idclassfoobarfoobarbar
jing-trang-20181222+dfsg2/dtdinst/example/datatype.dtd 0000664 0000000 0000000 00000000176 13520105541 0022432 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/datatype.xml 0000664 0000000 0000000 00000000704 13520105541 0022454 0 ustar 00root root 0000000 0000000
holidayholidaystartDateendDate
jing-trang-20181222+dfsg2/dtdinst/example/enumGroup.dtd 0000664 0000000 0000000 00000000250 13520105541 0022571 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/enumGroup.xml 0000664 0000000 0000000 00000001153 13520105541 0022621 0 ustar 00root root 0000000 0000000
JPTHUKFRITemployeeemployeecountry
jing-trang-20181222+dfsg2/dtdinst/example/externalId.dtd 0000664 0000000 0000000 00000000062 13520105541 0022710 0 ustar 00root root 0000000 0000000
%decls;
jing-trang-20181222+dfsg2/dtdinst/example/externalId.ent 0000664 0000000 0000000 00000000025 13520105541 0022722 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/externalId.xml 0000664 0000000 0000000 00000000351 13520105541 0022736 0 ustar 00root root 0000000 0000000
doc
jing-trang-20181222+dfsg2/dtdinst/example/flag.dtd 0000664 0000000 0000000 00000000256 13520105541 0021527 0 ustar 00root root 0000000 0000000
]]>
jing-trang-20181222+dfsg2/dtdinst/example/flag.xml 0000664 0000000 0000000 00000001312 13520105541 0021546 0 ustar 00root root 0000000 0000000
bigsmallemparaembigsmall
jing-trang-20181222+dfsg2/dtdinst/example/modelGroup.dtd 0000664 0000000 0000000 00000000227 13520105541 0022731 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/modelGroup.xml 0000664 0000000 0000000 00000001250 13520105541 0022753 0 ustar 00root root 0000000 0000000
codeemparacodeem
jing-trang-20181222+dfsg2/dtdinst/example/nameSpec.dtd 0000664 0000000 0000000 00000000201 13520105541 0022337 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/nameSpec.xml 0000664 0000000 0000000 00000000751 13520105541 0022376 0 ustar 00root root 0000000 0000000
paraem
jing-trang-20181222+dfsg2/dtdinst/example/overridden.dtd 0000664 0000000 0000000 00000000366 13520105541 0022761 0 ustar 00root root 0000000 0000000
]]>
jing-trang-20181222+dfsg2/dtdinst/example/overridden.xml 0000664 0000000 0000000 00000001722 13520105541 0023003 0 ustar 00root root 0000000 0000000
bigsmallemembigsmallempara
jing-trang-20181222+dfsg2/dtdinst/example/param.dtd 0000664 0000000 0000000 00000000051 13520105541 0021707 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/dtdinst/example/param.xml 0000664 0000000 0000000 00000000234 13520105541 0021737 0 ustar 00root root 0000000 0000000
EMPTY
EMPTY
jing-trang-20181222+dfsg2/dtdinst/index.html 0000664 0000000 0000000 00000020474 13520105541 0020467 0 ustar 00root root 0000000 0000000
DTDinst
DTDinst is a program for converting XML DTDs into an XML instance
format.
Previous versions of DTDinst could also convert XML DTDs into RELAX
NG. This functionality has now migrated
into Trang, which now shares the DTDinst code.
The key feature of DTDinst is its handling of parameter entities.
It is able to reliably turn parameter entity declarations and
references into a variety of higher-level
semantic constructs. It can do this even in the presence of
arbitrarily deep nesting of parameter entity references within
parameter entity declarations. At the same time, it accurately
follows XML 1.0 rules on parameter entity expansion, so that any valid
XML 1.0 DTD can be handled. If a parameter entity is used in a way
that does not correspond to any of the higher-level semantics
constructs supported by DTDinst, then references to that parameter
entity will be expanded in the DTDinst output.
Getting DTDinst
DTDinst is available for download as the
file dtdinst-@VERSION@.zip, which contains binaries, source code and
documentation. It requires a Java runtime compatible with the Java 2
Platform, Standard Edition (J2SE) version 1.4 (or any later version),
such as the Java Runtime Environment (JRE), which can be
downloaded here.
The latest version of DTDinst will always be available in
the Downloads
section of the project
site.
Running DTDinst
To run DTDinst, use a command of the form:
java -jar dtdinst.jar DTD
The DTD argument can be either a file or a
URL.
DTDinst writes an XML representation of the DTD in DTDinst format to the standard output. For example,
the command
Each parameter entity declaration is
represented by one of the following elements:
modelGroup is used for a parameter entity that
represents all or part of the content model of an element (example, DTDinst output)
attributeGroup is used for a parameter entity
containing zero or more attribute definitions, which can be
referenced in an ATTLIST declaration (example, DTDinst output)
attributeDefault is used for a parameter entity
that represents the default value of an attribute (example, DTDinst output)
datatype is used for a parameter entity
that represents an attribute type (example, DTDinst output)
enumGroup is used for a parameter entity that
contains zero or more enumerated values (example, DTDinst output)
flag is used for a parameter entity with replacement
text INCLUDE or IGNORE, which can be used to
control a conditional section (example, DTDinst output)
nameSpec is used for a parameter entity that represents
the name of an element or attribute (example, DTDinst output)
externalId is used for an external parameter entity
that does not fall into any of the above categories (example, DTDinst output)
param is used for an internal parameter entity
that does not fall into any of the above categories (example, DTDinst output)
overridden is used for a parameter entity declaration
that is overridden by an earlier declaration of the same parameter
entity (example, DTDinst output)
The element used to represent a parameter entity reference depends
on the element used to represent the declaration of the parameter
entity.
If the declaration is represented by a modelGroup,
attributeGroup, attributeDefault,
datatype, enumGroup, flag or
nameSpec element, then the reference will be represented
by a modelGroupRef, attributeGroupRef,
attributeDefaultRef, datatypeRef,
enumGroupRef, flagRef or
nameSpecRef element respectively.
If the declaration is represented by externalId and
the reference occurs at the declaration level (i.e. at a point where a
declaration would be allowed), then the reference will be represented
by a externalIdRef element containing the declarations
from the external entity.
Otherwise, the reference will be expanded and there will be no
indication that a reference was originally used in the DTD.
An XSLT stylesheet is available that
converts DTDinst format to RELAX NG. It has many more limitations than
the converter builtin to DTDinst, but it may be useful as a basis for
XSLT-based processing of DTDinst format.
Sample DTDs
You may find it interesting to experiment with the following XML DTDs
which are available online:
DTDinst does not attempt to understand the contents of ignored
conditional sections: DTDinst format represents the contents of an
ignored section as a string. If you wish to preserve information
about conditional sections, you should therefore make as many
conditional sections as possible be included marked sections rather
than ignored marked sections. You can do this by creating a wrapper
DTD that declares parameter entities as INCLUDE and then
references the real DTD. For example, you might use this wrapper DTD to convert the TEI P4 DTD.
DTDinst does not attempt to understand the contents of parameter
entities that are never referenced.
Reporting bugs
Please report bugs by creating a new issue in
the Issues
section of the project site. Be sure to attach a complete DTD for
which DTDinst exhibits the bug.
The overall structure of RELAX modulesNamespace declarations cannot be controlled by
RELAX Core. Wait for RELAX modularization.div elements in modules
Interfacediv elements in interfaces
Include
Hedge ModelsThis is used to describe element hedge models.
It is also used as subordinates of <sequence>,
<choice>, and <mixed>.
This is used to specify the "occurs" attribute,
which is shared by several elements.?*+with the label attributewith the type attribute
Ruleswithout embedded tag or attPool elementswith the type attributewith embedded tag or attPool elementswith the type attributewithout embedded tag or attPool elementswith a hedge modelwith embedded tag or attPool elementswith a hedge model
Clausestag elements embedded in elementRulesattPool elements embedded in elementRulestrue
jing-trang-20181222+dfsg2/eg/relaxCoreDatatypes.rng 0000664 0000000 0000000 00000015613 13520105541 0021726 0 ustar 00root root 0000000 0000000
hexbase64
jing-trang-20181222+dfsg2/eg/relaxng.rng 0000664 0000000 0000000 00000017601 13520105541 0017562 0 ustar 00root root 0000000 0000000
choiceinterleave
jing-trang-20181222+dfsg2/eg/testSuite.rng 0000664 0000000 0000000 00000007120 13520105541 0020106 0 ustar 00root root 0000000 0000000
([\-A-Za-z0-9:@&=+$,_.!~*'()]|%[0-9a-fA-F][0-9a-fA-F])+
jing-trang-20181222+dfsg2/eg/xslt.rng 0000664 0000000 0000000 00000064007 13520105541 0017116 0 ustar 00root root 0000000 0000000
1.0versionversionextension-element-prefixesexclude-result-prefixesuse-attribute-setsyesnoyesnosinglemultipleanyalphabetictraditionaltextnumberascendingdescendingupper-firstlower-firstyesnoxmlhtmltextyesnoyesnoyesno#default#default
\*|\i\c*:\*
1
.*:.*
([^\{\}]|\{\{|\}\})*\{([^"'\{\}]|"[^"]*"|'[^']*')+\}([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*
[^\{\}]*(\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*
([^\{\}]|\{\{|\}\}|\{([^"'\{\}]|"[^"]*"|'[^']*')+\})*
jing-trang-20181222+dfsg2/extapidoc/ 0000775 0000000 0000000 00000000000 13520105541 0016772 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jaxp/ 0000775 0000000 0000000 00000000000 13520105541 0017734 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jaxp/1.1/ 0000775 0000000 0000000 00000000000 13520105541 0020233 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jaxp/1.1/package-list 0000664 0000000 0000000 00000000176 13520105541 0022526 0 ustar 00root root 0000000 0000000 javax.xml.parsers
javax.xml.transform
javax.xml.transform.dom
javax.xml.transform.sax
javax.xml.transform.stream
org.w3c.dom
jing-trang-20181222+dfsg2/extapidoc/jdk/ 0000775 0000000 0000000 00000000000 13520105541 0017542 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jdk/1.3/ 0000775 0000000 0000000 00000000000 13520105541 0020043 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jdk/1.3/package-list 0000664 0000000 0000000 00000002515 13520105541 0022335 0 ustar 00root root 0000000 0000000 java.applet
java.awt
java.awt.color
java.awt.datatransfer
java.awt.dnd
java.awt.event
java.awt.font
java.awt.geom
java.awt.im
java.awt.im.spi
java.awt.image
java.awt.image.renderable
java.awt.print
java.beans
java.beans.beancontext
java.io
java.lang
java.lang.ref
java.lang.reflect
java.math
java.net
java.rmi
java.rmi.activation
java.rmi.dgc
java.rmi.registry
java.rmi.server
java.security
java.security.acl
java.security.cert
java.security.interfaces
java.security.spec
java.sql
java.text
java.util
java.util.jar
java.util.zip
javax.accessibility
javax.naming
javax.naming.directory
javax.naming.event
javax.naming.ldap
javax.naming.spi
javax.rmi
javax.rmi.CORBA
javax.sound.midi
javax.sound.midi.spi
javax.sound.sampled
javax.sound.sampled.spi
javax.swing
javax.swing.border
javax.swing.colorchooser
javax.swing.event
javax.swing.filechooser
javax.swing.plaf
javax.swing.plaf.basic
javax.swing.plaf.metal
javax.swing.plaf.multi
javax.swing.table
javax.swing.text
javax.swing.text.html
javax.swing.text.html.parser
javax.swing.text.rtf
javax.swing.tree
javax.swing.undo
javax.transaction
org.omg.CORBA
org.omg.CORBA_2_3
org.omg.CORBA_2_3.portable
org.omg.CORBA.DynAnyPackage
org.omg.CORBA.ORBPackage
org.omg.CORBA.portable
org.omg.CORBA.TypeCodePackage
org.omg.CosNaming
org.omg.CosNaming.NamingContextPackage
org.omg.SendingContext
org.omg.stub.java.rmi
jing-trang-20181222+dfsg2/extapidoc/jdk/1.5/ 0000775 0000000 0000000 00000000000 13520105541 0020045 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jdk/1.5/package-list 0000664 0000000 0000000 00000006437 13520105541 0022346 0 ustar 00root root 0000000 0000000 java.applet
java.awt
java.awt.color
java.awt.datatransfer
java.awt.dnd
java.awt.event
java.awt.font
java.awt.geom
java.awt.im
java.awt.im.spi
java.awt.image
java.awt.image.renderable
java.awt.print
java.beans
java.beans.beancontext
java.io
java.lang
java.lang.annotation
java.lang.instrument
java.lang.management
java.lang.ref
java.lang.reflect
java.math
java.net
java.nio
java.nio.channels
java.nio.channels.spi
java.nio.charset
java.nio.charset.spi
java.rmi
java.rmi.activation
java.rmi.dgc
java.rmi.registry
java.rmi.server
java.security
java.security.acl
java.security.cert
java.security.interfaces
java.security.spec
java.sql
java.text
java.util
java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks
java.util.jar
java.util.logging
java.util.prefs
java.util.regex
java.util.zip
javax.accessibility
javax.activity
javax.crypto
javax.crypto.interfaces
javax.crypto.spec
javax.imageio
javax.imageio.event
javax.imageio.metadata
javax.imageio.plugins.bmp
javax.imageio.plugins.jpeg
javax.imageio.spi
javax.imageio.stream
javax.management
javax.management.loading
javax.management.modelmbean
javax.management.monitor
javax.management.openmbean
javax.management.relation
javax.management.remote
javax.management.remote.rmi
javax.management.timer
javax.naming
javax.naming.directory
javax.naming.event
javax.naming.ldap
javax.naming.spi
javax.net
javax.net.ssl
javax.print
javax.print.attribute
javax.print.attribute.standard
javax.print.event
javax.rmi
javax.rmi.CORBA
javax.rmi.ssl
javax.security.auth
javax.security.auth.callback
javax.security.auth.kerberos
javax.security.auth.login
javax.security.auth.spi
javax.security.auth.x500
javax.security.cert
javax.security.sasl
javax.sound.midi
javax.sound.midi.spi
javax.sound.sampled
javax.sound.sampled.spi
javax.sql
javax.sql.rowset
javax.sql.rowset.serial
javax.sql.rowset.spi
javax.swing
javax.swing.border
javax.swing.colorchooser
javax.swing.event
javax.swing.filechooser
javax.swing.plaf
javax.swing.plaf.basic
javax.swing.plaf.metal
javax.swing.plaf.multi
javax.swing.plaf.synth
javax.swing.table
javax.swing.text
javax.swing.text.html
javax.swing.text.html.parser
javax.swing.text.rtf
javax.swing.tree
javax.swing.undo
javax.transaction
javax.transaction.xa
javax.xml
javax.xml.datatype
javax.xml.namespace
javax.xml.parsers
javax.xml.transform
javax.xml.transform.dom
javax.xml.transform.sax
javax.xml.transform.stream
javax.xml.validation
javax.xml.xpath
org.ietf.jgss
org.omg.CORBA
org.omg.CORBA.DynAnyPackage
org.omg.CORBA.ORBPackage
org.omg.CORBA.TypeCodePackage
org.omg.CORBA.portable
org.omg.CORBA_2_3
org.omg.CORBA_2_3.portable
org.omg.CosNaming
org.omg.CosNaming.NamingContextExtPackage
org.omg.CosNaming.NamingContextPackage
org.omg.Dynamic
org.omg.DynamicAny
org.omg.DynamicAny.DynAnyFactoryPackage
org.omg.DynamicAny.DynAnyPackage
org.omg.IOP
org.omg.IOP.CodecFactoryPackage
org.omg.IOP.CodecPackage
org.omg.Messaging
org.omg.PortableInterceptor
org.omg.PortableInterceptor.ORBInitInfoPackage
org.omg.PortableServer
org.omg.PortableServer.CurrentPackage
org.omg.PortableServer.POAManagerPackage
org.omg.PortableServer.POAPackage
org.omg.PortableServer.ServantLocatorPackage
org.omg.PortableServer.portable
org.omg.SendingContext
org.omg.stub.java.rmi
org.w3c.dom
org.w3c.dom.bootstrap
org.w3c.dom.events
org.w3c.dom.ls
org.xml.sax
org.xml.sax.ext
org.xml.sax.helpers
jing-trang-20181222+dfsg2/extapidoc/jdk/1.6/ 0000775 0000000 0000000 00000000000 13520105541 0020046 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/jdk/1.6/package-list 0000664 0000000 0000000 00000007771 13520105541 0022351 0 ustar 00root root 0000000 0000000 java.applet
java.awt
java.awt.color
java.awt.datatransfer
java.awt.dnd
java.awt.event
java.awt.font
java.awt.geom
java.awt.im
java.awt.im.spi
java.awt.image
java.awt.image.renderable
java.awt.print
java.beans
java.beans.beancontext
java.io
java.lang
java.lang.annotation
java.lang.instrument
java.lang.management
java.lang.ref
java.lang.reflect
java.math
java.net
java.nio
java.nio.channels
java.nio.channels.spi
java.nio.charset
java.nio.charset.spi
java.rmi
java.rmi.activation
java.rmi.dgc
java.rmi.registry
java.rmi.server
java.security
java.security.acl
java.security.cert
java.security.interfaces
java.security.spec
java.sql
java.text
java.text.spi
java.util
java.util.concurrent
java.util.concurrent.atomic
java.util.concurrent.locks
java.util.jar
java.util.logging
java.util.prefs
java.util.regex
java.util.spi
java.util.zip
javax.accessibility
javax.activation
javax.activity
javax.annotation
javax.annotation.processing
javax.crypto
javax.crypto.interfaces
javax.crypto.spec
javax.imageio
javax.imageio.event
javax.imageio.metadata
javax.imageio.plugins.bmp
javax.imageio.plugins.jpeg
javax.imageio.spi
javax.imageio.stream
javax.jws
javax.jws.soap
javax.lang.model
javax.lang.model.element
javax.lang.model.type
javax.lang.model.util
javax.management
javax.management.loading
javax.management.modelmbean
javax.management.monitor
javax.management.openmbean
javax.management.relation
javax.management.remote
javax.management.remote.rmi
javax.management.timer
javax.naming
javax.naming.directory
javax.naming.event
javax.naming.ldap
javax.naming.spi
javax.net
javax.net.ssl
javax.print
javax.print.attribute
javax.print.attribute.standard
javax.print.event
javax.rmi
javax.rmi.CORBA
javax.rmi.ssl
javax.script
javax.security.auth
javax.security.auth.callback
javax.security.auth.kerberos
javax.security.auth.login
javax.security.auth.spi
javax.security.auth.x500
javax.security.cert
javax.security.sasl
javax.sound.midi
javax.sound.midi.spi
javax.sound.sampled
javax.sound.sampled.spi
javax.sql
javax.sql.rowset
javax.sql.rowset.serial
javax.sql.rowset.spi
javax.swing
javax.swing.border
javax.swing.colorchooser
javax.swing.event
javax.swing.filechooser
javax.swing.plaf
javax.swing.plaf.basic
javax.swing.plaf.metal
javax.swing.plaf.multi
javax.swing.plaf.synth
javax.swing.table
javax.swing.text
javax.swing.text.html
javax.swing.text.html.parser
javax.swing.text.rtf
javax.swing.tree
javax.swing.undo
javax.tools
javax.transaction
javax.transaction.xa
javax.xml
javax.xml.bind
javax.xml.bind.annotation
javax.xml.bind.annotation.adapters
javax.xml.bind.attachment
javax.xml.bind.helpers
javax.xml.bind.util
javax.xml.crypto
javax.xml.crypto.dom
javax.xml.crypto.dsig
javax.xml.crypto.dsig.dom
javax.xml.crypto.dsig.keyinfo
javax.xml.crypto.dsig.spec
javax.xml.datatype
javax.xml.namespace
javax.xml.parsers
javax.xml.soap
javax.xml.stream
javax.xml.stream.events
javax.xml.stream.util
javax.xml.transform
javax.xml.transform.dom
javax.xml.transform.sax
javax.xml.transform.stax
javax.xml.transform.stream
javax.xml.validation
javax.xml.ws
javax.xml.ws.handler
javax.xml.ws.handler.soap
javax.xml.ws.http
javax.xml.ws.soap
javax.xml.ws.spi
javax.xml.xpath
org.ietf.jgss
org.omg.CORBA
org.omg.CORBA.DynAnyPackage
org.omg.CORBA.ORBPackage
org.omg.CORBA.TypeCodePackage
org.omg.CORBA.portable
org.omg.CORBA_2_3
org.omg.CORBA_2_3.portable
org.omg.CosNaming
org.omg.CosNaming.NamingContextExtPackage
org.omg.CosNaming.NamingContextPackage
org.omg.Dynamic
org.omg.DynamicAny
org.omg.DynamicAny.DynAnyFactoryPackage
org.omg.DynamicAny.DynAnyPackage
org.omg.IOP
org.omg.IOP.CodecFactoryPackage
org.omg.IOP.CodecPackage
org.omg.Messaging
org.omg.PortableInterceptor
org.omg.PortableInterceptor.ORBInitInfoPackage
org.omg.PortableServer
org.omg.PortableServer.CurrentPackage
org.omg.PortableServer.POAManagerPackage
org.omg.PortableServer.POAPackage
org.omg.PortableServer.ServantLocatorPackage
org.omg.PortableServer.portable
org.omg.SendingContext
org.omg.stub.java.rmi
org.w3c.dom
org.w3c.dom.bootstrap
org.w3c.dom.events
org.w3c.dom.ls
org.xml.sax
org.xml.sax.ext
org.xml.sax.helpers
jing-trang-20181222+dfsg2/extapidoc/sax/ 0000775 0000000 0000000 00000000000 13520105541 0017565 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/extapidoc/sax/package-list 0000664 0000000 0000000 00000000062 13520105541 0022052 0 ustar 00root root 0000000 0000000 org.xml.sax
org.xml.sax.ext
org.xml.sax.helpers
jing-trang-20181222+dfsg2/gcj/ 0000775 0000000 0000000 00000000000 13520105541 0015555 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/gcj/INSTALL 0000664 0000000 0000000 00000022004 13520105541 0016604 0 ustar 00root root 0000000 0000000 Copyright 1994, 1995, 1996, 1999, 2000, 2001, 2002 Free Software
Foundation, Inc.
This file is free documentation; the Free Software Foundation gives
unlimited permission to copy, distribute and modify it.
Basic Installation
==================
These are generic installation instructions.
The `configure' shell script attempts to guess correct values for
various system-dependent variables used during compilation. It uses
those values to create a `Makefile' in each directory of the package.
It may also create one or more `.h' files containing system-dependent
definitions. Finally, it creates a shell script `config.status' that
you can run in the future to recreate the current configuration, and a
file `config.log' containing compiler output (useful mainly for
debugging `configure').
It can also use an optional file (typically called `config.cache'
and enabled with `--cache-file=config.cache' or simply `-C') that saves
the results of its tests to speed up reconfiguring. (Caching is
disabled by default to prevent problems with accidental use of stale
cache files.)
If you need to do unusual things to compile the package, please try
to figure out how `configure' could check whether to do them, and mail
diffs or instructions to the address given in the `README' so they can
be considered for the next release. If you are using the cache, and at
some point `config.cache' contains results you don't want to keep, you
may remove or edit it.
The file `configure.ac' (or `configure.in') is used to create
`configure' by a program called `autoconf'. You only need
`configure.ac' if you want to change it or regenerate `configure' using
a newer version of `autoconf'.
The simplest way to compile this package is:
1. `cd' to the directory containing the package's source code and type
`./configure' to configure the package for your system. If you're
using `csh' on an old version of System V, you might need to type
`sh ./configure' instead to prevent `csh' from trying to execute
`configure' itself.
Running `configure' takes awhile. While running, it prints some
messages telling which features it is checking for.
2. Type `make' to compile the package.
3. Optionally, type `make check' to run any self-tests that come with
the package.
4. Type `make install' to install the programs and any data files and
documentation.
5. You can remove the program binaries and object files from the
source code directory by typing `make clean'. To also remove the
files that `configure' created (so you can compile the package for
a different kind of computer), type `make distclean'. There is
also a `make maintainer-clean' target, but that is intended mainly
for the package's developers. If you use it, you may have to get
all sorts of other programs in order to regenerate files that came
with the distribution.
Compilers and Options
=====================
Some systems require unusual options for compilation or linking that
the `configure' script does not know about. Run `./configure --help'
for details on some of the pertinent environment variables.
You can give `configure' initial values for variables by setting
them in the environment. You can do that on the command line like this:
./configure CC=c89 CFLAGS=-O2 LIBS=-lposix
*Note Defining Variables::, for more details.
Compiling For Multiple Architectures
====================================
You can compile the package for more than one kind of computer at the
same time, by placing the object files for each architecture in their
own directory. To do this, you must use a version of `make' that
supports the `VPATH' variable, such as GNU `make'. `cd' to the
directory where you want the object files and executables to go and run
the `configure' script. `configure' automatically checks for the
source code in the directory that `configure' is in and in `..'.
If you have to use a `make' that does not support the `VPATH'
variable, you have to compile the package for one architecture at a
time in the source code directory. After you have installed the
package for one architecture, use `make distclean' before reconfiguring
for another architecture.
Installation Names
==================
By default, `make install' will install the package's files in
`/usr/local/bin', `/usr/local/man', etc. You can specify an
installation prefix other than `/usr/local' by giving `configure' the
option `--prefix=PATH'.
You can specify separate installation prefixes for
architecture-specific files and architecture-independent files. If you
give `configure' the option `--exec-prefix=PATH', the package will use
PATH as the prefix for installing programs and libraries.
Documentation and other data files will still use the regular prefix.
In addition, if you use an unusual directory layout you can give
options like `--bindir=PATH' to specify different values for particular
kinds of files. Run `configure --help' for a list of the directories
you can set and what kinds of files go in them.
If the package supports it, you can cause programs to be installed
with an extra prefix or suffix on their names by giving `configure' the
option `--program-prefix=PREFIX' or `--program-suffix=SUFFIX'.
Optional Features
=================
Some packages pay attention to `--enable-FEATURE' options to
`configure', where FEATURE indicates an optional part of the package.
They may also pay attention to `--with-PACKAGE' options, where PACKAGE
is something like `gnu-as' or `x' (for the X Window System). The
`README' should mention any `--enable-' and `--with-' options that the
package recognizes.
For packages that use the X Window System, `configure' can usually
find the X include and library files automatically, but if it doesn't,
you can use the `configure' options `--x-includes=DIR' and
`--x-libraries=DIR' to specify their locations.
Specifying the System Type
==========================
There may be some features `configure' cannot figure out
automatically, but needs to determine by the type of machine the package
will run on. Usually, assuming the package is built to be run on the
_same_ architectures, `configure' can figure that out, but if it prints
a message saying it cannot guess the machine type, give it the
`--build=TYPE' option. TYPE can either be a short name for the system
type, such as `sun4', or a canonical name which has the form:
CPU-COMPANY-SYSTEM
where SYSTEM can have one of these forms:
OS KERNEL-OS
See the file `config.sub' for the possible values of each field. If
`config.sub' isn't included in this package, then this package doesn't
need to know the machine type.
If you are _building_ compiler tools for cross-compiling, you should
use the `--target=TYPE' option to select the type of system they will
produce code for.
If you want to _use_ a cross compiler, that generates code for a
platform different from the build platform, you should specify the
"host" platform (i.e., that on which the generated programs will
eventually be run) with `--host=TYPE'.
Sharing Defaults
================
If you want to set default values for `configure' scripts to share,
you can create a site shell script called `config.site' that gives
default values for variables like `CC', `cache_file', and `prefix'.
`configure' looks for `PREFIX/share/config.site' if it exists, then
`PREFIX/etc/config.site' if it exists. Or, you can set the
`CONFIG_SITE' environment variable to the location of the site script.
A warning: not all `configure' scripts look for a site script.
Defining Variables
==================
Variables not defined in a site shell script can be set in the
environment passed to `configure'. However, some packages may run
configure again during the build, and the customized values of these
variables may be lost. In order to avoid this problem, you should set
them in the `configure' command line, using `VAR=value'. For example:
./configure CC=/usr/local2/bin/gcc
will cause the specified gcc to be used as the C compiler (unless it is
overridden in the site shell script).
`configure' Invocation
======================
`configure' recognizes the following options to control how it
operates.
`--help'
`-h'
Print a summary of the options to `configure', and exit.
`--version'
`-V'
Print the version of Autoconf used to generate the `configure'
script, and exit.
`--cache-file=FILE'
Enable the cache: use and save the results of the tests in FILE,
traditionally `config.cache'. FILE defaults to `/dev/null' to
disable caching.
`--config-cache'
`-C'
Alias for `--cache-file=config.cache'.
`--quiet'
`--silent'
`-q'
Do not print messages saying which checks are being made. To
suppress all normal output, redirect it to `/dev/null' (any error
messages will still be shown).
`--srcdir=DIR'
Look for the package's source code in directory DIR. Usually
`configure' can determine that directory automatically.
`configure' also accepts some other, not widely useful, options. Run
`configure --help' for more details.
jing-trang-20181222+dfsg2/gcj/README.redhat8 0000664 0000000 0000000 00000001520 13520105541 0017771 0 ustar 00root root 0000000 0000000 GCJ as shipped in RedHat 8.0 has a bug in the list of libraries that
it uses to link with. Amongst other things, this causes any Java
program that throws an unhandled exception to hang while printing a
stack trace. See .
If you are running RedHat 8.0, I recommend you apply the following
patch before compiling:
--- /usr/lib/gcc-lib/i386-redhat-linux/3.2/libgcj.spec~ 2002-09-04 04:03:39.000000000 +0100
+++ /usr/lib/gcc-lib/i386-redhat-linux/3.2/libgcj.spec 2002-12-10 15:59:39.000000000 +0000
@@ -4,6 +4,6 @@
# to link with libgcj.
#
%rename lib liborig
-*lib: -lgcj -lm -lz -ldl %(libgcc) %(liborig)
+*lib: -lgcj -lm -lpthread -lz -ldl %(libgcc) %(liborig)
*jc1: -fhash-synchronization -fno-use-divide-subroutine -fuse-boehm-gc -fnon-call-exceptions -fkeep-inline-functions
jing-trang-20181222+dfsg2/gcj/aclocal.m4 0000664 0000000 0000000 00000002517 13520105541 0017422 0 ustar 00root root 0000000 0000000 m4_define([AC_LANG(Java)],
[ac_ext=java
ac_compile='$GCJ -c $GCJFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
ac_link='$GCJ --main=conftest -o conftest$ac_exeext $GCJFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
])
AU_DEFUN([AC_LANG_JAVA], [AC_LANG(Java)])
m4_define([_AC_LANG_ABBREV(JAVA)], [java])
m4_define([AC_LANG_SOURCE(Java)],
[$1])
m4_define([AC_LANG_PROGRAM(Java)],
[$1
public class conftest {
static public void main(String[] args) {
$2
}
}])
AC_DEFUN([AC_LANG_COMPILER(Java)],
[AC_REQUIRE([AC_PROG_GCJ])])
AC_DEFUN([AC_PROG_GCJ],
[AC_LANG_PUSH(Java)dnl
AC_ARG_VAR([GCJ], [Java compiler command])
AC_ARG_VAR([GCJFLAGS], [Java compiler flags])
_AC_ARG_VAR_LDFLAGS()dnl
m4_ifval([$1],
[AC_CHECK_TOOLS(GCJ, [$1])],
[if test -z "$GCJ"; then
AC_CHECK_TOOL(GCJ, gcj)
fi])
test -z "$GCJ" && AC_MSG_ERROR([GCJ not found in \$PATH])
test "${GCJFLAGS+set}" = set || GCJFLAGS="-g -O2"
])
AC_DEFUN([TRY_ORG_XML_SAX],
[AC_TRY_LINK([import org.xml.sax.helpers.XMLReaderFactory;
import org.xml.sax.SAXException;],
[try { XMLReaderFactory.createXMLReader(); } catch (SAXException e) { }],
[$1], [$2])])
AC_DEFUN([GCJ_LIB_SAX],
[AC_MSG_CHECKING([what library contains org.xml.sax])
TRY_ORG_XML_SAX([AC_MSG_RESULT([built in])],
[LIBS=-l-org-xml-sax
TRY_ORG_XML_SAX([AC_MSG_RESULT([-l-org-xml-sax])],
[LIBS=
AC_MSG_RESULT([none found])])])])
jing-trang-20181222+dfsg2/gcj/configure.ac 0000664 0000000 0000000 00000000174 13520105541 0020045 0 ustar 00root root 0000000 0000000 AC_INIT(@PROG@, @PROG_VERSION@)
AC_PROG_INSTALL
AC_PROG_GCJ
GCJ_LIB_SAX
AC_CONFIG_FILES([Makefile test/Makefile])
AC_OUTPUT
jing-trang-20181222+dfsg2/gcj/dist 0000775 0000000 0000000 00000016176 13520105541 0016461 0 ustar 00root root 0000000 0000000 #!/bin/sh
set -e
jing_main=com.thaiopensource.relaxng.util.Driver
jing_test_main=com.thaiopensource.relaxng.util.TestDriver
trang_main=com.thaiopensource.relaxng.translate.Driver
trang_test_main=com.thaiopensource.relaxng.translate.test.CompactTestDriver
a_jing_file=src/com/thaiopensource/relaxng/util/Driver.java
crimson_version=1.1.3
xerces_version=2.3.0
jing_version_properties=src/com/thaiopensource/relaxng/util/resources/Version.properties
trang_version_properties=trang/src/com/thaiopensource/relaxng/translate/resources/Version.properties
crimson_unwanted="
org/w3c
org/xml
org/apache/crimson/tree
org/apache/crimson/jaxp/DocumentBuilderImpl.java
org/apache/crimson/jaxp/DocumentBuilderFactoryImpl.java
javax/xml/parsers/DocumentBuilder.java
javax/xml/parsers/DocumentBuilderFactory.java
META-INF/services/javax.xml.parsers.DocumentBuilderFactory
META-INF/services/javax.xml.transform.TransformerFactory
META-INF/jaxp-javax.manifest
META-INF/manifest.crimson
"
jing_unwanted="
com/thaiopensource/datatype/xsd/regex/jdk1_4
com/thaiopensource/datatype/xsd/regex/xerces
com/thaiopensource/relaxng/jarv
com/thaiopensource/relaxng/util/JingTask.java
com/thaiopensource/validate/xerces
com/thaiopensource/validate/schematron
com/thaiopensource/validate/jarv
META-INF/services/org.iso_relax.verifier.VerifierFactoryLoader
"
jing_unwanted_in_trang="
com/thaiopensource/relaxng/impl
com/thaiopensource/relaxng/util
com/thaiopensource/relaxng/SchemaFactory.java
com/thaiopensource/validate
"
jing_test="dir.xsl exslt.xsl prep.xsl
spectest.xml xsdtest.xml xsdtest.xsl mnstest.xml nrltest.xml"
if [ -f ../${a_jing_file} ]; then
cd ..
elif [ ! -f ${a_jing_file} ]; then
echo You are in the wrong directory >&2
exit 1
fi
if [ $# -gt 0 ]; then
jing_build_dir=$1
else
jing_build_dir=build
fi
jing_build_dir=`cd ${jing_build_dir}; pwd`
build_dir=${jing_build_dir}/gcj
dist_dir=${jing_build_dir}/dist/gcj
top_dir=`pwd`
rm -fr ${build_dir}
test -f ${build_dir} || mkdir -p ${build_dir}
. ${jing_version_properties}
jing_version=$version
. ${trang_version_properties}
trang_version=$version
jing_dir=${build_dir}/jing-${jing_version}
trang_dir=${build_dir}/trang-${trang_version}
mkdir -p ${jing_dir} ${trang_dir}
(ls src/META-INF/services/*.*; find src -name '*.java' -or -name '*.jj' -or -name '*.properties' -or -name '*.rng') | cpio --quiet -p -m -d ${jing_dir}
cd ${jing_dir}/src
rm -fr ${jing_unwanted}
f=com/thaiopensource/relaxng/util/resources/Messages.properties
sed -e 's/java com.thaiopensource.relaxng.util.Driver/jing/' $f >tem
mv tem $f
echo com.thaiopensource.datatype.xsd.regex.xerces2.RegexEngineImpl >META-INF/services/com.thaiopensource.datatype.xsd.regex.RegexEngine
cd ${top_dir}
CLASSPATH=lib/JavaCC.zip gij COM.sun.labs.javacc.Main -output_directory=${jing_dir}/src/com/thaiopensource/relaxng/parse/compact ${jing_dir}/src/com/thaiopensource/relaxng/parse/compact/CompactSyntax.jj >/dev/null
f=${jing_dir}/src/com/thaiopensource/relaxng/parse/compact/CompactSyntaxTokenManager.java
sed -e 's/java.io.IOException/EOFException/g' $f >${build_dir}/tem
mv ${build_dir}/tem $f
cd ${build_dir}
tar xfz ${top_dir}/gcj/crimson-${crimson_version}-src.tar.gz crimson-${crimson_version}/src
cd crimson-${crimson_version}
patch -p0 <${top_dir}/gcj/crimson.patch
cd src
rm -fr ${crimson_unwanted}
find org javax -type f -not -name '*.java' -not -name '*.properties' | xargs rm -f
cd ${top_dir}
cp -a ${build_dir}/crimson-${crimson_version}/src/* ${jing_dir}/src
rm -fr ${build_dir}/crimson-${crimson_version}
cd ${build_dir}
xerces_top_dir=xerces-`echo ${xerces_version} | tr . _`
xerces_src_dir=${xerces_top_dir}/src
tar xfz ${top_dir}/gcj/Xerces-J-src.${xerces_version}.tar.gz ${xerces_src_dir}/org/apache/xerces/impl/xpath/regex
cd ${top_dir}
cp -a ${build_dir}/${xerces_src_dir}/* ${jing_dir}/src
rm -fr ${build_dir}/${xerces_top_dir}
cd ${jing_dir}
patch -p0 <${top_dir}/gcj/xerces-regex.patch
rm -f `find src -name '*~'`
cd ${top_dir}
cp -a ${jing_dir}/src ${trang_dir}
cd dtdinst
find src -name '*.java' -or -name '*.properties' | cpio --quiet -p -m -d ${trang_dir}
cd ../trang
find src -name '*.java' -or -name '*.properties' | cpio --quiet -p -m -d ${trang_dir}
cd ${trang_dir}/src
rm -fr ${jing_unwanted_in_trang}
f=com/thaiopensource/relaxng/translate/resources/Messages.properties
sed -e 's/java com.thaiopensource.relaxng.translate.Driver/trang/' $f >tem
mv tem $f
cd ${top_dir}
setup_prog() {
cd ${prog_src_dir}
sed -e "s/@PROG@/${prog}/" -e "s/@MAIN@/${main}/" -e "s/@TEST_MAIN@/${test_main}/" ${top_dir}/gcj/vars.mk >Makefile.in
echo SOURCES=\\ >>Makefile.in
find src -name '*.java' | sed -e 's;^; $(srcdir)/;' -e 's/$/ \\/' -e '$s/ \\//' >>Makefile.in
echo RESOURCES=\\ >>Makefile.in
find src -type f -not -name '*.java' -not -name '*.jj' | sed -e 's;^; ;' -e 's/$/.o/' -e 's/$/ \\/' -e '$s/ \\//' >>Makefile.in
echo DIRS=src \\ >>Makefile.in
find src/* -type d -not -name '*.java' -not -name '*.jj' | sed -e 's;^; ;' -e 's/$/ \\/' -e '$s/ \\//' >>Makefile.in
cat ${top_dir}/gcj/rules.mk >>Makefile.in
find src -type f -not -name '*.java' -not -name '*.jj' -exec mv "{}" "{}.resource" ";"
sed -e "s/@PROG@/${prog}/" -e "s/@PROG_VERSION@/${prog_version}/" ${top_dir}/gcj/configure.ac >configure.ac
cp -a ${top_dir}/gcj/aclocal.m4 .
cp -a ${top_dir}/gcj/install-sh .
cp -a ${top_dir}/gcj/mkinstalldirs .
cp -a ${top_dir}/gcj/INSTALL .
sed -e "s/@VERSION@/${prog_version}/" ${top_dir}/gcj/${prog}.1 >${prog}.1
autoconf
rm -fr autom4te*
sed -e "/^Version:/s/:.*/: ${prog_version}/" ${top_dir}/gcj/${prog}.spec >${prog}.spec
cat >copying.txt <>copying.txt
cat >>copying.txt <>copying.txt
cat >>copying.txt <>copying.txt
cp -a ${top_dir}/gcj/README.redhat8 .
mkdir test
}
prog=jing
main=${jing_main}
test_main=${jing_test_main}
prog_version=${jing_version}
prog_src_dir=${jing_dir}
copying=${top_dir}/copying.txt
setup_prog
cd test
for f in ${jing_test}; do cp -a ${top_dir}/test/$f .; done
cp -a ${top_dir}/gcj/test_jing.mk Makefile.in
cd ${top_dir}
prog=trang
main=${trang_main}
test_main=${trang_test_main}
prog_version=${trang_version}
prog_src_dir=${trang_dir}
copying=${top_dir}/trang/copying.txt
setup_prog
sed -e "s/@VERSION@/${trang_version}/g" ${top_dir}/trang/doc/trang-manual.html >trang-manual.html
cd test
cp -a ${top_dir}/trang/test/compacttest.xml .
cp -a ${top_dir}/trang/test/toxsdtest.xml .
cp -a ${top_dir}/test/dir.xsl .
cp -a ${top_dir}/test/exslt.xsl .
cp -a ${top_dir}/trang/test/compactprep.xsl prep.xsl
cp -a ${top_dir}/gcj/test_trang.mk Makefile.in
cd ${top_dir}
test -d ${dist_dir} || mkdir -p ${dist_dir}
cd ${dist_dir}
abs_dist_dir=`pwd`
cd ${top_dir}
cd ${jing_dir}/..
tar cfz ${abs_dist_dir}/jing-${jing_version}.tar.gz jing-${jing_version}
cd ${top_dir}
cd ${trang_dir}/..
tar cfz ${abs_dist_dir}/trang-${trang_version}.tar.gz trang-${trang_version}
jing-trang-20181222+dfsg2/gcj/install-sh 0000775 0000000 0000000 00000012701 13520105541 0017562 0 ustar 00root root 0000000 0000000 #!/bin/sh
#
# install - install a program, script, or datafile
# This comes from X11R5 (mit/util/scripts/install.sh).
#
# Copyright 1991 by the Massachusetts Institute of Technology
#
# Permission to use, copy, modify, distribute, and sell this software and its
# documentation for any purpose is hereby granted without fee, provided that
# the above copyright notice appear in all copies and that both that
# copyright notice and this permission notice appear in supporting
# documentation, and that the name of M.I.T. not be used in advertising or
# publicity pertaining to distribution of the software without specific,
# written prior permission. M.I.T. makes no representations about the
# suitability of this software for any purpose. It is provided "as is"
# without express or implied warranty.
#
# Calling this script install-sh is preferred over install.sh, to prevent
# `make' implicit rules from creating a file called install from it
# when there is no Makefile.
#
# This script is compatible with the BSD install script, but was written
# from scratch. It can only install one file at a time, a restriction
# shared with many OS's install programs.
# set DOITPROG to echo to test this script
# Don't use :- since 4.3BSD and earlier shells don't like it.
doit="${DOITPROG-}"
# put in absolute paths if you don't have them in your path; or use env. vars.
mvprog="${MVPROG-mv}"
cpprog="${CPPROG-cp}"
chmodprog="${CHMODPROG-chmod}"
chownprog="${CHOWNPROG-chown}"
chgrpprog="${CHGRPPROG-chgrp}"
stripprog="${STRIPPROG-strip}"
rmprog="${RMPROG-rm}"
mkdirprog="${MKDIRPROG-mkdir}"
transformbasename=""
transform_arg=""
instcmd="$mvprog"
chmodcmd="$chmodprog 0755"
chowncmd=""
chgrpcmd=""
stripcmd=""
rmcmd="$rmprog -f"
mvcmd="$mvprog"
src=""
dst=""
dir_arg=""
while [ x"$1" != x ]; do
case $1 in
-c) instcmd="$cpprog"
shift
continue;;
-d) dir_arg=true
shift
continue;;
-m) chmodcmd="$chmodprog $2"
shift
shift
continue;;
-o) chowncmd="$chownprog $2"
shift
shift
continue;;
-g) chgrpcmd="$chgrpprog $2"
shift
shift
continue;;
-s) stripcmd="$stripprog"
shift
continue;;
-t=*) transformarg=`echo $1 | sed 's/-t=//'`
shift
continue;;
-b=*) transformbasename=`echo $1 | sed 's/-b=//'`
shift
continue;;
*) if [ x"$src" = x ]
then
src=$1
else
# this colon is to work around a 386BSD /bin/sh bug
:
dst=$1
fi
shift
continue;;
esac
done
if [ x"$src" = x ]
then
echo "install: no input file specified"
exit 1
else
:
fi
if [ x"$dir_arg" != x ]; then
dst=$src
src=""
if [ -d $dst ]; then
instcmd=:
chmodcmd=""
else
instcmd=$mkdirprog
fi
else
# Waiting for this to be detected by the "$instcmd $src $dsttmp" command
# might cause directories to be created, which would be especially bad
# if $src (and thus $dsttmp) contains '*'.
if [ -f "$src" ] || [ -d "$src" ]
then
:
else
echo "install: $src does not exist"
exit 1
fi
if [ x"$dst" = x ]
then
echo "install: no destination specified"
exit 1
else
:
fi
# If destination is a directory, append the input filename; if your system
# does not like double slashes in filenames, you may need to add some logic
if [ -d $dst ]
then
dst="$dst"/`basename $src`
else
:
fi
fi
## this sed command emulates the dirname command
dstdir=`echo $dst | sed -e 's,[^/]*$,,;s,/$,,;s,^$,.,'`
# Make sure that the destination directory exists.
# this part is taken from Noah Friedman's mkinstalldirs script
# Skip lots of stat calls in the usual case.
if [ ! -d "$dstdir" ]; then
defaultIFS='
'
IFS="${IFS-${defaultIFS}}"
oIFS="${IFS}"
# Some sh's can't handle IFS=/ for some reason.
IFS='%'
set - `echo ${dstdir} | sed -e 's@/@%@g' -e 's@^%@/@'`
IFS="${oIFS}"
pathcomp=''
while [ $# -ne 0 ] ; do
pathcomp="${pathcomp}${1}"
shift
if [ ! -d "${pathcomp}" ] ;
then
$mkdirprog "${pathcomp}"
else
:
fi
pathcomp="${pathcomp}/"
done
fi
if [ x"$dir_arg" != x ]
then
$doit $instcmd $dst &&
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dst; else : ; fi &&
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dst; else : ; fi &&
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dst; else : ; fi &&
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dst; else : ; fi
else
# If we're going to rename the final executable, determine the name now.
if [ x"$transformarg" = x ]
then
dstfile=`basename $dst`
else
dstfile=`basename $dst $transformbasename |
sed $transformarg`$transformbasename
fi
# don't allow the sed command to completely eliminate the filename
if [ x"$dstfile" = x ]
then
dstfile=`basename $dst`
else
:
fi
# Make a temp file name in the proper directory.
dsttmp=$dstdir/#inst.$$#
# Move or copy the file name to the temp name
$doit $instcmd $src $dsttmp &&
trap "rm -f ${dsttmp}" 0 &&
# and set any options; do chmod last to preserve setuid bits
# If any of these fail, we abort the whole thing. If we want to
# ignore errors from any of these, just make sure not to ignore
# errors from the above "$doit $instcmd $src $dsttmp" command.
if [ x"$chowncmd" != x ]; then $doit $chowncmd $dsttmp; else :;fi &&
if [ x"$chgrpcmd" != x ]; then $doit $chgrpcmd $dsttmp; else :;fi &&
if [ x"$stripcmd" != x ]; then $doit $stripcmd $dsttmp; else :;fi &&
if [ x"$chmodcmd" != x ]; then $doit $chmodcmd $dsttmp; else :;fi &&
# Now rename the file to the real destination.
$doit $rmcmd -f $dstdir/$dstfile &&
$doit $mvcmd $dsttmp $dstdir/$dstfile
fi &&
exit 0
jing-trang-20181222+dfsg2/gcj/jing.1 0000664 0000000 0000000 00000003247 13520105541 0016574 0 ustar 00root root 0000000 0000000 .TH jing 1 @VERSION@
.SH NAME
jing \- validate an XML document using a RELAX NG schema
.SH SYNOPSIS
.B jing
.RB [ \-cfit ]
.RB [ \-e
.IR encoding ]
.I rng-file
.RI [ xml-file ...]
.SH DESCRIPTION
If
.I rng-file
is a correct RELAX NG schema and each
.I xml-file
is a well-formed XML document that is valid with respect to
.IR rng-file ,
then
.B jing
will be silent and terminate with a status of 0.
Otherwise,
.B jing
will report one or more errors to the standard
output and will terminate with a status of 1.
Both
.I rng-file
and
.I xml-file
can be filenames or URIs.
.SH OPTIONS
.TP
.B \-c
Uses the compact syntax for the schema.
.TP
.BI \-e " enc"
Uses the encoding
.I enc
to read the schema.
.TP
.BI \-f
Checks that the document is feasibly valid. A document is feasibly
valid if it could be transformed into a valid document by inserting
any number of attributes and child elements anywhere in the tree.
This is equivalent to transforming the schema by wrapping every
.BR data ,
.BR list ,
.B element
and
.B attribute
element in an
.B optional
element and then validating against the transformed schema. This
option may be useful while a document is still under construction.
This option also disables checking that for every IDREF there is a
corresponding ID.
.TP
.B \-i
Disables checking of ID/IDREF/IDREFS. By default,
Jing enforces the constraints imposed by RELAX NG DTD Compatibility
with respect to ID/IDREF/IDREFS.
.TP
.B \-t
Prints the time used by Jing for loading the schema and
for validation.
.SH "SEE ALSO"
trang(1)
.PP
http://relaxng.org
.SH AUTHOR
James Clark (jjc@jclark.com)
.PP
This product includes software developed by the
Apache Software Foundation (http://www.apache.org/).
jing-trang-20181222+dfsg2/gcj/jing.spec 0000664 0000000 0000000 00000001616 13520105541 0017364 0 ustar 00root root 0000000 0000000 Summary: A RELAX NG Validator.
Name: jing
Version:
Release: 1
URL: http://www.thaiopensource.com/relaxng/
Source: %{name}-%{version}.tar.gz
License: BSD
Group: Applications/Text
BuildRoot: %{_tmppath}/%{name}-root
BuildRequires: gcc-java >= 3.2-7
%description
Jing is an implementation of RELAX NG, a schema language for
XML. RELAX NG has been standardized by OASIS and is in the final
stages of standardization by ISO as ISO/IEC 19757-2. Jing validates
an XML document against a RELAX NG schema. Jing supports both the
original XML syntax for RELAX NG schemas, and the more recent non-XML
compact syntax.
%prep
%setup -q
%build
%configure GCJFLAGS="${GCJFLAGS:-%optflags}"
make
%install
rm -rf $RPM_BUILD_ROOT
%makeinstall
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
%{_bindir}/jing
%{_mandir}/man1/jing.1*
%changelog
* Sat Feb 22 2003 James Clark
- Initial build.
jing-trang-20181222+dfsg2/gcj/mkinstalldirs 0000775 0000000 0000000 00000003411 13520105541 0020362 0 ustar 00root root 0000000 0000000 #! /bin/sh
# mkinstalldirs --- make directory hierarchy
# Author: Noah Friedman
# Created: 1993-05-16
# Public domain
errstatus=0
dirmode=""
usage="\
Usage: mkinstalldirs [-h] [--help] [-m mode] dir ..."
# process command line arguments
while test $# -gt 0 ; do
case "${1}" in
-h | --help | --h* ) # -h for help
echo "${usage}" 1>&2; exit 0 ;;
-m ) # -m PERM arg
shift
test $# -eq 0 && { echo "${usage}" 1>&2; exit 1; }
dirmode="${1}"
shift ;;
-- ) shift; break ;; # stop option processing
-* ) echo "${usage}" 1>&2; exit 1 ;; # unknown option
* ) break ;; # first non-opt arg
esac
done
for file
do
if test -d "$file"; then
shift
else
break
fi
done
case $# in
0) exit 0 ;;
esac
case $dirmode in
'')
if mkdir -p -- . 2>/dev/null; then
echo "mkdir -p -- $*"
exec mkdir -p -- "$@"
fi ;;
*)
if mkdir -m "$dirmode" -p -- . 2>/dev/null; then
echo "mkdir -m $dirmode -p -- $*"
exec mkdir -m "$dirmode" -p -- "$@"
fi ;;
esac
for file
do
set fnord `echo ":$file" | sed -ne 's/^:\//#/;s/^://;s/\// /g;s/^#/\//;p'`
shift
pathcomp=
for d
do
pathcomp="$pathcomp$d"
case "$pathcomp" in
-* ) pathcomp=./$pathcomp ;;
esac
if test ! -d "$pathcomp"; then
echo "mkdir $pathcomp"
mkdir "$pathcomp" || lasterr=$?
if test ! -d "$pathcomp"; then
errstatus=$lasterr
else
if test ! -z "$dirmode"; then
echo "chmod $dirmode $pathcomp"
lasterr=""
chmod "$dirmode" "$pathcomp" || lasterr=$?
if test ! -z "$lasterr"; then
errstatus=$lasterr
fi
fi
fi
fi
pathcomp="$pathcomp/"
done
done
exit $errstatus
# Local Variables:
# mode: shell-script
# sh-indentation: 3
# End:
# mkinstalldirs ends here
jing-trang-20181222+dfsg2/gcj/readme.txt 0000664 0000000 0000000 00000001006 13520105541 0017550 0 ustar 00root root 0000000 0000000 The RPMs require libgcj-3.2. This is included with RedHat 8.0. You can
download the libgcj-3.2 RPM from:
http://rpmfind.net//linux/RPM/redhat/8.0/i386/libgcj-3.2-7.i386.html
However, the libgcj RPM depends on particular versions of libgcc and
glibc. So, if you are not running RedHat 8, you might find it easier
to rebuild the RPMs from source. You would need gcc-3.2 or later
installed with Java enabled. Then you can rebuild the RPMs using:
rpmbuild -ta jing-YYYYMMDD.tar.gz
rpmbuild -ta trang-YYYYMMDD.tar.gz
jing-trang-20181222+dfsg2/gcj/rpmmacros 0000664 0000000 0000000 00000000440 13520105541 0017501 0 ustar 00root root 0000000 0000000 %_rpmdir %{_jingbuilddir}/dist/gcj
%_srcrpmdir %{_jingbuilddir}/dist/gcj
%_specdir %{_jingbuilddir}/gcj-rpm
%_sourcedir %{_jingbuilddir}/gcj-rpm
%_builddir %{_jingbuilddir}/gcj-rpm
%_rpmfilename %%{NAME}-%%{VERSION}-%%{RELEASE}.%%{ARCH}.rpm
%packager James Clark
jing-trang-20181222+dfsg2/gcj/rpmrc 0000664 0000000 0000000 00000000335 13520105541 0016624 0 ustar 00root root 0000000 0000000 include: /usr/lib/rpm/rpmrc
macrofiles: /usr/lib/rpm/macros:/usr/lib/rpm/%{_target}/macros:/etc/rpm/macros.specspo:/etc/rpm/macros:/etc/rpm/%{_target}/macros:gcj/rpmmacros
optflags: i386 -O2 -march=i386 -mcpu=i686
jing-trang-20181222+dfsg2/gcj/rules.mk 0000664 0000000 0000000 00000002457 13520105541 0017250 0 ustar 00root root 0000000 0000000 all: $(PROG) test_$(PROG)
$(PROG): $(PROG).o $(RESOURCES)
$(GCJ) $(GCJFLAGS) $(LDFLAGS) --main=$(MAIN) -o $@ $(PROG).o $(RESOURCES) $(LIBS)
test_$(PROG): $(PROG).o $(RESOURCES)
$(GCJ) $(GCJFLAGS) $(LDFLAGS) --main=$(TEST_MAIN) -o $@ $(PROG).o $(RESOURCES) $(LIBS)
$(PROG).o: $(SOURCES)
$(GCJ) $(GCJFLAGS) -c -o $@ $(SOURCES)
.resource.o:
$(GCJ) $(GCJFLAGS) -c -o $@ --resource=`echo $@ | sed -e 's;src/;;' -e 's/.o$$//'` $<
$(RESOURCES): dirstamp
dirstamp:
for d in $(DIRS); do test -d $$d || mkdir $$d; done
@>$@
check: test_$(PROG)
cd test; $(MAKE)
install: $(PROG)
$(srcdir)/mkinstalldirs $(DESTDIR)$(bindir)
$(srcdir)/mkinstalldirs $(DESTDIR)$(man1dir)
$(INSTALL_PROGRAM) $(PROG) $(DESTDIR)$(bindir)/$(PROG)
$(INSTALL_DATA) $(srcdir)/$(PROG).1 $(DESTDIR)$(man1dir)/$(PROG).1
uninstall:
-rm -f $(DESTDIR)$(bindir)/$(PROG)
-rm -f $(DESTDIR)$(man1dir)/$(PROG).1
clean:
-rm -f dirstamp $(PROG) $(PROG).o $(RESOURCES)
-rmdir `for d in $(DIRS); do echo $$d; done | sort -r`
cd test; $(MAKE) clean
$(srcdir)/configure: configure.ac
cd $(srcdir) && autoconf
Makefile: Makefile.in config.status
./config.status
config.status: configure
./config.status --recheck
distclean: clean
-rm -f config.status config.cache config.log
.SUFFIXES: .resource
.PHONY: all check distclean clean install uninstall
jing-trang-20181222+dfsg2/gcj/test_jing.mk 0000664 0000000 0000000 00000004240 13520105541 0020074 0 ustar 00root root 0000000 0000000 srcdir=@srcdir@
XSLTPROC=xsltproc
check: spec-check mns-check nrl-check xsd-check
spec-check: spec-split/stamp
../test_jing spec-test.log spec-split
spec-prepped.xml: $(srcdir)/spectest.xml $(srcdir)/prep.xsl
$(XSLTPROC) -o $@ --stringparam dir spec-split $(srcdir)/prep.xsl $(srcdir)/spectest.xml 2>/dev/null
spec-split/stamp: spec-prepped.xml $(srcdir)/exslt.xsl
-mkdir spec-split
-mkdir `$(XSLTPROC) $(srcdir)/dir.xsl spec-prepped.xml 2>/dev/null`
$(XSLTPROC) $(srcdir)/exslt.xsl spec-prepped.xml 2>/dev/null
@>$@
mns-check: mns-split/stamp
../test_jing mns-test.log mns-split
mns-prepped.xml: $(srcdir)/mnstest.xml $(srcdir)/prep.xsl
$(XSLTPROC) -o $@ --stringparam dir mns-split $(srcdir)/prep.xsl $(srcdir)/mnstest.xml 2>/dev/null
mns-split/stamp: mns-prepped.xml $(srcdir)/exslt.xsl
-mkdir mns-split
-mkdir `$(XSLTPROC) $(srcdir)/dir.xsl mns-prepped.xml 2>/dev/null`
$(XSLTPROC) $(srcdir)/exslt.xsl mns-prepped.xml 2>/dev/null
@>$@
nrl-check: nrl-split/stamp
../test_jing nrl-test.log nrl-split
nrl-prepped.xml: $(srcdir)/nrltest.xml $(srcdir)/prep.xsl
$(XSLTPROC) -o $@ --stringparam dir nrl-split $(srcdir)/prep.xsl $(srcdir)/nrltest.xml 2>/dev/null
nrl-split/stamp: nrl-prepped.xml $(srcdir)/exslt.xsl
-mkdir nrl-split
-mkdir `$(XSLTPROC) $(srcdir)/dir.xsl nrl-prepped.xml 2>/dev/null`
$(XSLTPROC) $(srcdir)/exslt.xsl nrl-prepped.xml 2>/dev/null
@>$@
xsd-check: xsd-split/stamp
../test_jing xsd-test.log xsd-split
xsd-test-suite.xml: $(srcdir)/xsdtest.xml $(srcdir)/xsdtest.xsl
$(XSLTPROC) -o $@ $(srcdir)/xsdtest.xsl $(srcdir)/xsdtest.xml
xsd-prepped.xml: xsd-test-suite.xml $(srcdir)/prep.xsl
$(XSLTPROC) -o $@ --stringparam dir xsd-split $(srcdir)/prep.xsl xsd-test-suite.xml 2>/dev/null
xsd-split/stamp: xsd-prepped.xml $(srcdir)/exslt.xsl
-mkdir xsd-split
-mkdir `$(XSLTPROC) $(srcdir)/dir.xsl xsd-prepped.xml `
$(XSLTPROC) $(srcdir)/exslt.xsl xsd-prepped.xml 2>/dev/null
@>$@
clean:
-rm -fr spec-split spec-prepped.xml
-rm -fr xsd-split xsd-prepped.xml xsd-test-suite.xml
-rm -fr mns-split mns-prepped.xml mns-test-suite.xml
-rm -fr nrl-split nrl-prepped.xml nrl-test-suite.xml
.PHONY: clean check spec-check xsd-check mns-check nrl-check
jing-trang-20181222+dfsg2/gcj/test_trang.mk 0000664 0000000 0000000 00000002512 13520105541 0020260 0 ustar 00root root 0000000 0000000 srcdir=@srcdir@
XSLTPROC=xsltproc
FIXCR=sed -e "s/`echo x | tr x '\015'`/\\&\#xD;/g"
check: compact-check xsd-check
compact-check: compact-split/stamp
../test_trang xsd.log compact-split xml
xsd-check: xsd-split/stamp
../test_trang compact.log xsd-split xsd
compact-prepped.xml: $(srcdir)/compacttest.xml $(srcdir)/prep.xsl
$(XSLTPROC) --stringparam dir compact-split $(srcdir)/prep.xsl $(srcdir)/compacttest.xml | $(FIXCR) >$@
compact-split/stamp: compact-prepped.xml $(srcdir)/exslt.xsl $(srcdir)/dir.xsl
-mkdir `$(XSLTPROC) $(srcdir)/dir.xsl compact-prepped.xml`
$(XSLTPROC) $(srcdir)/exslt.xsl compact-prepped.xml
@for f in compact-split/*/xml/c.rng; do \
$(FIXCR) $$f >tem; mv tem $$f; \
done
# Work around another bug in xsltproc
@f=`grep -l ' foo="val"' compact-split/*/xml/c.rng`; \
if [ -f "$$f" ] ; then \
sed -e 's/ foo=/ rng:foo=/' $$f >tem; mv tem $$f; \
fi
@>$@
xsd-prepped.xml: $(srcdir)/toxsdtest.xml $(srcdir)/prep.xsl
$(XSLTPROC) -o $@ --stringparam dir xsd-split $(srcdir)/prep.xsl $(srcdir)/toxsdtest.xml
xsd-split/stamp: xsd-prepped.xml $(srcdir)/exslt.xsl $(srcdir)/dir.xsl
-mkdir `$(XSLTPROC) $(srcdir)/dir.xsl xsd-prepped.xml`
$(XSLTPROC) $(srcdir)/exslt.xsl xsd-prepped.xml
@>$@
clean:
-rm -fr compact-split xsd-split compact-prepped.xml xsd-prepped.xml
.PHONY: check xsd-check compact-check clean
jing-trang-20181222+dfsg2/gcj/todo.txt 0000664 0000000 0000000 00000000315 13520105541 0017262 0 ustar 00root root 0000000 0000000 Sign RPM file
Detect with -lpthread is needed
Instead of removing unneeded sources, omit them from compile list.
Include some examples and additional documentation in the dist.
Include regex-test in jing.
jing-trang-20181222+dfsg2/gcj/trang.1 0000664 0000000 0000000 00000005344 13520105541 0016760 0 ustar 00root root 0000000 0000000 .TH trang 1 @VERSION@
.SH NAME
trang \- convert between different schema languages for XML
.SH SYNOPSIS
.B trang
.RB [ \-I
.BR rng | rnc | dtd | xml ]
.RB [ \-O
.BR rng | rnc | dtd | xsd ]
.RB [ \-i
.IR input-param ]
.RB [ \-o
.IR output-param ]
.IR input-file " ..."
.I output-file
.SH DESCRIPTION
.B trang
takes as input a schema written in any of the following formats:
.IP
RELAX NG (XML syntax)
.IP
RELAX NG (compact syntax)
.IP
XML 1.0 DTD
.PP
and produces as output a schema written in any of the following formats:
.IP
RELAX NG (XML syntax)
.IP
RELAX NG (compact syntax)
.IP
XML 1.0 DTD
.IP
W3C XML Schema
.PP
Trang can also infer a schema from one or more example XML
documents.
.PP
Trang uses an internal representation based on RELAX NG. For each
supported input format, there is an input module that converts a
schema in that input format into this internal representation. For
each supported output format, there is an output module that converts
the internal representation into a schema in that output format.
Thus, any supported input format can be translated to any supported
output format.
.PP
Trang requires two command-line arguments: the first is the URI or
filename of the schema to be translated; the second is the output
filename.
.PP
Trang infers the input and output modules to be used from the
extension of input and output filenames as follows:
.TP
.B .rng
RELAX NG (XML syntax)
.TP
.B .rnc
RELAX NG (compact syntax)
.TP
.B .dtd
XML 1.0 DTD
.TP
.B .xsd
W3C XML Schema
.TP
.B .xml
XML documents (used as examples from which to infer a schema)
.PP
This inference can be overridden using the
.B \-I
and
.B \-O
options.
.LP
When the input is XML documents used as examples to infer a schema,
more than one input file may be specified as arguments. All the input
files are specified before the output file.
.SH OPTIONS
.TP
.BR "\-I rng" | rnc | dtd | xml
Specifies which input module to use.
.TP
.BR "\-O rng" | rnc | dtd | xsd
Specifies which output module to use.
.TP
.BI \-i " input-param"
.TP
.BI \-o " output-param"
Specifies a parameter for an input
.RB ( \-i )
or output
.RB ( \-o )
module.
The
.B \-i
and
.B \-o
options may be used multiple times in order to specify
multiple parameters. There are two kinds of parameter: boolean
parameters and string-valued parameters. A string-valued parameter is
specified using the form
.IB name = value\fR.
A boolean parameter is
specified using the form
.I name
or
.BI no- name\fR.
The applicable parameters depend on
the particular input and output module.
For details, see the HTML documentation.
.SH "SEE ALSO"
.BR jing (1)
.LP
Trang Manual
.PP
http://relaxng.org
.SH AUTHOR
James Clark (jjc@jclark.com)
.PP
This product includes software developed by the
Apache Software Foundation (http://www.apache.org/).
jing-trang-20181222+dfsg2/gcj/trang.spec 0000664 0000000 0000000 00000003263 13520105541 0017550 0 ustar 00root root 0000000 0000000 Summary: Multi-format schema converter based on RELAX NG.
Name: trang
Version:
Release: 1
URL: http://www.thaiopensource.com/relaxng/
Source: %{name}-%{version}.tar.gz
License: BSD
Group: Applications/Text
BuildRoot: %{_tmppath}/%{name}-root
BuildRequires: gcc-java >= 3.2-7
%description
Trang converts between different schema languages for XML. It
supports the following languages: RELAX NG (both XML and compact
syntax), XML 1.0 DTDs, W3C XML Schema. A schema written in any of the
supported schema languages can be converted into any of the other
supported schema languages, except that W3C XML Schema is supported
for output only, not for input.
Trang can also infer a schema from one or more example XML documents.
Trang is constructed around an RELAX NG object model designed to
support schema conversion. For each schema language supported for
input, there is an input module that can convert from the schema
language into this internal object model. Similarly, for each schema
language supported for output, there is an output module that can
convert from the internal object model in the schema language.
Trang aims to produce human-understandable schemas; it tries for a
translation that preserves all aspects of the input schema that may be
significant to a human reader, including the definitions, the way the
schema is divided into files, annotations and comments.
%prep
%setup -q
%build
%configure GCJFLAGS="${GCJFLAGS:-%optflags}"
make
%install
rm -rf $RPM_BUILD_ROOT
%makeinstall
%clean
rm -rf $RPM_BUILD_ROOT
%files
%defattr(-,root,root)
%{_bindir}/trang
%{_mandir}/man1/trang.1*
%doc trang-manual.html
%changelog
* Sat Feb 22 2003 James Clark
- Initial build.
jing-trang-20181222+dfsg2/gcj/vars.mk 0000664 0000000 0000000 00000000535 13520105541 0017064 0 ustar 00root root 0000000 0000000 SHELL=/bin/sh
srcdir = @srcdir@
VPATH = @srcdir@
prefix = @prefix@
exec_prefix = @exec_prefix@
bindir = @bindir@
mandir = @mandir@
man1dir = $(mandir)/man1
GCJ=@GCJ@
GCJFLAGS=@GCJFLAGS@
LDFLAGS=@LDFLAGS@
INSTALL = @INSTALL@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_DATA = @INSTALL_DATA@
PROG=@PROG@
MAIN=@MAIN@
TEST_MAIN=@TEST_MAIN@
LIBS=@LIBS@
jing-trang-20181222+dfsg2/iml.xsl 0000664 0000000 0000000 00000003100 13520105541 0016315 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/jing-trang.ipr 0000664 0000000 0000000 00000070154 13520105541 0017575 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/jing.bat 0000775 0000000 0000000 00000002312 13520105541 0016432 0 ustar 00root root 0000000 0000000 @echo off
setlocal
set MAIN_CLASS=com.thaiopensource.relaxng.util.Driver
set JAR_FILE=jing.jar
set JAVA_PROBLEM_EXIT_CODE=1
set JRE_KEY=HKLM\SOFTWARE\JavaSoft\Java Runtime Environment
set JAVA_VERSION=unknown
if not exist "%JAVA_HOME%\bin\java.exe" (
for /f "tokens=2* skip=2" %%u in ('reg query "%JRE_KEY%" /v CurrentVersion') do for /f "tokens=2* skip=2" %%i in ('reg query "%JRE_KEY%\%%v" /v JavaHome') do (
set JAVA_VERSION=%%v
set JAVA_HOME=%%j
)
) 2>nul
if exist "%JAVA_HOME%\bin\java.exe" goto found_java
echo Could not find a Java Runtime Environment. Download one from http://java.sun.com/javase/downloads/.
exit /b %JAVA_PROBLEM_EXIT_CODE%
:found_java
if not x1.4==x%JAVA_VERSION% if not x1.3==x%JAVA_VERSION% goto java_version_ok
echo Version 5.0 or newer of the Java Runtime Environment is required. Download one from http://java.sun.com/javase/downloads/.
exit /b %JAVA_PROBLEM_EXIT_CODE%
:java_version_ok
set JAR_DIR=%~dp0
if exist "%JAR_DIR%%JAR_FILE%" goto found_jar
echo Could not find %JAR_FILE%. Must be in the same directory as %~nx0 (%JAR_DIR%).
exit /b %JAVA_PROBLEM_EXIT_CODE%
:found_jar
"%JAVA_HOME%\bin\java.exe" -classpath "%JAR_DIR%%JAR_FILE%" %MAIN_CLASS% %*
jing-trang-20181222+dfsg2/maven-jing.xml 0000664 0000000 0000000 00000012131 13520105541 0017565 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/maven-trang.xml 0000664 0000000 0000000 00000011651 13520105541 0017757 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/ 0000775 0000000 0000000 00000000000 13520105541 0015571 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/ 0000775 0000000 0000000 00000000000 13520105541 0017203 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/mod.xml 0000664 0000000 0000000 00000000245 13520105541 0020505 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/catalog/src/ 0000775 0000000 0000000 00000000000 13520105541 0017772 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/ 0000775 0000000 0000000 00000000000 13520105541 0020716 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/ 0000775 0000000 0000000 00000000000 13520105541 0021474 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0024524 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/ 0000775 0000000 0000000 00000000000 13520105541 0026365 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/catalog/ 0000775 0000000 0000000 00000000000 13520105541 0027777 5 ustar 00root root 0000000 0000000 CatalogEntityResolver.java 0000664 0000000 0000000 00000002306 13520105541 0035055 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/catalog package com.thaiopensource.resolver.catalog;
import org.apache.xml.resolver.helpers.BootstrapResolver;
import org.xml.sax.EntityResolver;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import java.io.IOException;
import java.net.URL;
/**
* An EntityResolver for use when parsing catalogs.
*/
class CatalogEntityResolver implements EntityResolver {
private final EntityResolver entityResolver;
CatalogEntityResolver(EntityResolver entityResolver) {
this.entityResolver = entityResolver;
}
public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
if (BootstrapResolver.xmlCatalogPubId.equals(publicId)
|| BootstrapResolver.xmlCatalogSysId.equals(systemId)) {
URL url = BootstrapResolver.class.getResource("/org/apache/xml/resolver/etc/catalog.dtd");
if (url != null) {
InputSource in = new InputSource(url.toString());
// Avoid any weirdness the parser may perform on URLs
in.setByteStream(url.openStream());
in.setPublicId(publicId);
return in;
}
}
if (entityResolver != null)
return entityResolver.resolveEntity(publicId, systemId);
return null;
}
}
CatalogResolver.java 0000664 0000000 0000000 00000006217 13520105541 0033665 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/catalog package com.thaiopensource.resolver.catalog;
import com.thaiopensource.resolver.AbstractResolver;
import com.thaiopensource.resolver.BasicResolver;
import com.thaiopensource.resolver.Identifier;
import com.thaiopensource.resolver.Input;
import com.thaiopensource.resolver.Resolver;
import com.thaiopensource.resolver.ResolverException;
import com.thaiopensource.resolver.xml.ExternalDTDSubsetIdentifier;
import com.thaiopensource.resolver.xml.ExternalEntityIdentifier;
import com.thaiopensource.resolver.xml.ExternalIdentifier;
import com.thaiopensource.resolver.xml.sax.SAXResolver;
import org.apache.xml.resolver.Catalog;
import java.io.IOException;
import java.util.List;
/**
* A Resolver that uses OASIS XML catalogs.
*/
public class CatalogResolver extends AbstractResolver {
private final Catalog catalog;
private boolean catalogLoaded = false;
private boolean hadCatalogError = false;
// Allow somebody to customize in a different way, but still use our resolve logic.
public CatalogResolver(Catalog catalog) {
this.catalog = catalog;
}
public CatalogResolver(List catalogUris, SAXResolver resolver) {
this(new OasisCatalog(new SimpleCatalogManager(catalogUris), resolver));
}
public CatalogResolver(List catalogUris, Resolver resolver) {
this(catalogUris, new SAXResolver(resolver));
}
public CatalogResolver(List catalogUris) {
this(catalogUris, new SAXResolver());
}
public synchronized void resolve(Identifier id, Input input) throws IOException, ResolverException {
if (input.isResolved())
return;
if (hadCatalogError)
return;
String absoluteUri = null;
try {
absoluteUri = BasicResolver.resolveUri(id);
if (id.getUriReference().equals(absoluteUri))
absoluteUri = null;
}
catch (ResolverException e) {
// ignore
}
String resolved = null;
boolean isExternalIdentifier = (id instanceof ExternalIdentifier);
try {
if (!catalogLoaded) {
catalogLoaded = true;
catalog.loadSystemCatalogs();
}
if (absoluteUri != null)
resolved = isExternalIdentifier ? catalog.resolveSystem(absoluteUri) : catalog.resolveURI(absoluteUri);
if (resolved == null) {
if (!isExternalIdentifier)
resolved = catalog.resolveURI(id.getUriReference());
else if (id instanceof ExternalEntityIdentifier) {
ExternalEntityIdentifier xid = (ExternalEntityIdentifier)id;
resolved = catalog.resolveEntity(xid.getEntityName(), xid.getPublicId(), xid.getUriReference());
}
else if (id instanceof ExternalDTDSubsetIdentifier) {
ExternalDTDSubsetIdentifier xid = (ExternalDTDSubsetIdentifier)id;
resolved = catalog.resolveDoctype(xid.getDoctypeName(), xid.getPublicId(), xid.getUriReference());
}
else {
ExternalIdentifier xid = (ExternalIdentifier)id;
resolved = catalog.resolvePublic(xid.getPublicId(), xid.getUriReference());
}
}
}
catch (ResolverIOException e) {
hadCatalogError = true;
throw e.getResolverException();
}
if (resolved != null)
input.setUri(resolved);
}
}
jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/catalog/OasisCatalog.java0000664 0000000 0000000 00000004357 13520105541 0033224 0 ustar 00root root 0000000 0000000 package com.thaiopensource.resolver.catalog;
import com.thaiopensource.resolver.ResolverException;
import com.thaiopensource.resolver.xml.XMLDocumentIdentifier;
import com.thaiopensource.resolver.xml.sax.SAXResolver;
import com.thaiopensource.xml.sax.DraconianErrorHandler;
import org.apache.xml.resolver.Catalog;
import org.apache.xml.resolver.CatalogManager;
import org.apache.xml.resolver.readers.OASISXMLCatalogReader;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import javax.xml.transform.sax.SAXSource;
import java.io.IOException;
import java.net.URL;
/**
* A catalog with customized parsing of catalog files. In particular, it only supports
* OASIS XML Catalogs and it uses a SAXResolver for access to the catalog URIs.
*/
class OasisCatalog extends Catalog {
private final SAXResolver saxResolver;
OasisCatalog(CatalogManager catalogManager, SAXResolver saxResolver) {
super(catalogManager);
this.saxResolver = saxResolver;
// don't call setupReaders; since we use our own parseCatalogFile
// we'll load the catalogs lazily
}
protected void parseCatalogFile(String uri) throws IOException {
OASISXMLCatalogReader catalogReader = new OASISXMLCatalogReader();
try {
SAXSource source = saxResolver.resolve(new XMLDocumentIdentifier(uri, null, OASISXMLCatalogReader.namespaceName));
String systemId = source.getInputSource().getSystemId();
if (systemId == null)
systemId = uri;
base = new URL(systemId);
catalogReader.setCatalog(this);
XMLReader xmlReader = source.getXMLReader();
xmlReader.setEntityResolver(new CatalogEntityResolver(xmlReader.getEntityResolver()));
xmlReader.setContentHandler(catalogReader);
xmlReader.setErrorHandler(new DraconianErrorHandler());
xmlReader.parse(source.getInputSource());
}
catch (SAXException e) {
Exception wrapped = e.getException();
// this will get unwrapped by CatalogResolver
throw new ResolverIOException(wrapped instanceof ResolverException
? (ResolverException)wrapped
: new ResolverException(e));
}
}
protected Catalog newCatalog() {
return new OasisCatalog(catalogManager, saxResolver);
}
}
ResolverIOException.java 0000664 0000000 0000000 00000001040 13520105541 0034466 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/catalog package com.thaiopensource.resolver.catalog;
import com.thaiopensource.resolver.ResolverException;
import java.io.IOException;
/**
* A wrapper for a ResolverException to allow it to be passed up by the catalog parser.
*/
public class ResolverIOException extends IOException {
private final ResolverException resolverException;
public ResolverIOException(ResolverException resolverException) {
this.resolverException = resolverException;
}
public ResolverException getResolverException() {
return resolverException;
}
}
SimpleCatalogManager.java 0000664 0000000 0000000 00000001764 13520105541 0034612 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/main/com/thaiopensource/resolver/catalog package com.thaiopensource.resolver.catalog;
import org.apache.xml.resolver.CatalogManager;
import java.util.List;
import java.util.Vector;
/**
* A very simple CatalogManager that does not use use property file/system property customization.
*/
class SimpleCatalogManager extends CatalogManager {
private final Vector catalogUris;
SimpleCatalogManager(List catalogUris) {
this.catalogUris = new Vector();
this.catalogUris.addAll(catalogUris);
// disable printing to System.out
setVerbosity(0);
}
public Vector getCatalogFiles() {
return catalogUris;
}
public boolean getRelativeCatalogs() {
return false;
}
public boolean getPreferPublic() {
return true;
}
public boolean getIgnoreMissingProperties() {
return true;
}
public boolean getAllowOasisXMLCatalogPI() {
return false;
}
public boolean getUseStaticCatalog() {
return false;
}
public String getCatalogClassName() {
return null;
}
}
jing-trang-20181222+dfsg2/mod/catalog/src/test/ 0000775 0000000 0000000 00000000000 13520105541 0020751 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/test/com/ 0000775 0000000 0000000 00000000000 13520105541 0021527 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/test/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0024557 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/test/com/thaiopensource/resolver/ 0000775 0000000 0000000 00000000000 13520105541 0026420 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/test/com/thaiopensource/resolver/catalog/ 0000775 0000000 0000000 00000000000 13520105541 0030032 5 ustar 00root root 0000000 0000000 CatalogResolverTest.java 0000664 0000000 0000000 00000002537 13520105541 0034561 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/catalog/src/test/com/thaiopensource/resolver/catalog package com.thaiopensource.resolver.catalog;
import com.thaiopensource.resolver.Input;
import com.thaiopensource.resolver.Resolver;
import com.thaiopensource.resolver.ResolverException;
import com.thaiopensource.resolver.xml.ExternalIdentifier;
import com.thaiopensource.resolver.xml.sax.SAXResolver;
import org.testng.Assert;
import org.testng.annotations.Test;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
/**
* Tests CatalogResolver.
*/
public class CatalogResolverTest {
@Test
public void testResolve() throws IOException, ResolverException {
List catalogs = new ArrayList();
catalogs.add(resourceUri("catalog.xml"));
Resolver resolver = new CatalogResolver(catalogs, new SAXResolver(null));
ExternalIdentifier xid = new ExternalIdentifier("foo.xml", "http://www.example.com/index.html", "The Great Foo");
Input input = new Input();
resolver.resolve(xid, input);
Assert.assertEquals(input.getUri(), "http://www.example.com/bar.xml");
}
static String resourceUri(String fileName) {
String className = CatalogResolverTest.class.getName();
int dotIndex = className.lastIndexOf('.');
String resourceName = className.substring(0, dotIndex + 1).replace('.', '/') + fileName;
return CatalogResolverTest.class.getClassLoader().getResource(resourceName).toString();
}
}
jing-trang-20181222+dfsg2/mod/catalog/src/test/com/thaiopensource/resolver/catalog/catalog.xml 0000664 0000000 0000000 00000000402 13520105541 0032162 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/catalog/src/test/com/thaiopensource/resolver/catalog/catalog2.xml 0000664 0000000 0000000 00000000443 13520105541 0032251 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/convert-from-dtd/ 0000775 0000000 0000000 00000000000 13520105541 0020763 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/mod.xml 0000664 0000000 0000000 00000000233 13520105541 0022262 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/ 0000775 0000000 0000000 00000000000 13520105541 0021552 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/ 0000775 0000000 0000000 00000000000 13520105541 0022476 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/ 0000775 0000000 0000000 00000000000 13520105541 0023254 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0026304 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/ 0000775 0000000 0000000 00000000000 13520105541 0027744 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/ 0000775 0000000 0000000 00000000000 13520105541 0031103 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/dtd/ 0000775 0000000 0000000 00000000000 13520105541 0031656 5 ustar 00root root 0000000 0000000 Converter.java 0000664 0000000 0000000 00000107005 13520105541 0034414 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/dtd package com.thaiopensource.relaxng.input.dtd;
import com.thaiopensource.relaxng.edit.Annotated;
import com.thaiopensource.relaxng.edit.AnyNameNameClass;
import com.thaiopensource.relaxng.edit.AttributeAnnotation;
import com.thaiopensource.relaxng.edit.AttributePattern;
import com.thaiopensource.relaxng.edit.ChoicePattern;
import com.thaiopensource.relaxng.edit.Combine;
import com.thaiopensource.relaxng.edit.Comment;
import com.thaiopensource.relaxng.edit.Component;
import com.thaiopensource.relaxng.edit.CompositePattern;
import com.thaiopensource.relaxng.edit.DataPattern;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.ElementPattern;
import com.thaiopensource.relaxng.edit.EmptyPattern;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.GroupPattern;
import com.thaiopensource.relaxng.edit.IncludeComponent;
import com.thaiopensource.relaxng.edit.NameClass;
import com.thaiopensource.relaxng.edit.NameNameClass;
import com.thaiopensource.relaxng.edit.NotAllowedPattern;
import com.thaiopensource.relaxng.edit.OneOrMorePattern;
import com.thaiopensource.relaxng.edit.OptionalPattern;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.RefPattern;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.edit.SchemaDocument;
import com.thaiopensource.relaxng.edit.TextPattern;
import com.thaiopensource.relaxng.edit.ValuePattern;
import com.thaiopensource.relaxng.edit.ZeroOrMorePattern;
import com.thaiopensource.relaxng.input.CommentTrimmer;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import com.thaiopensource.xml.dtd.om.AttributeDefault;
import com.thaiopensource.xml.dtd.om.AttributeGroup;
import com.thaiopensource.xml.dtd.om.AttributeGroupMember;
import com.thaiopensource.xml.dtd.om.AttributeGroupVisitor;
import com.thaiopensource.xml.dtd.om.Datatype;
import com.thaiopensource.xml.dtd.om.DatatypeVisitor;
import com.thaiopensource.xml.dtd.om.Def;
import com.thaiopensource.xml.dtd.om.Dtd;
import com.thaiopensource.xml.dtd.om.EnumGroup;
import com.thaiopensource.xml.dtd.om.EnumGroupVisitor;
import com.thaiopensource.xml.dtd.om.Flag;
import com.thaiopensource.xml.dtd.om.ModelGroup;
import com.thaiopensource.xml.dtd.om.ModelGroupVisitor;
import com.thaiopensource.xml.dtd.om.NameSpec;
import com.thaiopensource.xml.dtd.om.TokenizedDatatype;
import com.thaiopensource.xml.dtd.om.TopLevel;
import com.thaiopensource.xml.dtd.om.TopLevelVisitor;
import com.thaiopensource.xml.em.ExternalId;
import com.thaiopensource.xml.util.WellKnownNamespaces;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
public class Converter {
static class Options {
boolean inlineAttlistDecls;
boolean generateStart = true;
boolean strictAny;
String elementDeclPattern;
String attlistDeclPattern;
String colonReplacement;
String anyName;
String annotationPrefix;
String defaultNamespace;
final Map prefixMap = new HashMap();
}
private final Dtd dtd;
private final ErrorReporter er;
private final SchemaCollection sc = new SchemaCollection();
private final Options options;
/**
* true if any uses of ANY have been encountered in the DTD
*/
private boolean hadAny = false;
/**
* true if any default values have been encountered in the DTD
*/
private boolean hadDefaultValue = false;
/**
* Maps each element name to an Integer containing a set of flags.
*/
private final Map elementNameTable = new HashMap();
/**
* Maps each element name to a List of attribute groups of each attlist declaration.
*/
private final Map> attlistDeclTable = new HashMap>();
/**
* Set of strings representing names for which there are definitions in the DTD.
*/
private final Set definedNames = new HashSet();
/**
* Maps prefixes to namespace URIs.
*/
private final Map prefixTable = new HashMap();
/**
* Maps a string representing an element name to the set of names of attributes
* that have been declated for that element.
*/
private final Map> attributeNamesTable = new HashMap>();
/**
* Contains the set of attribute names that have already been output in the current scope.
*/
private Set attributeNames = null;
private String defaultNamespace = null;
private String annotationPrefix = null;
// These variables control the names use for definitions.
private String colonReplacement = null;
private String elementDeclPattern = null;
private String attlistDeclPattern = null;
private String anyName = null;
/**
* Flags for element names used in elementDeclTable.
*/
private static final int ELEMENT_DECL = 01;
private static final int ATTLIST_DECL = 02;
private static final int ELEMENT_REF = 04;
/**
* Characters that will be considered for use as a replacement for colon in
* a QName. Also used as separators in constructing names of definitions
* corresponding to element declarations and attlist declarations,
*/
private static final String SEPARATORS = ".-_";
// # is the category; % is the name in the category
private static final String DEFAULT_PATTERN = "#.%";
private final String[] ELEMENT_KEYWORDS = {
"element", "elem", "e"
};
private final String[] ATTLIST_KEYWORDS = {
"attlist", "attributes", "attribs", "atts", "a"
};
private final String[] ANY_KEYWORDS = {
"any", "ANY", "anyElement"
};
private static abstract class VisitorBase implements TopLevelVisitor {
public void processingInstruction(String target, String value) throws Exception { }
public void comment(String value) throws Exception { }
public void flagDef(String name, Flag flag) throws Exception { }
public void includedSection(Flag flag, TopLevel[] contents)
throws Exception {
for (int i = 0; i < contents.length; i++)
contents[i].accept(this);
}
public void ignoredSection(Flag flag, String contents) throws Exception { }
public void internalEntityDecl(String name, String value) throws Exception { }
public void externalEntityDecl(String name, ExternalId externalId) throws Exception { }
public void notationDecl(String name, ExternalId externalId) throws Exception { }
public void nameSpecDef(String name, NameSpec nameSpec) throws Exception { }
public void overriddenDef(Def def, boolean isDuplicate) throws Exception { }
public void externalIdDef(String name, ExternalId externalId) throws Exception { }
public void externalIdRef(String name, ExternalId externalId,
String uri, String encoding, TopLevel[] contents)
throws Exception {
for (int i = 0; i < contents.length; i++)
contents[i].accept(this);
}
public void paramDef(String name, String value) throws Exception { }
public void attributeDefaultDef(String name, AttributeDefault ad) throws Exception { }
}
private class Analyzer extends VisitorBase implements ModelGroupVisitor,
AttributeGroupVisitor {
public void elementDecl(NameSpec nameSpec, ModelGroup modelGroup)
throws Exception {
noteElementName(nameSpec.getValue(), ELEMENT_DECL);
modelGroup.accept(this);
}
public void attlistDecl(NameSpec nameSpec, AttributeGroup attributeGroup)
throws Exception {
noteElementName(nameSpec.getValue(), ATTLIST_DECL);
noteAttlist(nameSpec.getValue(), attributeGroup);
attributeGroup.accept(this);
}
public void modelGroupDef(String name, ModelGroup modelGroup)
throws Exception {
noteDef(name);
modelGroup.accept(this);
}
public void attributeGroupDef(String name, AttributeGroup attributeGroup)
throws Exception {
noteDef(name);
attributeGroup.accept(this);
}
public void enumGroupDef(String name, EnumGroup enumGroup) {
noteDef(name);
}
public void datatypeDef(String name, Datatype datatype) {
noteDef(name);
}
public void choice(ModelGroup[] members) throws Exception {
for (int i = 0; i < members.length; i++)
members[i].accept(this);
}
public void sequence(ModelGroup[] members) throws Exception {
for (int i = 0; i < members.length; i++)
members[i].accept(this);
}
public void oneOrMore(ModelGroup member) throws Exception {
member.accept(this);
}
public void zeroOrMore(ModelGroup member) throws Exception {
member.accept(this);
}
public void optional(ModelGroup member) throws Exception {
member.accept(this);
}
public void modelGroupRef(String name, ModelGroup modelGroup) {
}
public void elementRef(NameSpec name) {
noteElementName(name.getValue(), ELEMENT_REF);
}
public void pcdata() {
}
public void any() {
hadAny = true;
}
public void attribute(NameSpec nameSpec,
Datatype datatype,
AttributeDefault attributeDefault) {
noteAttribute(nameSpec.getValue(), attributeDefault.getDefaultValue());
}
public void attributeGroupRef(String name, AttributeGroup attributeGroup) {
}
}
private class ComponentOutput extends VisitorBase {
private final List components;
private final Annotated grammar;
private List comments = null;
ComponentOutput(GrammarPattern grammar) {
components = grammar.getComponents();
this.grammar = grammar;
}
void finish() {
if (comments != null)
grammar.getFollowingElementAnnotations().addAll(comments);
}
private void addComponent(Component c) {
if (comments != null) {
if (components.isEmpty())
grammar.getLeadingComments().addAll(comments);
else
c.getLeadingComments().addAll(comments);
comments = null;
}
components.add(c);
}
public void elementDecl(NameSpec nameSpec, ModelGroup modelGroup) throws Exception {
GroupPattern gp = new GroupPattern();
if (options.inlineAttlistDecls) {
List groups = attlistDeclTable.get(nameSpec.getValue());
if (groups != null) {
attributeNames = new HashSet();
AttributeGroupVisitor agv = new AttributeGroupOutput(gp);
for (AttributeGroup group : groups)
group.accept(agv);
}
}
else
gp.getChildren().add(ref(attlistDeclName(nameSpec.getValue())));
Pattern pattern = convert(modelGroup);
if (gp.getChildren().size() > 0) {
if (pattern instanceof GroupPattern)
gp.getChildren().addAll(((GroupPattern)pattern).getChildren());
else
gp.getChildren().add(pattern);
pattern = gp;
}
addComponent(new DefineComponent(elementDeclName(nameSpec.getValue()),
new ElementPattern(convertQName(nameSpec.getValue(), true),
pattern)));
if (!options.inlineAttlistDecls && (nameFlags(nameSpec.getValue()) & ATTLIST_DECL) == 0) {
DefineComponent dc = new DefineComponent(attlistDeclName(nameSpec.getValue()), new EmptyPattern());
dc.setCombine(Combine.INTERLEAVE);
addComponent(dc);
}
if (anyName != null && options.strictAny) {
DefineComponent dc = new DefineComponent(anyName, ref(elementDeclName(nameSpec.getValue())));
dc.setCombine(Combine.CHOICE);
addComponent(dc);
}
}
public void attlistDecl(NameSpec nameSpec, AttributeGroup attributeGroup) throws Exception {
if (options.inlineAttlistDecls)
return;
String name = nameSpec.getValue();
attributeNames
= attributeNamesTable.get(name);
if (attributeNames == null) {
attributeNames = new HashSet();
attributeNamesTable.put(name, attributeNames);
}
Pattern pattern = convert(attributeGroup);
if (pattern instanceof EmptyPattern) {
// Only keep an empty definition if this is the first attlist for this element,
// and all attlists are also empty. In this case, if we didn't keep the
// definition, we would have no definition for the attlist.
List decls = attlistDeclTable.get(name);
if (decls.get(0) != attributeGroup)
return;
attributeNames = new HashSet();
for (int i = 1, len = decls.size(); i < len; i++)
if (!(convert(decls.get(i)) instanceof EmptyPattern))
return;
}
DefineComponent dc = new DefineComponent(attlistDeclName(name), pattern);
dc.setCombine(Combine.INTERLEAVE);
addComponent(dc);
}
public void modelGroupDef(String name, ModelGroup modelGroup)
throws Exception {
addComponent(new DefineComponent(name, convert(modelGroup)));
}
public void attributeGroupDef(String name, AttributeGroup attributeGroup)
throws Exception {
// This takes care of duplicates within the group
attributeNames = new HashSet();
Pattern pattern;
AttributeGroupMember[] members = attributeGroup.getMembers();
GroupPattern group = new GroupPattern();
AttributeGroupVisitor agv = new AttributeGroupOutput(group);
for (int i = 0; i < members.length; i++)
members[i].accept(agv);
switch (group.getChildren().size()) {
case 0:
pattern = new EmptyPattern();
break;
case 1:
pattern = group.getChildren().get(0);
break;
default:
pattern = group;
break;
}
addComponent(new DefineComponent(name, pattern));
}
public void enumGroupDef(String name, EnumGroup enumGroup) throws Exception {
ChoicePattern choice = new ChoicePattern();
enumGroup.accept(new EnumGroupOutput(choice));
Pattern pattern;
switch (choice.getChildren().size()) {
case 0:
pattern = new NotAllowedPattern();
break;
case 1:
pattern = choice.getChildren().get(0);
break;
default:
pattern = choice;
break;
}
addComponent(new DefineComponent(name, pattern));
}
public void datatypeDef(String name, Datatype datatype) throws Exception {
addComponent(new DefineComponent(name, convert(datatype)));
}
public void comment(String value) {
if (comments == null)
comments = new Vector();
comments.add(new Comment(CommentTrimmer.trimComment(value)));
}
public void externalIdRef(String name, ExternalId externalId,
String uri, String encoding, TopLevel[] contents)
throws Exception {
if (uri == null) {
// I don't think this can happen
super.externalIdRef(name, externalId, uri, encoding, contents);
return;
}
SignificanceDetector sd = new SignificanceDetector();
try {
sd.externalIdRef(name, externalId, uri, encoding, contents);
if (!sd.significant)
return;
}
catch (Exception e) {
throw (RuntimeException)e;
}
if (sc.getSchemaDocumentMap().get(uri) != null) {
// I don't think this can happen because the second and subsequent inclusions
// will never pass the SignificanceDetector, but just in case
super.externalIdRef(name, externalId, uri, encoding, contents);
return;
}
IncludeComponent ic = new IncludeComponent(uri);
ic.setNs(defaultNamespace);
addComponent(ic);
GrammarPattern included = new GrammarPattern();
ComponentOutput co = new ComponentOutput(included);
for (int i = 0; i < contents.length; i++)
contents[i].accept(co);
co.finish();
sc.getSchemaDocumentMap().put(uri, new SchemaDocument(included, encoding));
}
}
private class AttributeGroupOutput implements AttributeGroupVisitor {
final List group;
AttributeGroupOutput(GroupPattern gp) {
group = gp.getChildren();
}
public void attribute(NameSpec nameSpec,
Datatype datatype,
AttributeDefault attributeDefault) throws Exception {
String name = nameSpec.getValue();
if (attributeNames.contains(name))
return;
attributeNames.add(name);
if (name.equals("xmlns") || name.startsWith("xmlns:"))
return;
String dv = attributeDefault.getDefaultValue();
String fv = attributeDefault.getFixedValue();
Pattern dt;
if (fv != null) {
String[] typeName = valueType(datatype);
dt = new ValuePattern(typeName[0], typeName[1], fv);
}
else if (datatype.getType() != Datatype.CDATA)
dt = convert(datatype);
else
dt = new TextPattern();
AttributePattern pattern = new AttributePattern(convertQName(name, false), dt);
if (dv != null) {
AttributeAnnotation anno = new AttributeAnnotation(WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS, "defaultValue", dv);
anno.setPrefix(annotationPrefix);
pattern.getAttributeAnnotations().add(anno);
}
if (!attributeDefault.isRequired())
group.add(new OptionalPattern(pattern));
else
group.add(pattern);
}
public void attributeGroupRef(String name, AttributeGroup attributeGroup)
throws Exception {
DuplicateAttributeDetector detector = new DuplicateAttributeDetector();
attributeGroup.accept(detector);
if (detector.containsDuplicate)
attributeGroup.accept(this);
else {
group.add(ref(name));
attributeNames.addAll(detector.names);
}
}
}
private class DatatypeOutput implements DatatypeVisitor {
Pattern pattern;
public void cdataDatatype() {
pattern = new DataPattern("", "string");
}
public void tokenizedDatatype(String typeName) {
pattern = new DataPattern(WellKnownNamespaces.XML_SCHEMA_DATATYPES, typeName);
}
public void enumDatatype(EnumGroup enumGroup) throws Exception {
if (enumGroup.getMembers().length == 0)
pattern = new NotAllowedPattern();
else {
ChoicePattern tem = new ChoicePattern();
pattern = tem;
enumGroup.accept(new EnumGroupOutput(tem));
}
}
public void notationDatatype(EnumGroup enumGroup) throws Exception {
enumDatatype(enumGroup);
}
public void datatypeRef(String name, Datatype datatype) {
pattern = ref(name);
}
}
private class EnumGroupOutput implements EnumGroupVisitor {
final private List list;
EnumGroupOutput(ChoicePattern choice) {
list = choice.getChildren();
}
public void enumValue(String value) {
list.add(new ValuePattern("", "token", value));
}
public void enumGroupRef(String name, EnumGroup enumGroup) {
list.add(ref(name));
}
}
private class ModelGroupOutput implements ModelGroupVisitor {
private Pattern pattern;
public void choice(ModelGroup[] members) throws Exception {
if (members.length == 0)
pattern = new NotAllowedPattern();
else if (members.length == 1)
members[0].accept(this);
else {
ChoicePattern tem = new ChoicePattern();
pattern = tem;
List children = tem.getChildren();
for (int i = 0; i < members.length; i++)
children.add(convert(members[i]));
}
}
public void sequence(ModelGroup[] members) throws Exception {
if (members.length == 0)
pattern = new EmptyPattern();
else if (members.length == 1)
members[0].accept(this);
else {
GroupPattern tem = new GroupPattern();
pattern = tem;
List children = tem.getChildren();
for (int i = 0; i < members.length; i++)
children.add(convert(members[i]));
}
}
public void oneOrMore(ModelGroup member) throws Exception {
pattern = new OneOrMorePattern(convert(member));
}
public void zeroOrMore(ModelGroup member) throws Exception {
pattern = new ZeroOrMorePattern(convert(member));
}
public void optional(ModelGroup member) throws Exception {
pattern = new OptionalPattern(convert(member));
}
public void modelGroupRef(String name, ModelGroup modelGroup) {
pattern = ref(name);
}
public void elementRef(NameSpec name) {
pattern = ref(elementDeclName(name.getValue()));
}
public void pcdata() {
pattern = new TextPattern();
}
public void any() {
pattern = ref(anyName);
if (options.strictAny)
pattern = new ZeroOrMorePattern(pattern);
}
}
private class DuplicateAttributeDetector implements AttributeGroupVisitor {
private boolean containsDuplicate = false;
private final List names = new Vector();
public void attribute(NameSpec nameSpec,
Datatype datatype,
AttributeDefault attributeDefault) {
String name = nameSpec.getValue();
if (attributeNames.contains(name))
containsDuplicate = true;
names.add(name);
}
public void attributeGroupRef(String name, AttributeGroup attributeGroup) throws Exception {
attributeGroup.accept(this);
}
}
private class SignificanceDetector extends VisitorBase {
boolean significant = false;
public void elementDecl(NameSpec nameSpec, ModelGroup modelGroup)
throws Exception {
significant = true;
}
public void attlistDecl(NameSpec nameSpec, AttributeGroup attributeGroup)
throws Exception {
significant = true;
}
public void modelGroupDef(String name, ModelGroup modelGroup)
throws Exception {
significant = true;
}
public void attributeGroupDef(String name, AttributeGroup attributeGroup)
throws Exception {
significant = true;
}
public void enumGroupDef(String name, EnumGroup enumGroup) {
significant = true;
}
public void datatypeDef(String name, Datatype datatype) {
significant = true;
}
}
public Converter(Dtd dtd, ErrorReporter er, Options options) {
this.dtd = dtd;
this.er = er;
this.options = options;
}
public SchemaCollection convert() {
try {
dtd.accept(new Analyzer());
chooseNames();
GrammarPattern grammar = new GrammarPattern();
sc.setMainUri(dtd.getUri());
sc.getSchemaDocumentMap().put(dtd.getUri(),
new SchemaDocument(grammar, dtd.getEncoding()));
ComponentOutput co = new ComponentOutput(grammar);
dtd.accept(co);
outputUndefinedElements(grammar.getComponents());
if (options.generateStart)
outputStart(grammar.getComponents());
outputAny(grammar.getComponents());
co.finish();
return sc;
}
catch (Exception e) {
throw (RuntimeException)e;
}
}
private void chooseNames() {
chooseAny();
chooseColonReplacement();
chooseDeclPatterns();
choosePrefixes();
chooseAnnotationPrefix();
}
private void chooseAny() {
if (!hadAny)
return;
if (options.anyName != null) {
if (!definedNames.contains(options.anyName)) {
anyName = options.anyName;
definedNames.add(anyName);
return;
}
warning("cannot_use_any_name");
}
for (int n = 0;; n++) {
for (int i = 0; i < ANY_KEYWORDS.length; i++) {
anyName = repeatChar('_', n) + ANY_KEYWORDS[i];
if (!definedNames.contains(anyName)) {
definedNames.add(anyName);
return;
}
}
}
}
private void choosePrefixes() {
if (options.defaultNamespace != null) {
if (defaultNamespace != null && !defaultNamespace.equals(options.defaultNamespace))
warning("default_namespace_conflict");
defaultNamespace = options.defaultNamespace;
}
else if (defaultNamespace == null)
defaultNamespace = NameClass.INHERIT_NS;
for (Map.Entry entry : options.prefixMap.entrySet()) {
String prefix = entry.getKey();
String ns = entry.getValue();
String s = prefixTable.get(prefix);
if (s == null)
warning("irrelevant_prefix", prefix);
else {
if (!s.equals("") && !s.equals(ns))
warning("prefix_conflict", prefix);
prefixTable.put(prefix, ns);
}
}
}
private void chooseAnnotationPrefix() {
if (!hadDefaultValue)
return;
if (options.annotationPrefix != null) {
if (prefixTable.get(options.annotationPrefix) == null) {
annotationPrefix = options.annotationPrefix;
return;
}
warning("cannot_use_annotation_prefix");
}
for (int n = 0;; n++) {
annotationPrefix = repeatChar('_', n) + "a";
if (prefixTable.get(annotationPrefix) == null)
return;
}
}
private void chooseColonReplacement() {
if (options.colonReplacement != null) {
colonReplacement = options.colonReplacement;
if (colonReplacementOk())
return;
warning("cannot_use_colon_replacement");
colonReplacement = null;
}
if (colonReplacementOk())
return;
for (int n = 1;; n++) {
for (int i = 0; i < SEPARATORS.length(); i++) {
colonReplacement = repeatChar(SEPARATORS.charAt(i), n);
if (colonReplacementOk())
return;
}
}
}
private boolean colonReplacementOk() {
Set names = new HashSet();
for (String s : elementNameTable.keySet()) {
String name = mungeQName(s);
if (names.contains(name))
return false;
names.add(name);
}
return true;
}
private void chooseDeclPatterns() {
if (options.elementDeclPattern != null) {
if (patternOk(options.elementDeclPattern, null))
elementDeclPattern = options.elementDeclPattern;
else
warning("cannot_use_element_decl_pattern");
}
if (options.attlistDeclPattern != null) {
if (patternOk(options.attlistDeclPattern, elementDeclPattern))
attlistDeclPattern = options.attlistDeclPattern;
else
warning("cannot_use_attlist_decl_pattern");
}
if (elementDeclPattern != null && attlistDeclPattern != null)
return;
// XXX Try to match length and case of best prefix
String pattern = namingPattern();
if (elementDeclPattern == null) {
if (patternOk("%", attlistDeclPattern))
elementDeclPattern = "%";
else
elementDeclPattern = choosePattern(pattern, ELEMENT_KEYWORDS, attlistDeclPattern);
}
if (attlistDeclPattern == null)
attlistDeclPattern = choosePattern(pattern, ATTLIST_KEYWORDS, elementDeclPattern);
}
private String choosePattern(String metaPattern, String[] keywords, String otherPattern) {
for (;;) {
for (int i = 0; i < keywords.length; i++) {
String pattern = substitute(metaPattern, '#', keywords[i]);
if (patternOk(pattern, otherPattern))
return pattern;
}
// add another separator
metaPattern = (metaPattern.substring(0, 1)
+ metaPattern.substring(1, 2)
+ metaPattern.substring(1, 2)
+ metaPattern.substring(2));
}
}
private String namingPattern() {
Map patternTable = new HashMap();
for (String name : definedNames) {
for (int i = 0; i < SEPARATORS.length(); i++) {
char sep = SEPARATORS.charAt(i);
int k = name.indexOf(sep);
if (k > 0)
inc(patternTable, name.substring(0, k + 1) + "%");
k = name.lastIndexOf(sep);
if (k >= 0 && k < name.length() - 1)
inc(patternTable, "%" + name.substring(k));
}
}
String bestPattern = null;
int bestCount = 0;
for (Map.Entry entry : patternTable.entrySet()) {
int count = entry.getValue();
if (bestPattern == null || count > bestCount) {
bestCount = count;
bestPattern = entry.getKey();
}
}
if (bestPattern == null)
return DEFAULT_PATTERN;
if (bestPattern.charAt(0) == '%')
return bestPattern.substring(0, 2) + "#";
else
return "#" + bestPattern.substring(bestPattern.length() - 2);
}
private static void inc(Map table, String str) {
Integer n = table.get(str);
if (n == null)
table.put(str, 1);
else
table.put(str, n + 1);
}
private boolean patternOk(String pattern, String otherPattern) {
Set usedNames = new HashSet();
for (String s : elementNameTable.keySet()) {
String name = mungeQName(s);
String declName = substitute(pattern, '%', name);
if (definedNames.contains(declName))
return false;
if (otherPattern != null) {
String otherDeclName = substitute(otherPattern, '%', name);
if (usedNames.contains(declName)
|| usedNames.contains(otherDeclName)
|| declName.equals(otherDeclName))
return false;
usedNames.add(declName);
usedNames.add(otherDeclName);
}
}
return true;
}
private void noteDef(String name) {
definedNames.add(name);
}
private void noteElementName(String name, int flags) {
Integer n = elementNameTable.get(name);
if (n != null) {
flags |= n;
if (n == flags)
return;
}
else
noteNamePrefix(name);
elementNameTable.put(name, flags);
}
private void noteAttlist(String name, AttributeGroup group) {
List groups = attlistDeclTable.get(name);
if (groups == null) {
groups = new Vector();
attlistDeclTable.put(name, groups);
}
groups.add(group);
}
private void noteAttribute(String name, String defaultValue) {
if (name.equals("xmlns")) {
if (defaultValue != null) {
if (defaultNamespace != null
&& !defaultNamespace.equals(defaultValue))
error("INCONSISTENT_DEFAULT_NAMESPACE");
else
defaultNamespace = defaultValue;
}
}
else if (name.startsWith("xmlns:")) {
if (defaultValue != null) {
String prefix = name.substring(6);
String ns = prefixTable.get(prefix);
if (ns != null
&& !ns.equals("")
&& !ns.equals(defaultValue))
error("INCONSISTENT_PREFIX", prefix);
else if (!prefix.equals("xml"))
prefixTable.put(prefix, defaultValue);
}
}
else {
if (defaultValue != null)
hadDefaultValue = true;
noteNamePrefix(name);
}
}
private void noteNamePrefix(String name) {
int i = name.indexOf(':');
if (i < 0)
return;
String prefix = name.substring(0, i);
if (prefixTable.get(prefix) == null && !prefix.equals("xml"))
prefixTable.put(prefix, "");
}
private int nameFlags(String name) {
Integer n = elementNameTable.get(name);
if (n == null)
return 0;
return n;
}
private String elementDeclName(String name) {
return substitute(elementDeclPattern, '%', mungeQName(name));
}
private String attlistDeclName(String name) {
return substitute(attlistDeclPattern, '%', mungeQName(name));
}
private String mungeQName(String name) {
if (colonReplacement == null) {
int i = name.indexOf(':');
if (i < 0)
return name;
return name.substring(i + 1);
}
return substitute(name, ':', colonReplacement);
}
private static String repeatChar(char c, int n) {
char[] buf = new char[n];
for (int i = 0; i < n; i++)
buf[i] = c;
return new String(buf);
}
/* Replace the first occurrence of ch in pattern by value. */
private static String substitute(String pattern, char ch, String value) {
int i = pattern.indexOf(ch);
if (i < 0)
return pattern;
StringBuffer buf = new StringBuffer();
buf.append(pattern.substring(0, i));
buf.append(value);
buf.append(pattern.substring(i + 1));
return buf.toString();
}
private void outputStart(List components) {
ChoicePattern choice = new ChoicePattern();
// Use the defined but unreferenced elements.
// If there aren't any, use all defined elements.
int mask = ELEMENT_REF|ELEMENT_DECL;
for (;;) {
boolean gotOne = false;
for (Map.Entry entry : elementNameTable.entrySet()) {
if ((entry.getValue() & mask) == ELEMENT_DECL) {
gotOne = true;
choice.getChildren().add(ref(elementDeclName(entry.getKey())));
}
}
if (gotOne)
break;
if (mask == ELEMENT_DECL)
return;
mask = ELEMENT_DECL;
}
components.add(new DefineComponent(DefineComponent.START, choice));
}
private void outputAny(List components) {
if (!hadAny)
return;
if (options.strictAny) {
DefineComponent dc = new DefineComponent(anyName, new TextPattern());
dc.setCombine(Combine.CHOICE);
components.add(dc);
}
else {
// any = (element * { attribute * { text }*, any } | text)*
CompositePattern group = new GroupPattern();
group.getChildren().add(new ZeroOrMorePattern(new AttributePattern(new AnyNameNameClass(),
new TextPattern())));
group.getChildren().add(ref(anyName));
CompositePattern choice = new ChoicePattern();
choice.getChildren().add(new ElementPattern(new AnyNameNameClass(), group));
choice.getChildren().add(new TextPattern());
components.add(new DefineComponent(anyName, new ZeroOrMorePattern(choice)));
}
}
private void outputUndefinedElements(List components) {
List elementNames = new Vector();
elementNames.addAll(elementNameTable.keySet());
Collections.sort(elementNames);
for (String elementName : elementNames) {
if ((elementNameTable.get(elementName) & ELEMENT_DECL) == 0) {
DefineComponent dc = new DefineComponent(elementDeclName(elementName), new NotAllowedPattern());
dc.setCombine(Combine.CHOICE);
components.add(dc);
}
}
}
static private Pattern ref(String name) {
return new RefPattern(name);
}
private void error(String key) {
er.error(key, null);
}
private void error(String key, String arg) {
er.error(key, arg, null);
}
private void warning(String key) {
er.warning(key, null);
}
private void warning(String key, String arg) {
er.warning(key, arg, null);
}
private static String[] valueType(Datatype datatype) {
datatype = datatype.deref();
switch (datatype.getType()) {
case Datatype.CDATA:
return new String[] { "", "string" };
case Datatype.TOKENIZED:
return new String[] { WellKnownNamespaces.XML_SCHEMA_DATATYPES, ((TokenizedDatatype)datatype).getTypeName() };
}
return new String[] { "", "token" };
}
private Pattern convert(ModelGroup mg) throws Exception {
ModelGroupOutput mgo = new ModelGroupOutput();
mg.accept(mgo);
return mgo.pattern;
}
private Pattern convert(Datatype dt) throws Exception {
DatatypeOutput dto = new DatatypeOutput();
dt.accept(dto);
return dto.pattern;
}
private Pattern convert(AttributeGroup ag) throws Exception {
GroupPattern group = new GroupPattern();
ag.accept(new AttributeGroupOutput(group));
switch (group.getChildren().size()) {
case 0:
return new EmptyPattern();
case 1:
return group.getChildren().get(0);
}
return group;
}
private NameClass convertQName(String name, boolean useDefault) {
int i = name.indexOf(':');
if (i < 0)
return new NameNameClass(useDefault ? defaultNamespace : "", name);
String prefix = name.substring(0, i);
String localName = name.substring(i + 1);
String ns;
if (prefix.equals("xml"))
ns = WellKnownNamespaces.XML;
else {
ns = prefixTable.get(prefix);
if (ns.equals("")) {
error("UNDECLARED_PREFIX", prefix);
ns = "##" + prefix;
prefixTable.put(prefix, ns);
}
}
NameNameClass nnc = new NameNameClass(ns, localName);
nnc.setPrefix(prefix);
return nnc;
}
}
DtdInputFormat.java 0000664 0000000 0000000 00000013751 13520105541 0035355 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/dtd package com.thaiopensource.relaxng.input.dtd;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.input.InputFormat;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import com.thaiopensource.relaxng.translate.util.AbsoluteUriParam;
import com.thaiopensource.relaxng.translate.util.AbstractParam;
import com.thaiopensource.relaxng.translate.util.InvalidParamValueException;
import com.thaiopensource.relaxng.translate.util.InvalidParamsException;
import com.thaiopensource.relaxng.translate.util.NCNameParam;
import com.thaiopensource.relaxng.translate.util.NmtokenParam;
import com.thaiopensource.relaxng.translate.util.Param;
import com.thaiopensource.relaxng.translate.util.ParamFactory;
import com.thaiopensource.relaxng.translate.util.ParamProcessor;
import com.thaiopensource.resolver.Resolver;
import com.thaiopensource.util.Localizer;
import com.thaiopensource.xml.dtd.om.Dtd;
import com.thaiopensource.xml.dtd.parse.DtdParserImpl;
import com.thaiopensource.xml.dtd.parse.ParseException;
import com.thaiopensource.xml.em.EntityManager;
import com.thaiopensource.xml.em.ResolverUriEntityManager;
import com.thaiopensource.xml.em.UriEntityManager;
import com.thaiopensource.xml.util.Naming;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
import java.io.IOException;
import java.util.Map;
public class DtdInputFormat implements InputFormat {
static private class NamespaceDeclParamFactory implements ParamFactory {
private final Map prefixMap;
NamespaceDeclParamFactory(Map prefixMap) {
this.prefixMap = prefixMap;
}
public Param createParam(String name) {
if (!name.startsWith("xmlns:"))
return null;
final String prefix = name.substring(6);
if (!Naming.isNcname(prefix))
return null;
return new AbsoluteUriParam() {
public void setAbsoluteUri(String uri) {
prefixMap.put(prefix, uri);
}
};
}
}
static private abstract class DeclPatternParam extends AbstractParam {
private final Localizer localizer;
DeclPatternParam(Localizer localizer) {
this.localizer = localizer;
}
public void set(String value) throws InvalidParamValueException {
if (value.indexOf('%') < 0)
throw new InvalidParamValueException(localizer.message("no_percent"));
if (value.lastIndexOf('%') != value.indexOf('%'))
throw new InvalidParamValueException(localizer.message("multiple_percent"));
if (!Naming.isNcname(value.replace('%', 'x')))
throw new InvalidParamValueException(localizer.message("not_ncname_with_percent"));
setDeclPattern(value);
}
abstract void setDeclPattern(String pattern);
}
public SchemaCollection load(String uri, String[] params, String outputFormat, ErrorHandler eh, Resolver resolver)
throws InvalidParamsException, IOException, SAXException {
final ErrorReporter er = new ErrorReporter(eh, DtdInputFormat.class);
final Converter.Options options = new Converter.Options();
if ("xsd".equals(outputFormat)) {
options.inlineAttlistDecls = true;
options.generateStart = false;
}
ParamProcessor pp = new ParamProcessor();
pp.declare("inline-attlist",
new AbstractParam() {
public void set(boolean value) {
options.inlineAttlistDecls = value;
}
});
pp.declare("xmlns",
new AbsoluteUriParam() {
public void set(String value) throws InvalidParamValueException {
if (value.equals(""))
setAbsoluteUri(value);
else
super.set(value);
}
protected void setAbsoluteUri(String value) {
options.defaultNamespace = value;
}
});
pp.declare("any-name",
new NCNameParam() {
protected void setNCName(String value) {
options.anyName = value;
}
});
pp.declare("strict-any",
new AbstractParam() {
public void set(boolean value) {
options.strictAny = value;
}
});
pp.declare("annotation-prefix",
new NCNameParam() {
protected void setNCName(String value) {
options.annotationPrefix = value;
}
});
pp.declare("colon-replacement",
new NmtokenParam() {
protected void setNmtoken(String value) {
options.colonReplacement = value;
}
});
pp.declare("generate-start",
new AbstractParam() {
public void set(boolean value) {
options.generateStart = value;
}
});
pp.declare("element-define",
new DeclPatternParam(er.getLocalizer()) {
void setDeclPattern(String pattern) {
options.elementDeclPattern = pattern;
}
});
pp.declare("attlist-define",
new DeclPatternParam(er.getLocalizer()) {
void setDeclPattern(String pattern) {
options.attlistDeclPattern = pattern;
}
});
pp.setParamFactory(new NamespaceDeclParamFactory(options.prefixMap));
pp.process(params, eh);
try {
EntityManager em = resolver != null? new ResolverUriEntityManager(resolver): new UriEntityManager();
Dtd dtd = new DtdParserImpl().parse(uri, em);
try {
return new Converter(dtd, er, options).convert();
}
catch (ErrorReporter.WrappedSAXException e) {
throw e.getException();
}
}
catch (ParseException e) {
throw new SAXParseException(e.getMessageBody(), null, e.getLocation(), e.getLineNumber(), e.getColumnNumber());
}
}
}
ResolverEntityManager.java 0000664 0000000 0000000 00000005336 13520105541 0036742 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/dtd package com.thaiopensource.relaxng.input.dtd;
import com.thaiopensource.resolver.Input;
import com.thaiopensource.resolver.Resolver;
import com.thaiopensource.resolver.ResolverException;
import com.thaiopensource.resolver.xml.ExternalEntityIdentifier;
import com.thaiopensource.xml.em.EntityManager;
import com.thaiopensource.xml.em.ExternalId;
import com.thaiopensource.xml.em.OpenEntity;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.Reader;
/**
*
*/
public class ResolverEntityManager extends EntityManager {
private final Resolver resolver;
public ResolverEntityManager(Resolver resolver) {
this.resolver = resolver;
}
public OpenEntity open(String systemId) throws IOException {
Input input = new Input();
input.setUri(systemId);
try {
return open(input);
}
catch (ResolverException e) {
throw toIOException(e);
}
}
public OpenEntity open(ExternalId xid, boolean isParameterEntity, String entityName) throws IOException {
Input input = new Input();
if (isParameterEntity)
entityName = "%" + entityName;
try {
resolver.resolve(new ExternalEntityIdentifier(xid.getSystemId(),
xid.getBaseUri(),
xid.getPublicId(),
entityName),
input);
return open(input);
}
catch (ResolverException e) {
throw toIOException(e);
}
}
private OpenEntity open(Input input) throws ResolverException, IOException {
resolver.open(input);
if (!input.isOpen())
throw new ResolverException("could not open input");
Reader reader = input.getCharacterStream();
String encoding = input.getEncoding();
String systemId = input.getUri();
if (reader != null) {
if (encoding == null)
encoding = "UTF-8"; // XXX not sure if it's safe to pass null here
return new OpenEntity(reader, systemId, systemId, encoding);
}
InputStream in = input.getByteStream();
if (encoding != null)
return new OpenEntity(new InputStreamReader(in, encoding),
systemId, systemId, encoding);
return detectEncoding(in, systemId);
}
private static IOException toIOException(ResolverException e) {
String message = e.getMessage();
Throwable cause = e.getCause();
if (message == null) {
if (cause instanceof IOException)
return (IOException)cause;
// Avoid IOException(Throwable) because it's 1.6
return new IOException(cause.getMessage());
}
// Avoid IOException(String, Throwable) because it's 1.6
return new IOException(message);
}
}
resources/ 0000775 0000000 0000000 00000000000 13520105541 0033611 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/dtd Messages.properties 0000664 0000000 0000000 00000002177 13520105541 0037505 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-dtd/src/main/com/thaiopensource/relaxng/input/dtd/resources # Properties file specifying messages
# key=message
INCONSISTENT_PREFIX=inconsistent namespace URIs for prefix \"{0}\"
INCONSISTENT_DEFAULT_NAMESPACE=inconsistent namespace URIs for default namespace
UNDECLARED_PREFIX=no namespace declaration for prefix \"{0}\"
no_percent=must contain a percent character
multiple_percent=must not contain more than one percent character
not_ncname_with_percent=must be a valid NCName after replacement of the percent character by an NCName
cannot_use_colon_replacement=cannot use supplied \"colon-replacement\" parameter
cannot_use_any_name=cannot use supplied \"any-name\" parameter
cannot_use_annotation_prefix=cannot use supplied \"annotation-prefix\" parameter
cannot_use_element_decl_pattern=cannot use supplied \"element-define\" parameter
cannot_use_attlist_decl_pattern=cannot use supplied \"attlist-define\" parameter
default_namespace_conflict=default value for \"xmlns\" in the DTD conflicts with supplied \"xmlns\" parameter
prefix_conflict=default value for \"xmlns:{0}\" prefix in the DTD conflicts with supplied \"xmlns:{0}\" parameter
irrelevant_prefix=prefix \"{0}\" is not used anywhere in the DTD
jing-trang-20181222+dfsg2/mod/convert-from-dtd/todo.txt 0000664 0000000 0000000 00000001052 13520105541 0022467 0 ustar 00root root 0000000 0000000 Option to map comments into annotations (or maybe should be separate program).
Output overridden definitions.
Try to preserve marked sections.
Annotation for included sections (d:condition="flagName")
When inlining attlist decls, comments should be inlined also. Maybe
inlining attlist decls should be separate later transformation. Also
need to fix XSD output to deal with such comments.
Choose start elements based on presence of namespace declarations.
An attribute group that contains only namespace declarations should
disappear completely.
jing-trang-20181222+dfsg2/mod/convert-from-xml/ 0000775 0000000 0000000 00000000000 13520105541 0021010 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/mod.xml 0000664 0000000 0000000 00000000266 13520105541 0022315 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/convert-from-xml/src/ 0000775 0000000 0000000 00000000000 13520105541 0021577 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/ 0000775 0000000 0000000 00000000000 13520105541 0022523 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/ 0000775 0000000 0000000 00000000000 13520105541 0023301 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0026331 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/thaiopensource/relaxng/ 0000775 0000000 0000000 00000000000 13520105541 0027771 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/thaiopensource/relaxng/input/ 0000775 0000000 0000000 00000000000 13520105541 0031130 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/thaiopensource/relaxng/input/xml/ 0000775 0000000 0000000 00000000000 13520105541 0031730 5 ustar 00root root 0000000 0000000 Inferrer.java 0000664 0000000 0000000 00000031663 13520105541 0034301 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/thaiopensource/relaxng/input/xml package com.thaiopensource.relaxng.input.xml;
import com.thaiopensource.datatype.DatatypeLibraryLoader;
import com.thaiopensource.relaxng.edit.AttributePattern;
import com.thaiopensource.relaxng.edit.ChoicePattern;
import com.thaiopensource.relaxng.edit.CompositePattern;
import com.thaiopensource.relaxng.edit.DataPattern;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.ElementPattern;
import com.thaiopensource.relaxng.edit.EmptyPattern;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.GroupPattern;
import com.thaiopensource.relaxng.edit.NameNameClass;
import com.thaiopensource.relaxng.edit.OneOrMorePattern;
import com.thaiopensource.relaxng.edit.OptionalPattern;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.RefPattern;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.edit.SchemaDocument;
import com.thaiopensource.relaxng.edit.TextPattern;
import com.thaiopensource.relaxng.edit.ZeroOrMorePattern;
import com.thaiopensource.resolver.Resolver;
import com.thaiopensource.resolver.xml.sax.SAXResolver;
import com.thaiopensource.xml.infer.AttributeDecl;
import com.thaiopensource.xml.infer.ChoiceParticle;
import com.thaiopensource.xml.infer.ElementDecl;
import com.thaiopensource.xml.infer.ElementParticle;
import com.thaiopensource.xml.infer.EmptyParticle;
import com.thaiopensource.xml.infer.InferHandler;
import com.thaiopensource.xml.infer.OneOrMoreParticle;
import com.thaiopensource.xml.infer.Particle;
import com.thaiopensource.xml.infer.ParticleVisitor;
import com.thaiopensource.xml.infer.Schema;
import com.thaiopensource.xml.infer.SequenceParticle;
import com.thaiopensource.xml.infer.TextParticle;
import com.thaiopensource.xml.util.Name;
import org.xml.sax.ErrorHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import java.io.IOException;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
class Inferrer {
private final Schema schema;
private final Set multiplyReferencedElementNames = new HashSet();
private final GrammarPattern grammar;
private final ParticleConverter particleConverter = new ParticleConverter();
private final List outputQueue = new Vector();
private final Set queued = new HashSet();
private String prefixSeparator;
private static final String SEPARATORS = ".-_";
static class Options {
String encoding;
Resolver resolver;
}
private static class PatternComparator implements Comparator {
private static final Class[] classOrder = {
TextPattern.class, RefPattern.class, ElementPattern.class
};
public int compare(Pattern p1, Pattern p2) {
if (p1.getClass() != p2.getClass())
return classIndex(p1.getClass()) - classIndex(p2.getClass());
if (p1 instanceof RefPattern)
return ((RefPattern)p1).getName().compareTo(((RefPattern)p2).getName());
if (p1 instanceof ElementPattern)
return Name.compare(extractElementName(p1), extractElementName(p2));
return 0;
}
private static Name extractElementName(Object o) {
NameNameClass nnc = (NameNameClass)((ElementPattern)o).getNameClass();
return new Name(nnc.getNamespaceUri(), nnc.getLocalName());
}
private static int classIndex(Class aClass) {
for (int i = 0; i < classOrder.length; i++)
if (aClass == classOrder[i])
return i;
return classOrder.length;
}
}
private class ParticleConverter extends PatternComparator implements ParticleVisitor {
public Object visitElement(ElementParticle p) {
Name name = p.getName();
if (multiplyReferencedElementNames.contains(name)) {
if (!queued.contains(name)) {
queued.add(name);
outputQueue.add(name);
}
return new RefPattern(getDefineName(name));
}
else
return createElementPattern(name);
}
public Object visitChoice(ChoiceParticle p) {
ChoicePattern cp = new ChoicePattern();
List children = cp.getChildren();
addChoices(children, p.getChild1());
addChoices(children, p.getChild2());
Collections.sort(children, this);
for (Iterator iter = children.iterator(); iter.hasNext();)
if (iter.next() instanceof EmptyPattern) {
iter.remove();
return makeOptional(cp);
}
return cp;
}
private Object makeOptional(ChoicePattern cp) {
List children = cp.getChildren();
boolean done = false;
for (int i = 0, len = children.size(); i < len; i++) {
Pattern child = children.get(i);
if (child instanceof OneOrMorePattern) {
children.set(i, new ZeroOrMorePattern(((OneOrMorePattern)child).getChild()));
done = true;
}
}
if (done)
return normalize(cp);
return new OptionalPattern(normalize(cp));
}
private void addChoices(List children, Particle child) {
Pattern pattern = convert(child);
if (pattern instanceof ChoicePattern)
children.addAll(((ChoicePattern)pattern).getChildren());
else
children.add(pattern);
}
public Object visitSequence(SequenceParticle p) {
GroupPattern gp = new GroupPattern();
addGroup(gp.getChildren(), p.getChild1());
addGroup(gp.getChildren(), p.getChild2());
return gp;
}
private void addGroup(List children, Particle child) {
Pattern pattern = convert(child);
if (pattern instanceof GroupPattern)
children.addAll(((GroupPattern)pattern).getChildren());
else
children.add(pattern);
}
public Object visitEmpty(EmptyParticle p) {
return new EmptyPattern();
}
public Object visitText(TextParticle p) {
return new TextPattern();
}
public Object visitOneOrMore(OneOrMoreParticle p) {
return new OneOrMorePattern(convert(p.getChild()));
}
public Pattern convert(Particle particle) {
return (Pattern)particle.accept(this);
}
}
private class ReferenceFinder implements ParticleVisitor {
private final Set referencedElementNames = new HashSet();
public Object visitElement(ElementParticle p) {
Name name = p.getName();
if (referencedElementNames.contains(name))
multiplyReferencedElementNames.add(name);
else
referencedElementNames.add(name);
return null;
}
public Object visitChoice(ChoiceParticle p) {
p.getChild1().accept(this);
p.getChild2().accept(this);
return null;
}
public Object visitSequence(SequenceParticle p) {
p.getChild1().accept(this);
p.getChild2().accept(this);
return null;
}
public Object visitEmpty(EmptyParticle p) {
return null;
}
public Object visitText(TextParticle p) {
return null;
}
public Object visitOneOrMore(OneOrMoreParticle p) {
return p.getChild().accept(this);
}
}
static SchemaCollection infer(String[] args, Options options, ErrorHandler eh) throws SAXException, IOException {
InferHandler handler = new InferHandler(new DatatypeLibraryLoader());
XMLReader xr = new SAXResolver(options.resolver).createXMLReader();
xr.setErrorHandler(eh);
xr.setContentHandler(handler);
for (int i = 0; i < args.length; i++) {
InputSource in = new InputSource(args[i]);
if (options.encoding != null)
in.setEncoding(options.encoding);
xr.parse(in);
}
SchemaCollection sc = new SchemaCollection();
sc.setMainUri(args[0]);
SchemaDocument sd = new SchemaDocument(new Inferrer(handler.getSchema()).grammar);
sc.getSchemaDocumentMap().put(sc.getMainUri(), sd);
return sc;
}
private Inferrer(Schema schema) {
this.schema = schema;
this.grammar = new GrammarPattern();
findMultiplyReferencedElements();
choosePrefixSeparator();
grammar.getComponents().add(new DefineComponent(DefineComponent.START,
particleConverter.convert(schema.getStart())));
// Names can get added to outputQueue during this loop,
// so don't change this to a for each.
for (int i = 0; i < outputQueue.size(); i++) {
Name elementName = outputQueue.get(i);
grammar.getComponents().add(new DefineComponent(getDefineName(elementName),
createElementPattern(elementName)));
}
}
private void findMultiplyReferencedElements() {
ReferenceFinder finder = new ReferenceFinder();
schema.getStart().accept(finder);
for (ElementDecl decl : schema.getElementDecls().values()) {
Particle particle = decl.getContentModel();
if (particle != null)
particle.accept(finder);
}
}
private void choosePrefixSeparator() {
Map prefixMap = schema.getPrefixMap();
Set namespacesInDefines = new HashSet();
for (Name name : multiplyReferencedElementNames)
namespacesInDefines.add(name.getNamespaceUri());
if (namespacesInDefines.size() <= 1)
return; // don't need to use prefixes in defines
// define additional prefixes if necessary
namespacesInDefines.removeAll(prefixMap.keySet());
if (namespacesInDefines.size() > 1) {
namespacesInDefines.remove("");
int n = 1;
for (String ns : namespacesInDefines) {
for (; ;) {
String prefix = "ns" + Integer.toString(n++);
if (!prefixMap.containsKey(prefix)) {
prefixMap.put(ns, prefix);
break;
}
}
}
}
// choose a prefixSeparator that avoids all collisions
StringBuffer buf = new StringBuffer();
for (int len = 1;; len++)
for (int i = 0; i < SEPARATORS.length(); i++) {
char c = SEPARATORS.charAt(i);
for (int j = 0; j < len; j++)
buf.append(c);
prefixSeparator = buf.toString();
if (prefixSeparatorOk())
return;
buf.setLength(0);
}
}
private boolean prefixSeparatorOk() {
Set names = new HashSet();
for (Name elementName : multiplyReferencedElementNames) {
String name = getDefineName(elementName);
if (names.contains(name))
return false;
names.add(name);
}
return true;
}
private Pattern createElementPattern(Name elementName) {
ElementDecl elementDecl = schema.getElementDecl(elementName);
Pattern contentPattern;
Particle particle = elementDecl.getContentModel();
if (particle != null)
contentPattern = particleConverter.convert(particle);
else
contentPattern = makeDatatype(elementDecl.getDatatype());
Map attributeDecls = elementDecl.getAttributeDecls();
if (attributeDecls.size() > 0) {
GroupPattern group = new GroupPattern();
List attributeNames = new Vector();
attributeNames.addAll(attributeDecls.keySet());
Collections.sort(attributeNames, new Comparator() {
public int compare(Name n1, Name n2) {
return Name.compare(n1, n2);
}
});
for (Name attName : attributeNames) {
AttributeDecl att = attributeDecls.get(attName);
Pattern tem;
if (att.getDatatype() == null)
tem = new TextPattern();
else
tem = makeDatatype(att.getDatatype());
tem = new AttributePattern(makeNameClass(attName), tem);
if (att.isOptional())
tem = new OptionalPattern(tem);
group.getChildren().add(tem);
}
if (contentPattern instanceof GroupPattern)
group.getChildren().addAll(((GroupPattern)contentPattern).getChildren());
else if (!(contentPattern instanceof EmptyPattern))
group.getChildren().add(contentPattern);
contentPattern = group;
}
return new ElementPattern(makeNameClass(elementName), contentPattern);
}
private NameNameClass makeNameClass(Name name) {
String ns = name.getNamespaceUri();
NameNameClass nnc = new NameNameClass(ns, name.getLocalName());
if (!ns.equals("")) {
String prefix = schema.getPrefixMap().get(ns);
if (prefix != null)
nnc.setPrefix(prefix);
}
return nnc;
}
private static DataPattern makeDatatype(Name datatypeName) {
return new DataPattern(datatypeName.getNamespaceUri(), datatypeName.getLocalName());
}
private String getDefineName(Name elementName) {
if (prefixSeparator != null) {
String prefix = schema.getPrefixMap().get(elementName.getNamespaceUri());
if (prefix != null)
return prefix + prefixSeparator + elementName.getLocalName();
}
return elementName.getLocalName();
}
private static Pattern normalize(CompositePattern cp) {
if (cp.getChildren().size() == 1)
return cp.getChildren().get(0);
return cp;
}
}
XmlInputFormat.java 0000664 0000000 0000000 00000002402 13520105541 0035443 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-from-xml/src/main/com/thaiopensource/relaxng/input/xml package com.thaiopensource.relaxng.input.xml;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.input.AbstractMultiInputFormat;
import com.thaiopensource.relaxng.input.InputFailedException;
import com.thaiopensource.relaxng.translate.util.EncodingParam;
import com.thaiopensource.relaxng.translate.util.InvalidParamsException;
import com.thaiopensource.relaxng.translate.util.ParamProcessor;
import com.thaiopensource.resolver.Resolver;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import java.io.IOException;
public class XmlInputFormat extends AbstractMultiInputFormat {
public SchemaCollection load(String[] uris, String[] params, String outputFormat, ErrorHandler eh, Resolver resolver)
throws InputFailedException, InvalidParamsException, IOException, SAXException {
ParamProcessor pp = new ParamProcessor();
final Inferrer.Options options = new Inferrer.Options();
options.resolver = resolver;
pp.declare("encoding",
new EncodingParam() {
protected void setEncoding(String encoding) {
options.encoding = encoding;
}
});
pp.process(params, eh);
return Inferrer.infer(uris, options, eh);
}
}
jing-trang-20181222+dfsg2/mod/convert-from-xml/todo.txt 0000664 0000000 0000000 00000000374 13520105541 0022522 0 ustar 00root root 0000000 0000000 Choose default namespace.
Should we reconsider always inlining elements that are referenced only once?
Deal with QName datatype.
Type of qualified attribute should be globally consistent.
Option to make it more eager to use repeated choice groups.
jing-trang-20181222+dfsg2/mod/convert-to-dtd/ 0000775 0000000 0000000 00000000000 13520105541 0020442 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/mod.xml 0000664 0000000 0000000 00000000134 13520105541 0021741 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/ 0000775 0000000 0000000 00000000000 13520105541 0021231 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/ 0000775 0000000 0000000 00000000000 13520105541 0022155 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/ 0000775 0000000 0000000 00000000000 13520105541 0022733 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0025763 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/ 0000775 0000000 0000000 00000000000 13520105541 0027423 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/ 0000775 0000000 0000000 00000000000 13520105541 0030763 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd/ 0000775 0000000 0000000 00000000000 13520105541 0031536 5 ustar 00root root 0000000 0000000 Analysis.java 0000664 0000000 0000000 00000052332 13520105541 0034112 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.edit.AbstractPatternVisitor;
import com.thaiopensource.relaxng.edit.AnyNameNameClass;
import com.thaiopensource.relaxng.edit.AttributePattern;
import com.thaiopensource.relaxng.edit.ChoiceNameClass;
import com.thaiopensource.relaxng.edit.ChoicePattern;
import com.thaiopensource.relaxng.edit.Component;
import com.thaiopensource.relaxng.edit.ComponentVisitor;
import com.thaiopensource.relaxng.edit.CompositePattern;
import com.thaiopensource.relaxng.edit.Container;
import com.thaiopensource.relaxng.edit.DataPattern;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.DivComponent;
import com.thaiopensource.relaxng.edit.ElementPattern;
import com.thaiopensource.relaxng.edit.EmptyPattern;
import com.thaiopensource.relaxng.edit.ExternalRefPattern;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.GroupPattern;
import com.thaiopensource.relaxng.edit.IncludeComponent;
import com.thaiopensource.relaxng.edit.InterleavePattern;
import com.thaiopensource.relaxng.edit.ListPattern;
import com.thaiopensource.relaxng.edit.MixedPattern;
import com.thaiopensource.relaxng.edit.NameClass;
import com.thaiopensource.relaxng.edit.NameClassVisitor;
import com.thaiopensource.relaxng.edit.NameNameClass;
import com.thaiopensource.relaxng.edit.NotAllowedPattern;
import com.thaiopensource.relaxng.edit.NsNameNameClass;
import com.thaiopensource.relaxng.edit.OneOrMorePattern;
import com.thaiopensource.relaxng.edit.OptionalPattern;
import com.thaiopensource.relaxng.edit.ParentRefPattern;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.PatternVisitor;
import com.thaiopensource.relaxng.edit.RefPattern;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.edit.TextPattern;
import com.thaiopensource.relaxng.edit.ValuePattern;
import com.thaiopensource.relaxng.edit.ZeroOrMorePattern;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import com.thaiopensource.relaxng.output.common.NameClassSplitter;
import com.thaiopensource.util.VoidValue;
import com.thaiopensource.xml.util.Name;
import com.thaiopensource.xml.util.Naming;
import com.thaiopensource.xml.util.WellKnownNamespaces;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
class Analysis {
private final NamespaceManager nsm = new NamespaceManager();
private final AttlistMapper am = new AttlistMapper();
private final ErrorReporter er;
private final Map contentTypes = new HashMap();
private final Map attributeTypes = new HashMap();
private final Map> attributeAlphabets = new HashMap>();
private final Map> attributeNamespaces = new HashMap>();
private Map defines = null;
private final Set attlists = new HashSet();
private final Map parts = new HashMap();
private final Map seenTable = new HashMap();
private final Map elementDecls = new HashMap();
private ContentType startType = ContentType.ERROR;
private GrammarPart mainPart;
private final SchemaCollection schemas;
private GrammarPattern grammarPattern;
private final AttributeTyper attributeTyper = new AttributeTyper();
private final AttributeAlphabetComputer attributeAlphabetComputer = new AttributeAlphabetComputer();
private final AttributeNamespacesComputer attributeNamespacesComputer = new AttributeNamespacesComputer();
private final IncludeContentChecker includeContentChecker = new IncludeContentChecker();
private final static Set EMPTY_STRING_SET = Collections.emptySet();
private final static Set EMPTY_NAME_SET = Collections.emptySet();
private class Analyzer implements PatternVisitor,
ComponentVisitor, NameClassVisitor {
private ElementPattern ancestorPattern;
private final Set pendingRefs;
public Analyzer() {
pendingRefs = new HashSet();
}
private Analyzer(ElementPattern ancestorPattern) {
this.ancestorPattern = ancestorPattern;
pendingRefs = new HashSet();
}
private Analyzer(Set pendingRefs) {
this.pendingRefs = pendingRefs;
}
public ContentType visitEmpty(EmptyPattern p) {
return ContentType.EMPTY;
}
public ContentType visitData(DataPattern p) {
return ContentType.SIMPLE_TYPE;
}
public ContentType visitValue(ValuePattern p) {
Datatypes.Info info = Datatypes.getInfo(p.getDatatypeLibrary(), p.getType());
if (info.usesTokenEquality() && Naming.isNmtoken(p.getValue()))
return ContentType.ENUM;
if (info.usesCdataEquality())
return ContentType.VALUE;
return ContentType.SIMPLE_TYPE;
}
public ContentType visitElement(ElementPattern p) {
int len;
if (seen(p))
len = NameClassSplitter.split(p.getNameClass()).size();
else {
new Analyzer(p).analyzeContentType(p.getChild());
List names = noteNames(p.getNameClass(), true);
len = names.size();
for (int i = 0; i < len; i++) {
NameNameClass nnc = names.get(i);
String ns = nnc.getNamespaceUri();
if (ns == NameClass.INHERIT_NS)
ns = "";
Name name = new Name(ns, nnc.getLocalName());
ElementPattern prev = elementDecls.get(name);
if (prev != null) {
er.error("sorry_multiple_element", ns, name.getLocalName(), p.getSourceLocation());
er.error("other_element", prev.getSourceLocation());
}
else
elementDecls.put(name, p);
}
}
return len == 1 ? ContentType.DIRECT_SINGLE_ELEMENT : ContentType.ELEMENT_CLASS;
}
public ContentType visitAttribute(AttributePattern p) {
noteNames(p.getNameClass(), false);
ContentType t = analyzeContentType(p.getChild());
if (t.isA(ContentType.MODEL_GROUP) || t == ContentType.MIXED_ELEMENT_CLASS || t == ContentType.MIXED_MODEL)
er.error("bad_attribute_type", p.getSourceLocation());
if (ancestorPattern != null)
am.noteAttribute(ancestorPattern);
return ContentType.EMPTY;
}
private List noteNames(NameClass nc, boolean defaultable) {
nc.accept(this);
List names = NameClassSplitter.split(nc);
int len = names.size();
for (int i = 0; i < len; i++)
nsm.noteName(names.get(i), defaultable);
return names;
}
public ContentType visitNotAllowed(NotAllowedPattern p) {
return ContentType.NOT_ALLOWED;
}
public ContentType visitText(TextPattern p) {
return ContentType.TEXT;
}
public ContentType visitList(ListPattern p) {
return ContentType.SIMPLE_TYPE;
}
public ContentType visitOneOrMore(OneOrMorePattern p) {
return checkContentType("sorry_one_or_more", ContentType.oneOrMore(analyzeContentTypeNullAncestorPattern(p.getChild())), p);
}
public ContentType visitZeroOrMore(ZeroOrMorePattern p) {
return checkContentType("sorry_zero_or_more", ContentType.zeroOrMore(analyzeContentTypeNullAncestorPattern(p.getChild())), p);
}
public ContentType visitChoice(ChoicePattern p) {
List children = p.getChildren();
Iterator iter = children.iterator();
ContentType tem = analyzeContentType(iter.next());
while (iter.hasNext())
tem = checkContentType("sorry_choice",
ContentType.choice(tem, analyzeContentType(iter.next())),
p);
if (getAttributeType(p) == AttributeType.MULTI) {
Set attributeNames = new HashSet();
for (Pattern child : children) {
Set childAttributeNames = getAttributeAlphabet(child);
for (Name name : childAttributeNames) {
if (attributeNames.contains(name))
er.error("sorry_choice_attribute_name",
name.getNamespaceUri(),
name.getLocalName(),
p.getSourceLocation());
else
attributeNames.add(name);
}
}
}
return tem;
}
public ContentType visitInterleave(InterleavePattern p) {
List children = p.getChildren();
ContentType tem = analyzeContentType(children.get(0));
for (int i = 1, len = children.size(); i < len; i++)
tem = checkContentType("sorry_interleave", ContentType.interleave(tem, analyzeContentType(children.get(i))), p);
return tem;
}
public ContentType visitGroup(GroupPattern p) {
List children = p.getChildren();
ContentType tem = analyzeContentType(children.get(0));
for (int i = 1, len = children.size(); i < len; i++)
tem = checkContentType("sorry_group", ContentType.group(tem, analyzeContentType(children.get(i))), p);
return tem;
}
public ContentType visitRef(RefPattern p) {
String name = p.getName();
Pattern def = getBody(name);
if (def == null) {
er.error("undefined_ref", p.getSourceLocation());
return ContentType.ERROR;
}
if (pendingRefs.contains(name)) {
er.error("ref_loop", p.getSourceLocation());
return ContentType.ERROR;
}
pendingRefs.add(name);
ContentType t = ContentType.ref(new Analyzer(pendingRefs).analyzeContentType(def));
pendingRefs.remove(name);
if (t.isA(ContentType.EMPTY))
am.noteAttributeGroupRef(ancestorPattern, p.getName());
return ContentType.ref(t);
}
public ContentType visitParentRef(ParentRefPattern p) {
er.error("sorry_parent_ref", p.getSourceLocation());
return null;
}
public ContentType visitGrammar(GrammarPattern p) {
if (defines != null) {
er.error("sorry_nested_grammar", p.getSourceLocation());
return ContentType.ERROR;
}
defines = new HashMap();
try {
mainPart = new GrammarPart(er, defines, attlists, schemas, parts, p);
}
catch (GrammarPart.IncludeLoopException e) {
er.error("include_loop", e.getInclude().getSourceLocation());
return ContentType.ERROR;
}
grammarPattern = p;
visitContainer(p);
return startType;
}
public ContentType visitExternalRef(ExternalRefPattern p) {
er.error("sorry_external_ref", p.getSourceLocation());
return null;
}
public ContentType visitMixed(MixedPattern p) {
return checkContentType("sorry_mixed", ContentType.mixed(analyzeContentType(p.getChild())), p);
}
public ContentType visitOptional(OptionalPattern p) {
return checkContentType("sorry_optional", ContentType.optional(analyzeContentTypeNullAncestorPattern(p.getChild())), p);
}
public VoidValue visitContainer(Container c) {
List list = c.getComponents();
for (int i = 0, len = list.size(); i < len; i++)
list.get(i).accept(this);
return VoidValue.VOID;
}
public VoidValue visitDiv(DivComponent c) {
return visitContainer(c);
}
public VoidValue visitDefine(DefineComponent c) {
if (c.getName() == DefineComponent.START)
startType = analyzeContentType(c.getBody());
else
new Analyzer().analyzeContentType(c.getBody());
if (attlists.contains(c.getName()) && getContentType(c.getBody()) != ContentType.EMPTY) {
er.error("not_attlist", c.getName(), c.getSourceLocation());
attlists.remove(c.getName());
}
return VoidValue.VOID;
}
public VoidValue visitInclude(IncludeComponent c) {
includeContentChecker.visitContainer(c);
visitContainer((GrammarPattern)(schemas.getSchemaDocumentMap().get(c.getUri())).getPattern());
return VoidValue.VOID;
}
public VoidValue visitChoice(ChoiceNameClass nc) {
List list = nc.getChildren();
for (int i = 0, len = list.size(); i < len; i++)
list.get(i).accept(this);
return VoidValue.VOID;
}
public VoidValue visitAnyName(AnyNameNameClass nc) {
er.error("sorry_wildcard", nc.getSourceLocation());
return VoidValue.VOID;
}
public VoidValue visitNsName(NsNameNameClass nc) {
er.error("sorry_wildcard", nc.getSourceLocation());
return VoidValue.VOID;
}
public VoidValue visitName(NameNameClass nc) {
nsm.noteName(nc, true);
return VoidValue.VOID;
}
ContentType checkContentType(String key, ContentType t, Pattern p) {
if (t != null)
return t;
er.error(key, p.getSourceLocation());
return ContentType.ERROR;
}
ContentType analyzeContentType(Pattern p) {
ContentType t = contentTypes.get(p);
if (t == null) {
t = p.accept(this);
contentTypes.put(p, t);
}
return t;
}
ContentType analyzeContentTypeNullAncestorPattern(Pattern p) {
return (ancestorPattern == null ? this : new Analyzer(pendingRefs)).analyzeContentType(p);
}
}
class IncludeContentChecker implements ComponentVisitor {
public VoidValue visitContainer(Container c) {
List list = c.getComponents();
for (int i = 0, len = list.size(); i < len; i++)
list.get(i).accept(this);
return VoidValue.VOID;
}
public VoidValue visitDefine(DefineComponent c) {
er.error("sorry_include_override", c.getSourceLocation());
return VoidValue.VOID;
}
public VoidValue visitDiv(DivComponent c) {
return visitContainer(c);
}
public VoidValue visitInclude(IncludeComponent c) {
return VoidValue.VOID;
}
}
private class AttributeTyper extends AbstractPatternVisitor {
public AttributeType visitPattern(Pattern p) {
return AttributeType.EMPTY;
}
public AttributeType visitMixed(MixedPattern p) {
return getAttributeType(p.getChild());
}
public AttributeType visitOneOrMore(OneOrMorePattern p) {
return getAttributeType(p.getChild());
}
public AttributeType visitZeroOrMore(ZeroOrMorePattern p) {
return getAttributeType(p.getChild());
}
public AttributeType visitOptional(OptionalPattern p) {
return getAttributeType(p.getChild());
}
public AttributeType visitComposite(CompositePattern p) {
List list = p.getChildren();
AttributeType at = getAttributeType(list.get(0));
for (int i = 1, len = list.size(); i < len; i++)
at = AttributeType.group(at, getAttributeType(list.get(i)));
return at;
}
public AttributeType visitAttribute(AttributePattern p) {
return AttributeType.SINGLE;
}
public AttributeType visitEmpty(EmptyPattern p) {
return AttributeType.MULTI;
}
public AttributeType visitRef(RefPattern p) {
return getAttributeType(getBody(p.getName()));
}
}
private class AttributeAlphabetComputer extends AbstractPatternVisitor> {
public Set visitPattern(Pattern p) {
return EMPTY_NAME_SET;
}
public Set visitMixed(MixedPattern p) {
return getAttributeAlphabet(p.getChild());
}
public Set visitOneOrMore(OneOrMorePattern p) {
return getAttributeAlphabet(p.getChild());
}
public Set visitZeroOrMore(ZeroOrMorePattern p) {
return getAttributeAlphabet(p.getChild());
}
public Set visitOptional(OptionalPattern p) {
return getAttributeAlphabet(p.getChild());
}
public Set visitComposite(CompositePattern p) {
List list = p.getChildren();
Set result = new HashSet();
for (int i = 0, len = list.size(); i < len; i++)
result.addAll(getAttributeAlphabet(list.get(i)));
return result;
}
public Set visitAttribute(AttributePattern p) {
Set result = new HashSet();
List names = NameClassSplitter.split(p.getNameClass());
for (int i = 0, len = names.size(); i < len; i++) {
NameNameClass nnc = names.get(i);
String ns = nnc.getNamespaceUri();
if (ns == NameClass.INHERIT_NS)
ns = "";
result.add(new Name(ns, nnc.getLocalName()));
}
return result;
}
public Set visitRef(RefPattern p) {
return getAttributeAlphabet(getBody(p.getName()));
}
}
private class AttributeNamespacesComputer extends AbstractPatternVisitor> {
public Set visitPattern(Pattern p) {
return EMPTY_STRING_SET;
}
public Set visitMixed(MixedPattern p) {
return getAttributeNamespaces(p.getChild());
}
public Set visitOneOrMore(OneOrMorePattern p) {
return getAttributeNamespaces(p.getChild());
}
public Set visitZeroOrMore(ZeroOrMorePattern p) {
return getAttributeNamespaces(p.getChild());
}
public Set visitOptional(OptionalPattern p) {
return getAttributeNamespaces(p.getChild());
}
public Set visitComposite(CompositePattern p) {
Set result = EMPTY_STRING_SET;
boolean newResult = false;
for (Pattern child : p.getChildren()) {
Set tem = getAttributeNamespaces(child);
if (tem != EMPTY_STRING_SET && !result.containsAll(tem)) {
if (result == EMPTY_STRING_SET)
result = tem;
else {
if (!newResult) {
result = new HashSet(result);
newResult = true;
}
result.addAll(tem);
}
}
}
if (newResult)
result = Collections.unmodifiableSet(result);
return result;
}
public Set visitAttribute(AttributePattern p) {
Set result = null;
List names = NameClassSplitter.split(p.getNameClass());
for (NameNameClass name : names) {
String ns = name.getNamespaceUri();
if (ns.length() != 0 && ns != NameClass.INHERIT_NS && !ns.equals(WellKnownNamespaces.XML)) {
if (result == null)
result = new HashSet();
result.add(ns);
}
}
if (result == null)
return EMPTY_STRING_SET;
return Collections.unmodifiableSet(result);
}
public Set visitRef(RefPattern p) {
return getAttributeNamespaces(getBody(p.getName()));
}
}
private boolean seen(Pattern p) {
if (seenTable.get(p) != null)
return true;
seenTable.put(p, p);
return false;
}
Analysis(SchemaCollection schemas, ErrorReporter er) {
this.schemas = schemas;
this.er = er;
new Analyzer().analyzeContentType(getPattern());
checkAttlists();
if (!er.getHadError())
nsm.assignPrefixes();
}
private void checkAttlists() {
for (String name : attlists)
if (getParamEntityElementName(name) == null)
er.error("not_attlist", name, getBody(name).getSourceLocation());
}
Pattern getPattern() {
return (schemas.getSchemaDocumentMap().get(schemas.getMainUri())).getPattern();
}
String getPrefixForNamespaceUri(String ns) {
return nsm.getPrefixForNamespaceUri(ns);
}
String getElementPrefixForNamespaceUri(String ns) {
if (ns.equals("") || ns.equals(nsm.getDefaultNamespaceUri()) || ns == NameClass.INHERIT_NS)
return null;
return nsm.getPrefixForNamespaceUri(ns);
}
String getParamEntityElementName(String name) {
NameNameClass nc = am.getParamEntityElementName(name);
if (nc == null)
return null;
String prefix = getElementPrefixForNamespaceUri(nc.getNamespaceUri());
String localName = nc.getLocalName();
if (prefix == null)
return localName;
return prefix + ":" + localName;
}
ContentType getContentType(Pattern p) {
return contentTypes.get(p);
}
AttributeType getAttributeType(Pattern p) {
AttributeType at = attributeTypes.get(p);
if (at == null) {
at = p.accept(attributeTyper);
attributeTypes.put(p, at);
}
return at;
}
Set getAttributeAlphabet(Pattern p) {
Set aa = attributeAlphabets.get(p);
if (aa == null) {
aa = Collections.unmodifiableSet(p.accept(attributeAlphabetComputer));
attributeAlphabets.put(p, aa);
}
return aa;
}
Set getAttributeNamespaces(Pattern p) {
Set aa = attributeNamespaces.get(p);
if (aa == null) {
aa = p.accept(attributeNamespacesComputer);
attributeNamespaces.put(p, aa);
}
return aa;
}
Pattern getBody(String name) {
return defines.get(name);
}
GrammarPattern getGrammarPattern() {
return grammarPattern;
}
String getMainUri() {
return schemas.getMainUri();
}
GrammarPart getGrammarPart(String sourceUri) {
if (sourceUri.equals(schemas.getMainUri()))
return mainPart;
else
return parts.get(sourceUri);
}
Pattern getSchema(String sourceUri) {
return (schemas.getSchemaDocumentMap().get(sourceUri)).getPattern();
}
String getEncoding(String sourceUri) {
return (schemas.getSchemaDocumentMap().get(sourceUri)).getEncoding();
}
}
AttlistMapper.java 0000664 0000000 0000000 00000002672 13520105541 0035122 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.edit.ElementPattern;
import com.thaiopensource.relaxng.edit.NameClass;
import com.thaiopensource.relaxng.edit.NameNameClass;
import java.util.HashMap;
import java.util.Map;
class AttlistMapper {
private final Map elementToAttlistMap = new HashMap();
private final Map paramEntityToElementMap = new HashMap();
void noteAttribute(ElementPattern e) {
elementToAttlistMap.put(e, Boolean.FALSE);
}
void noteAttributeGroupRef(ElementPattern e, String paramEntityName) {
if (e != null) {
if (elementToAttlistMap.get(e) != null)
elementToAttlistMap.put(e, Boolean.FALSE);
else
elementToAttlistMap.put(e, paramEntityName);
}
if (e == null || paramEntityToElementMap.get(paramEntityName) != null)
paramEntityToElementMap.put(paramEntityName, Boolean.FALSE);
else
paramEntityToElementMap.put(paramEntityName, e);
}
NameNameClass getParamEntityElementName(String name) {
Object elem = paramEntityToElementMap.get(name);
if (elem == null || elem == Boolean.FALSE)
return null;
Object tem = elementToAttlistMap.get(elem);
if (!name.equals(tem))
return null;
NameClass nc = ((ElementPattern)elem).getNameClass();
if (!(nc instanceof NameNameClass))
return null;
return (NameNameClass)nc;
}
}
AttributeType.java 0000664 0000000 0000000 00000000701 13520105541 0035125 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
class AttributeType {
private AttributeType() { }
static final AttributeType EMPTY = new AttributeType();
static final AttributeType SINGLE = new AttributeType();
static final AttributeType MULTI = new AttributeType();
static AttributeType group(AttributeType at1, AttributeType at2) {
if (at1 == EMPTY)
return at2;
if (at2 == EMPTY)
return at1;
return MULTI;
}
}
ContentType.java 0000664 0000000 0000000 00000010747 13520105541 0034607 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
class ContentType {
private final ContentType parent;
static final ContentType MIXED_ELEMENT_CLASS = new ContentType();
static final ContentType NOT_ALLOWED = new ContentType();
static final ContentType SIMPLE_TYPE = new ContentType();
static final ContentType SIMPLE_TYPE_CHOICE = new ContentType(SIMPLE_TYPE);
static final ContentType VALUE = new ContentType(SIMPLE_TYPE);
static final ContentType EMPTY = new ContentType();
static final ContentType TEXT = new ContentType(MIXED_ELEMENT_CLASS);
static final ContentType MIXED_MODEL = new ContentType();
static final ContentType INTERLEAVE_MIXED_MODEL = new ContentType(MIXED_MODEL);
static final ContentType MODEL_GROUP = new ContentType();
static final ContentType ELEMENT_CLASS = new ContentType(MODEL_GROUP);
static final ContentType DIRECT_SINGLE_ELEMENT = new ContentType(ELEMENT_CLASS);
static final ContentType ZERO_OR_MORE_ELEMENT_CLASS = new ContentType(MODEL_GROUP);
static final ContentType INTERLEAVE_ZERO_OR_MORE_ELEMENT_CLASS = new ContentType(ZERO_OR_MORE_ELEMENT_CLASS);
static final ContentType ENUM = new ContentType(SIMPLE_TYPE);
static final ContentType ERROR = new ContentType();
private ContentType() {
this.parent = null;
}
private ContentType(ContentType parent) {
this.parent = parent;
}
boolean isA(ContentType t) {
if (this == t)
return true;
if (parent != null && parent.isA(t))
return true;
return false;
}
static ContentType zeroOrMore(ContentType t) {
if (t.isA(ELEMENT_CLASS))
return ZERO_OR_MORE_ELEMENT_CLASS;
if (t.isA(MIXED_ELEMENT_CLASS))
return MIXED_MODEL;
return oneOrMore(t);
}
static ContentType oneOrMore(ContentType t) {
if (t == ERROR)
return ERROR;
if (t == EMPTY)
return EMPTY;
if (t.isA(MIXED_ELEMENT_CLASS))
return MIXED_MODEL;
if (t.isA(MODEL_GROUP))
return MODEL_GROUP;
return null;
}
static ContentType group(ContentType t1, ContentType t2) {
if (t1.isA(MODEL_GROUP) && t2.isA(MODEL_GROUP))
return MODEL_GROUP;
return groupOrInterleave(t1, t2);
}
static ContentType mixed(ContentType t) {
if (t.isA(EMPTY))
return TEXT;
if (t.isA(ZERO_OR_MORE_ELEMENT_CLASS))
return MIXED_MODEL;
return null;
}
static ContentType interleave(ContentType t1, ContentType t2) {
if (t1.isA(ZERO_OR_MORE_ELEMENT_CLASS) && t2.isA(ZERO_OR_MORE_ELEMENT_CLASS))
return INTERLEAVE_ZERO_OR_MORE_ELEMENT_CLASS;
if (((t1.isA(MIXED_MODEL) || t1 == TEXT) && t2.isA(ZERO_OR_MORE_ELEMENT_CLASS))
|| t1.isA(ZERO_OR_MORE_ELEMENT_CLASS) && (t2.isA(MIXED_MODEL) || t2 == TEXT))
return INTERLEAVE_MIXED_MODEL;
return groupOrInterleave(t1, t2);
}
static private ContentType groupOrInterleave(ContentType t1, ContentType t2) {
if (t1 == ERROR || t2 == ERROR)
return ERROR;
if (t1.isA(EMPTY))
return ref(t2);
if (t2.isA(EMPTY))
return ref(t1);
return null;
}
static ContentType optional(ContentType t) {
if (t == ERROR)
return ERROR;
if (t == EMPTY)
return EMPTY;
if (t.isA(MODEL_GROUP))
return MODEL_GROUP;
if (t.isA(MIXED_ELEMENT_CLASS))
return MIXED_ELEMENT_CLASS;
if (t == NOT_ALLOWED)
return MODEL_GROUP;
return null;
}
static ContentType choice(ContentType t1, ContentType t2) {
if (t1 == ERROR || t2 == ERROR)
return ERROR;
if (t1 == EMPTY && t2 == EMPTY)
return EMPTY;
if (t1 == NOT_ALLOWED) {
if (t2 == NOT_ALLOWED)
return NOT_ALLOWED;
if (t2.isA(ELEMENT_CLASS))
return ELEMENT_CLASS;
if (t2.isA(MIXED_ELEMENT_CLASS))
return MIXED_ELEMENT_CLASS;
if (t2.isA(MODEL_GROUP))
return MODEL_GROUP;
if (t2.isA(ENUM))
return ENUM;
return null;
}
if (t2 == NOT_ALLOWED)
return choice(t2, t1);
if (t1.isA(ENUM) && t2.isA(ENUM))
return ENUM;
if (t1.isA(SIMPLE_TYPE) && t2.isA(SIMPLE_TYPE))
return SIMPLE_TYPE_CHOICE;
if (t1.isA(ELEMENT_CLASS) && t2.isA(ELEMENT_CLASS))
return ELEMENT_CLASS;
if (t1.isA(MODEL_GROUP) && t2.isA(MODEL_GROUP))
return MODEL_GROUP;
if ((t1.isA(MIXED_ELEMENT_CLASS) && t2.isA(ELEMENT_CLASS))
|| (t1.isA(ELEMENT_CLASS) && t2.isA(MIXED_ELEMENT_CLASS)))
return MIXED_ELEMENT_CLASS;
return null;
}
static ContentType ref(ContentType t) {
if (t.isA(DIRECT_SINGLE_ELEMENT))
return ELEMENT_CLASS;
return t;
}
}
Datatypes.java 0000664 0000000 0000000 00000007263 13520105541 0034270 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.xml.util.WellKnownNamespaces;
import java.util.HashMap;
import java.util.Map;
public class Datatypes {
private static final Map xsdMap = new HashMap();
// exactly equivalent to DTD datatype of same name
private static final int COMPATIBLE = 0x0;
// closest to CDATA
private static final int CDATA = 0x1;
// closest to NMTOKEN
private static final int NMTOKEN = 0x2;
// closest to CDATA
private static final int CDATA_EQUALITY = 0x4;
// closest to CDATA
private static final int TOKEN_EQUALITY = 0x8;
// closest CDATA type is exact
private static final int EXACT = 0x10;
private static final Object[] others = {
"",
new Info("string", CDATA|EXACT|CDATA_EQUALITY),
"",
new Info("token", CDATA|EXACT|TOKEN_EQUALITY),
WellKnownNamespaces.RELAX_NG_COMPATIBILITY_DATATYPES,
new Info("ID", COMPATIBLE|EXACT|TOKEN_EQUALITY),
WellKnownNamespaces.RELAX_NG_COMPATIBILITY_DATATYPES,
new Info("IDREF", COMPATIBLE|EXACT|TOKEN_EQUALITY),
WellKnownNamespaces.RELAX_NG_COMPATIBILITY_DATATYPES,
new Info("IDREFS", COMPATIBLE|EXACT|TOKEN_EQUALITY)
};
public final static class Info {
private final String name;
private final int flags;
private Info(String name, int flags) {
this.name = name;
this.flags = flags;
}
public String closestType() {
switch (flags & 0x3) {
case COMPATIBLE:
return name;
case NMTOKEN:
return "NMTOKEN";
default:
return "CDATA";
}
}
public boolean isExact() {
return (flags & EXACT) != 0;
}
public boolean usesTokenEquality() {
return (flags & TOKEN_EQUALITY) != 0;
}
public boolean usesCdataEquality() {
return (flags & CDATA_EQUALITY) != 0;
}
}
public static Info getInfo(String datatypeLibrary, String localName) {
if (datatypeLibrary.equals(WellKnownNamespaces.XML_SCHEMA_DATATYPES))
return xsdMap.get(localName);
for (int i = 0; i < others.length; i += 2)
if (datatypeLibrary.equals(others[i])
&& localName.equals(((Info)others[i + 1]).name))
return (Info)others[i + 1];
return null;
}
private static void xsd(String name, int flags) {
xsdMap.put(name, new Info(name, flags));
}
static {
xsd("ENTITIES", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("ENTITY", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("ID", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("IDREF", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("IDREFS", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("NMTOKEN", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("NMTOKENS", COMPATIBLE|EXACT|TOKEN_EQUALITY);
xsd("NOTATION", NMTOKEN);
xsd("NCName", NMTOKEN);
xsd("QName", NMTOKEN);
xsd("anyURI", CDATA|CDATA_EQUALITY);
xsd("base64Binary", CDATA);
xsd("boolean", NMTOKEN);
xsd("byte", CDATA);
xsd("date", NMTOKEN);
xsd("dateTime", NMTOKEN);
xsd("decimal", CDATA);
xsd("duration", NMTOKEN);
xsd("gDay", NMTOKEN);
xsd("gMonth", NMTOKEN);
xsd("gMonthDay", NMTOKEN);
xsd("gYear", NMTOKEN);
xsd("gYearMonth", NMTOKEN);
xsd("hexBinary", NMTOKEN);
xsd("int", CDATA);
xsd("integer", CDATA);
xsd("language", CDATA); // XXX
xsd("long", CDATA);
xsd("negativeInteger", CDATA);
xsd("nonNegativeInteger", CDATA);
xsd("nonPositiveInteger", CDATA);
xsd("normalizedString", CDATA|EXACT|CDATA_EQUALITY);
xsd("positiveInteger", CDATA);
xsd("short", CDATA);
xsd("string", CDATA|EXACT|CDATA_EQUALITY);
xsd("time", NMTOKEN);
xsd("token", CDATA|EXACT|TOKEN_EQUALITY);
xsd("unsignedInt", CDATA);
xsd("unsignedLong", CDATA);
xsd("unsignedShort", CDATA);
}
}
DtdOutput.java 0000664 0000000 0000000 00000114523 13520105541 0034264 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.edit.AbstractPatternVisitor;
import com.thaiopensource.relaxng.edit.AbstractVisitor;
import com.thaiopensource.relaxng.edit.Annotated;
import com.thaiopensource.relaxng.edit.AnnotationChild;
import com.thaiopensource.relaxng.edit.AttributeAnnotation;
import com.thaiopensource.relaxng.edit.AttributePattern;
import com.thaiopensource.relaxng.edit.ChoiceNameClass;
import com.thaiopensource.relaxng.edit.ChoicePattern;
import com.thaiopensource.relaxng.edit.Comment;
import com.thaiopensource.relaxng.edit.Component;
import com.thaiopensource.relaxng.edit.ComponentVisitor;
import com.thaiopensource.relaxng.edit.CompositePattern;
import com.thaiopensource.relaxng.edit.Container;
import com.thaiopensource.relaxng.edit.DataPattern;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.DivComponent;
import com.thaiopensource.relaxng.edit.ElementPattern;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.GroupPattern;
import com.thaiopensource.relaxng.edit.IncludeComponent;
import com.thaiopensource.relaxng.edit.InterleavePattern;
import com.thaiopensource.relaxng.edit.ListPattern;
import com.thaiopensource.relaxng.edit.MixedPattern;
import com.thaiopensource.relaxng.edit.NameClass;
import com.thaiopensource.relaxng.edit.NameNameClass;
import com.thaiopensource.relaxng.edit.OneOrMorePattern;
import com.thaiopensource.relaxng.edit.OptionalPattern;
import com.thaiopensource.relaxng.edit.Param;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.PatternVisitor;
import com.thaiopensource.relaxng.edit.RefPattern;
import com.thaiopensource.relaxng.edit.TextPattern;
import com.thaiopensource.relaxng.edit.ValuePattern;
import com.thaiopensource.relaxng.edit.ZeroOrMorePattern;
import com.thaiopensource.relaxng.output.OutputDirectory;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import com.thaiopensource.relaxng.output.common.NameClassSplitter;
import com.thaiopensource.util.VoidValue;
import com.thaiopensource.xml.out.CharRepertoire;
import com.thaiopensource.xml.util.Naming;
import com.thaiopensource.xml.util.WellKnownNamespaces;
import java.io.IOException;
import java.io.Writer;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.Vector;
class DtdOutput {
private final boolean warnDatatypes;
private final String sourceUri;
private Writer writer;
private String encoding;
private CharRepertoire charRepertoire;
private final int indent;
private final int lineLength;
private final String lineSep;
private final StringBuffer buf = new StringBuffer();
private final List elementQueue = new Vector();
private final List requiredParamEntities = new Vector();
private final List externallyRequiredParamEntities = new Vector();
private final Set doneParamEntities = new HashSet();
private final Set doneIncludes = new HashSet();
private final Set pendingIncludes = new HashSet();
private final Analysis analysis;
private final GrammarPart part;
private final OutputDirectory od;
private final ErrorReporter er;
private final Set reservedEntityNames;
private final PatternVisitor topLevelContentModelOutput = new TopLevelContentModelOutput();
private final AbstractVisitor nestedContentModelOutput = new ContentModelOutput();
private final PatternVisitor expandedContentModelOutput = new ExpandedContentModelOutput();
private final PatternVisitor groupContentModelOutput = new GroupContentModelOutput();
private final PatternVisitor choiceContentModelOutput = new ChoiceContentModelOutput();
private final PatternVisitor occurContentModelOutput = new ParenthesizedContentModelOutput();
private final PatternVisitor innerElementClassOutput = new InnerElementClassOutput();
private final PatternVisitor expandedInnerElementClassOutput = new ExpandedInnerElementClassOutput();
private final AttributeOutput attributeOutput = new AttributeOutput();
private final AttributeOutput optionalAttributeOutput = new OptionalAttributeOutput();
private final PatternVisitor topLevelSimpleTypeOutput = new TopLevelSimpleTypeOutput();
private final PatternVisitor nestedSimpleTypeOutput = new SimpleTypeOutput();
private final PatternVisitor valueOutput = new ValueOutput();
private final GrammarOutput grammarOutput = new GrammarOutput();
static private final String DTD_URI = "http://www.thaiopensource.com/ns/relaxng/dtd";
private DtdOutput(boolean warnDatatypes, String sourceUri, Analysis analysis, Set reservedEntityNames, OutputDirectory od, ErrorReporter er) {
this.warnDatatypes = warnDatatypes;
this.sourceUri = sourceUri;
this.analysis = analysis;
this.reservedEntityNames = reservedEntityNames;
this.od = od;
this.er = er;
this.part = analysis.getGrammarPart(sourceUri);
try {
OutputDirectory.Stream stream = od.open(sourceUri, analysis.getEncoding(sourceUri));
this.encoding = stream.getEncoding();
this.writer = stream.getWriter();
this.charRepertoire = stream.getCharRepertoire();
}
catch (IOException e) {
throw new WrappedIOException(e);
}
this.lineSep = od.getLineSeparator();
this.indent = od.getIndent();
this.lineLength = od.getLineLength();
}
class ParenthesizedContentModelOutput extends AbstractPatternVisitor {
public VoidValue visitPattern(Pattern p) {
buf.append('(');
p.accept(nestedContentModelOutput);
buf.append(')');
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
Pattern def = getBody(p.getName());
if (getContentType(def) == ContentType.DIRECT_SINGLE_ELEMENT)
((ElementPattern)def).getNameClass().accept(nestedContentModelOutput);
else
visitPattern(p);
return VoidValue.VOID;
}
public VoidValue visitElement(ElementPattern p) {
if (getContentType(p) == ContentType.DIRECT_SINGLE_ELEMENT) {
p.getNameClass().accept(nestedContentModelOutput);
elementQueue.add(p);
}
else
visitPattern(p);
return VoidValue.VOID;
}
}
class ChoiceContentModelOutput extends ParenthesizedContentModelOutput {
public VoidValue visitOptional(OptionalPattern p) {
p.accept(nestedContentModelOutput);
return VoidValue.VOID;
}
public VoidValue visitOneOrMore(OneOrMorePattern p) {
p.accept(nestedContentModelOutput);
return VoidValue.VOID;
}
public VoidValue visitZeroOrMore(ZeroOrMorePattern p) {
p.accept(nestedContentModelOutput);
return VoidValue.VOID;
}
}
private class GroupContentModelOutput extends ChoiceContentModelOutput {
public VoidValue visitGroup(GroupPattern p) {
p.accept(nestedContentModelOutput);
return VoidValue.VOID;
}
}
class ContentModelOutput extends AbstractVisitor {
public VoidValue visitName(NameNameClass nc) {
String prefix = analysis.getElementPrefixForNamespaceUri(nc.getNamespaceUri());
if (prefix != null)
buf.append(prefix).append(':');
buf.append(nc.getLocalName());
return VoidValue.VOID;
}
public VoidValue visitChoice(ChoiceNameClass nc) {
List list = nc.getChildren();
boolean needSep = false;
for (int i = 0, len = list.size(); i < len; i++) {
if (needSep)
buf.append('|');
else
needSep = true;
list.get(i).accept(this);
}
return VoidValue.VOID;
}
public VoidValue visitElement(ElementPattern p) {
p.getNameClass().accept(this);
elementQueue.add(p);
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
Pattern def = getBody(p.getName());
if (getContentType(def) == ContentType.DIRECT_SINGLE_ELEMENT)
((ElementPattern)def).getNameClass().accept(this);
else
paramEntityRef(p);
return VoidValue.VOID;
}
public VoidValue visitZeroOrMore(ZeroOrMorePattern p) {
p.getChild().accept(occurContentModelOutput);
buf.append('*');
return VoidValue.VOID;
}
public VoidValue visitOneOrMore(OneOrMorePattern p) {
p.getChild().accept(occurContentModelOutput);
ContentType t = getContentType(p);
if (t.isA(ContentType.MIXED_MODEL))
buf.append('*');
else
buf.append('+');
return VoidValue.VOID;
}
public VoidValue visitOptional(OptionalPattern p) {
p.getChild().accept(occurContentModelOutput);
buf.append('?');
return VoidValue.VOID;
}
public VoidValue visitText(TextPattern p) {
buf.append("#PCDATA");
return VoidValue.VOID;
}
public VoidValue visitMixed(MixedPattern p) {
buf.append("#PCDATA");
return VoidValue.VOID;
}
public VoidValue visitGroup(GroupPattern p) {
List list = p.getChildren();
boolean needSep = false;
final int len = list.size();
for (int i = 0; i < len; i++) {
Pattern member = list.get(i);
ContentType t = getContentType(member);
if (!t.isA(ContentType.EMPTY)) {
if (needSep)
buf.append(',');
else
needSep = true;
member.accept(groupContentModelOutput);
}
}
return VoidValue.VOID;
}
public VoidValue visitInterleave(InterleavePattern p) {
ContentType ct = getContentType(p);
if (ct == ContentType.INTERLEAVE_ZERO_OR_MORE_ELEMENT_CLASS || ct == ContentType.INTERLEAVE_MIXED_MODEL) {
buf.append('(');
p.accept(innerElementClassOutput);
buf.append(')');
buf.append('*');
}
else {
final List list = p.getChildren();
for (int i = 0, len = list.size(); i < len; i++) {
Pattern member = list.get(i);
ContentType t = getContentType(member);
if (!t.isA(ContentType.EMPTY))
member.accept(this);
}
}
return VoidValue.VOID;
}
public VoidValue visitChoice(ChoicePattern p) {
List list = p.getChildren();
boolean needSep = false;
final int len = list.size();
if (getContentType(p).isA(ContentType.MIXED_ELEMENT_CLASS)) {
for (int i = 0; i < len; i++) {
Pattern member = list.get(i);
if (getContentType(member).isA(ContentType.MIXED_ELEMENT_CLASS)) {
member.accept(nestedContentModelOutput);
needSep = true;
break;
}
}
}
for (int i = 0; i < len; i++) {
Pattern member = list.get(i);
ContentType t = getContentType(member);
if (t != ContentType.NOT_ALLOWED && t != ContentType.EMPTY && !t.isA(ContentType.MIXED_ELEMENT_CLASS)) {
if (needSep)
buf.append('|');
else
needSep = true;
member.accept(!t.isA(ContentType.ELEMENT_CLASS) ? choiceContentModelOutput : nestedContentModelOutput);
}
}
for (int i = 0; i < len; i++) {
Pattern member = list.get(i);
ContentType t = getContentType(member);
if (t == ContentType.NOT_ALLOWED) {
if (needSep)
buf.append(' ');
else
needSep = true;
member.accept(nestedContentModelOutput);
}
}
return VoidValue.VOID;
}
public VoidValue visitGrammar(GrammarPattern p) {
return getBody(DefineComponent.START).accept(this);
}
}
class TopLevelContentModelOutput extends ContentModelOutput {
public VoidValue visitZeroOrMore(ZeroOrMorePattern p) {
buf.append('(');
p.getChild().accept(nestedContentModelOutput);
buf.append(')');
buf.append('*');
return VoidValue.VOID;
}
public VoidValue visitOneOrMore(OneOrMorePattern p) {
buf.append('(');
p.getChild().accept(nestedContentModelOutput);
buf.append(')');
ContentType t = getContentType(p);
if (t.isA(ContentType.MIXED_MODEL))
buf.append('*');
else
buf.append('+');
return VoidValue.VOID;
}
public VoidValue visitOptional(OptionalPattern p) {
buf.append('(');
p.getChild().accept(nestedContentModelOutput);
buf.append(')');
buf.append('?');
return VoidValue.VOID;
}
public VoidValue visitElement(ElementPattern p) {
buf.append('(');
super.visitElement(p);
buf.append(')');
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
ContentType t = getContentType(p);
if (t.isA(ContentType.MIXED_MODEL))
super.visitRef(p);
else {
buf.append('(');
super.visitRef(p);
buf.append(')');
}
return VoidValue.VOID;
}
public VoidValue visitChoice(ChoicePattern p) {
buf.append('(');
p.accept(nestedContentModelOutput);
buf.append(')');
return VoidValue.VOID;
}
public VoidValue visitText(TextPattern p) {
buf.append('(');
p.accept(nestedContentModelOutput);
buf.append(')');
return VoidValue.VOID;
}
public VoidValue visitMixed(MixedPattern p) {
buf.append('(');
if (getContentType(p.getChild()) == ContentType.EMPTY)
buf.append("#PCDATA)");
else {
buf.append("#PCDATA|");
p.getChild().accept(innerElementClassOutput);
buf.append(')');
buf.append('*');
}
return VoidValue.VOID;
}
public VoidValue visitGroup(GroupPattern p) {
List list = p.getChildren();
Pattern main = null;
for (int i = 0, len = list.size(); i < len; i++) {
Pattern member = list.get(i);
if (!getContentType(member).isA(ContentType.EMPTY)) {
if (main == null)
main = member;
else {
buf.append('(');
nestedContentModelOutput.visitGroup(p);
buf.append(')');
return VoidValue.VOID;
}
}
}
if (main != null)
main.accept(this);
return VoidValue.VOID;
}
}
class ExpandedContentModelOutput extends ContentModelOutput {
public VoidValue visitElement(ElementPattern p) {
p.getNameClass().accept(this);
return VoidValue.VOID;
}
}
class PatternOutput extends AbstractPatternVisitor {
public VoidValue visitPattern(Pattern p) {
return VoidValue.VOID;
}
}
class InnerElementClassOutput extends PatternOutput {
public VoidValue visitRef(RefPattern p) {
getBody(p.getName()).accept(expandedInnerElementClassOutput);
return VoidValue.VOID;
}
public VoidValue visitComposite(CompositePattern p) {
List list = p.getChildren();
boolean needSep = false;
int doneIndex = -1;
for (int i = 0, len = list.size(); i < len; i++) {
Pattern member = list.get(i);
ContentType ct = getContentType(member);
if (ct.isA(ContentType.MIXED_MODEL) || ct == ContentType.TEXT) {
member.accept(this);
needSep = true;
doneIndex = i;
break;
}
}
for (int i = 0, len = list.size(); i < len; i++) {
if (i != doneIndex) {
Pattern member = list.get(i);
if (getContentType(member) != ContentType.EMPTY) {
if (needSep)
buf.append('|');
else
needSep = true;
member.accept(this);
}
}
}
return VoidValue.VOID;
}
public VoidValue visitZeroOrMore(ZeroOrMorePattern p) {
p.getChild().accept(nestedContentModelOutput);
return VoidValue.VOID;
}
public VoidValue visitOneOrMore(OneOrMorePattern p) {
p.getChild().accept(nestedContentModelOutput);
return VoidValue.VOID;
}
public VoidValue visitMixed(MixedPattern p) {
if (getContentType(p.getChild()) == ContentType.EMPTY)
buf.append("#PCDATA");
else {
buf.append("#PCDATA|");
p.getChild().accept(this);
}
return VoidValue.VOID;
}
public VoidValue visitText(TextPattern p) {
buf.append("#PCDATA");
return VoidValue.VOID;
}
}
class ExpandedInnerElementClassOutput extends InnerElementClassOutput {
public VoidValue visitZeroOrMore(ZeroOrMorePattern p) {
p.getChild().accept(expandedContentModelOutput);
return VoidValue.VOID;
}
public VoidValue visitOneOrMore(OneOrMorePattern p) {
p.getChild().accept(expandedContentModelOutput);
return VoidValue.VOID;
}
}
class AttributeOutput extends PatternOutput {
void output(Pattern p) {
if (getAttributeType(p) != AttributeType.EMPTY)
p.accept(this);
}
void newlineIndent() {
buf.append(lineSep);
for (int i = 0; i < indent; i++)
buf.append(' ');
}
public VoidValue visitComposite(CompositePattern p) {
List list = p.getChildren();
for (int i = 0, len = list.size(); i < len; i++)
output(list.get(i));
return VoidValue.VOID;
}
public VoidValue visitMixed(MixedPattern p) {
output(p.getChild());
return VoidValue.VOID;
}
public VoidValue visitOneOrMore(OneOrMorePattern p) {
output(p.getChild());
return VoidValue.VOID;
}
public VoidValue visitZeroOrMore(ZeroOrMorePattern p) {
if (getAttributeType(p) != AttributeType.SINGLE)
er.warning("attribute_occur_approx", p.getSourceLocation());
optionalAttributeOutput.output(p.getChild());
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
ContentType t = getContentType(p);
if (t.isA(ContentType.EMPTY) && isRequired()) {
if (analysis.getParamEntityElementName(p.getName()) == null) {
newlineIndent();
paramEntityRef(p);
}
}
else
output(getBody(p.getName()));
return VoidValue.VOID;
}
public VoidValue visitAttribute(AttributePattern p) {
ContentType ct = getContentType(p.getChild());
if (ct == ContentType.NOT_ALLOWED)
return VoidValue.VOID;
List names = NameClassSplitter.split(p.getNameClass());
int len = names.size();
if (len > 1)
er.warning("attribute_occur_approx", p.getSourceLocation());
for (int i = 0; i < len; i++) {
int start = buf.length();
newlineIndent();
NameNameClass nnc = names.get(i);
String ns = nnc.getNamespaceUri();
if (!ns.equals("") && ns != NameClass.INHERIT_NS) {
String prefix = analysis.getPrefixForNamespaceUri(ns);
buf.append(prefix);
buf.append(':');
}
buf.append(nnc.getLocalName());
buf.append(' ');
if (ct == ContentType.VALUE)
p.getChild().accept(valueOutput);
else {
int typeStart = buf.length();
if (ct.isA(ContentType.SIMPLE_TYPE) || ct == ContentType.TEXT)
p.getChild().accept(topLevelSimpleTypeOutput);
else if (ct == ContentType.EMPTY) {
er.warning("empty_attribute_approx", p.getSourceLocation());
buf.append("CDATA");
}
int typeEnd = buf.length();
if (isRequired() && len == 1)
buf.append(" #REQUIRED");
else {
String dv = getDefaultValue(p);
if (dv == null)
buf.append(" #IMPLIED");
else {
buf.append(' ');
attributeValueLiteral(dv);
}
}
int lineStart = start + lineSep.length();
if (buf.length() - lineStart > lineLength && ct.isA(ContentType.ENUM)) {
ModelBreaker breaker = new ModelBreaker(buf.substring(lineStart, typeStart),
buf.substring(typeStart, typeEnd),
buf.substring(typeEnd),
lineLength);
buf.setLength(start);
while (breaker.hasNextLine()) {
buf.append(lineSep);
buf.append(breaker.nextLine());
}
}
}
}
return VoidValue.VOID;
}
boolean isRequired() {
return true;
}
public VoidValue visitChoice(ChoicePattern p) {
if (getAttributeType(p) != AttributeType.EMPTY)
er.warning("attribute_occur_approx", p.getSourceLocation());
optionalAttributeOutput.visitComposite(p);
return VoidValue.VOID;
}
public VoidValue visitOptional(OptionalPattern p) {
if (getAttributeType(p) != AttributeType.SINGLE)
er.warning("attribute_occur_approx", p.getSourceLocation());
optionalAttributeOutput.output(p.getChild());
return VoidValue.VOID;
}
}
class OptionalAttributeOutput extends AttributeOutput {
boolean isRequired() {
return false;
}
}
class SimpleTypeOutput extends PatternOutput {
public VoidValue visitText(TextPattern p) {
buf.append("CDATA");
return VoidValue.VOID;
}
public VoidValue visitValue(ValuePattern p) {
buf.append(p.getValue());
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
paramEntityRef(p);
return VoidValue.VOID;
}
public VoidValue visitData(DataPattern p) {
Datatypes.Info info = Datatypes.getInfo(p.getDatatypeLibrary(), p.getType());
if (info == null) {
er.warning("unrecognized_datatype", p.getSourceLocation());
buf.append("CDATA");
}
else {
if (warnDatatypes) {
if (!info.isExact())
er.warning("datatype_approx", p.getType(), info.closestType(), p.getSourceLocation());
else {
for (Param param : p.getParams())
er.warning("ignore_param", param.getName(), p.getType(), p.getSourceLocation());
if (p.getExcept() != null)
er.warning("ignore_except", p.getType(), p.getSourceLocation());
}
}
buf.append(info.closestType());
}
return VoidValue.VOID;
}
public VoidValue visitChoice(ChoicePattern p) {
List list = p.getChildren();
boolean needSep = false;
final int len = list.size();
for (int i = 0; i < len; i++) {
Pattern member = list.get(i);
ContentType t = getContentType(member);
if (t != ContentType.NOT_ALLOWED) {
if (needSep)
buf.append('|');
else
needSep = true;
member.accept(this);
}
}
for (int i = 0; i < len; i++) {
Pattern member = list.get(i);
ContentType t = getContentType(member);
if (t == ContentType.NOT_ALLOWED) {
if (needSep)
buf.append(' ');
else
needSep = true;
member.accept(this);
}
}
return VoidValue.VOID;
}
}
class TopLevelSimpleTypeOutput extends SimpleTypeOutput {
public VoidValue visitList(ListPattern p) {
if (warnDatatypes)
er.warning("list_approx", p.getSourceLocation());
buf.append("CDATA");
return VoidValue.VOID;
}
public VoidValue visitValue(ValuePattern p) {
if (getContentType(p) == ContentType.ENUM) {
buf.append('(');
super.visitValue(p);
buf.append(')');
}
else {
Datatypes.Info info = Datatypes.getInfo(p.getDatatypeLibrary(), p.getType());
if (info == null) {
er.warning("unrecognized_datatype", p.getSourceLocation());
buf.append("CDATA");
}
else {
String type = info.closestType();
if (warnDatatypes)
er.warning("value_approx", type, p.getSourceLocation());
buf.append(type);
}
}
return VoidValue.VOID;
}
public VoidValue visitChoice(ChoicePattern p) {
ContentType t = getContentType(p);
if (t == ContentType.ENUM) {
buf.append('(');
nestedSimpleTypeOutput.visitChoice(p);
buf.append(')');
}
else if (t == ContentType.SIMPLE_TYPE_CHOICE) {
if (warnDatatypes)
er.warning("datatype_choice_approx", p.getSourceLocation());
buf.append("CDATA");
}
else
super.visitChoice(p);
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
ContentType t = getContentType(p);
if (t == ContentType.ENUM) {
buf.append('(');
super.visitRef(p);
buf.append(')');
}
else if (t == ContentType.TEXT)
buf.append("CDATA");
else
super.visitRef(p);
return VoidValue.VOID;
}
}
private class ValueOutput extends PatternOutput {
public VoidValue visitValue(ValuePattern p) {
buf.append("CDATA #FIXED ");
attributeValueLiteral(p.getValue());
return VoidValue.VOID;
}
public VoidValue visitRef(RefPattern p) {
paramEntityRef(p);
return VoidValue.VOID;
}
}
class GrammarOutput implements ComponentVisitor {
public void visitContainer(Container c) {
final List list = c.getComponents();
for (int i = 0, len = list.size(); i < len; i++)
(list.get(i)).accept(this);
}
public VoidValue visitDiv(DivComponent c) {
outputLeadingComments(c);
outputInitialChildComments(c);
visitContainer(c);
outputFollowingComments(c);
return VoidValue.VOID;
}
public VoidValue visitDefine(DefineComponent c) {
if (c.getName() == DefineComponent.START) {
outputLeadingComments(c);
outputFollowingComments(c);
if (analysis.getPattern() == analysis.getGrammarPattern())
c.getBody().accept(nestedContentModelOutput);
}
else {
if (getContentType(c.getBody()) == ContentType.DIRECT_SINGLE_ELEMENT)
outputElement((ElementPattern)c.getBody(), c);
else if (!doneParamEntities.contains(c.getName())) {
doneParamEntities.add(c.getName());
outputParamEntity(c);
}
}
outputQueuedElements();
return VoidValue.VOID;
}
public VoidValue visitInclude(IncludeComponent c) {
outputInclude(c);
return VoidValue.VOID;
}
}
void outputQueuedElements() {
for (int i = 0; i < elementQueue.size(); i++)
outputElement(elementQueue.get(i), null);
elementQueue.clear();
}
static void output(boolean warnDatatypes, Analysis analysis, OutputDirectory od, ErrorReporter er) throws IOException {
try {
new DtdOutput(warnDatatypes, analysis.getMainUri(), analysis, new HashSet(), od, er).topLevelOutput();
}
catch (WrappedIOException e) {
throw e.cause;
}
}
void topLevelOutput() {
GrammarPattern grammarPattern = analysis.getGrammarPattern();
xmlDecl();
Pattern p = analysis.getPattern();
if (p != grammarPattern) {
outputLeadingComments(p);
p.accept(nestedContentModelOutput);
outputQueuedElements();
}
if (grammarPattern != null) {
outputLeadingComments(grammarPattern);
outputInitialChildComments(grammarPattern);
grammarOutput.visitContainer(grammarPattern);
outputFollowingComments(grammarPattern);
}
close();
}
void subOutput(GrammarPattern grammarPattern) {
xmlDecl();
outputLeadingComments(grammarPattern);
outputInitialChildComments(grammarPattern);
grammarOutput.visitContainer(grammarPattern);
outputFollowingComments(grammarPattern);
close();
}
void xmlDecl() {
write("");
outputNewline();
}
ContentType getContentType(Pattern p) {
return analysis.getContentType(p);
}
AttributeType getAttributeType(Pattern p) {
return analysis.getAttributeType(p);
}
Pattern getBody(String name) {
return analysis.getBody(name);
}
void paramEntityRef(RefPattern p) {
String name = p.getName();
buf.append('%');
buf.append(name);
buf.append(';');
requiredParamEntities.add(name);
}
void attributeValueLiteral(String value) {
buf.append('\'');
for (int i = 0, len = value.length(); i < len; i++) {
char c = value.charAt(i);
switch (c) {
case '<':
buf.append("<");
break;
case '&':
buf.append("&");
break;
case '\'':
buf.append("'");
break;
case '"':
buf.append(""");
break;
case '\r':
buf.append("
");
break;
case '\n':
buf.append("
");
break;
case '\t':
buf.append(" ");
break;
default:
buf.append(c);
break;
}
}
buf.append('\'');
}
void outputRequiredComponents() {
for (int i=0; i < requiredParamEntities.size(); i++) {
String name = requiredParamEntities.get(i);
Component c = part.getWhereProvided(name);
if (c == null)
externallyRequiredParamEntities.add(name);
else if (c instanceof DefineComponent) {
if (!doneParamEntities.contains(name)) {
doneParamEntities.add(name);
outputParamEntity((DefineComponent)c);
}
}
else
outputInclude((IncludeComponent)c);
}
requiredParamEntities.clear();
}
void outputInclude(IncludeComponent inc) {
String href = inc.getUri();
if (doneIncludes.contains(href))
return;
if (pendingIncludes.contains(href)) {
er.error("sorry_include_depend", inc.getSourceLocation());
return;
}
pendingIncludes.add(href);
DtdOutput sub = new DtdOutput(warnDatatypes, href, analysis, reservedEntityNames, od, er);
GrammarPattern g = (GrammarPattern)analysis.getSchema(href);
sub.subOutput(g);
requiredParamEntities.addAll(sub.externallyRequiredParamEntities);
outputRequiredComponents();
outputLeadingComments(inc);
String entityName = genEntityName(inc);
outputNewline();
write("');
outputNewline();
write('%');
write(entityName);
write(';');
outputNewline();
outputFollowingComments(inc);
doneIncludes.add(href);
pendingIncludes.remove(href);
}
String genEntityName(IncludeComponent inc) {
String entityName = getAttributeAnnotation(inc, DTD_URI, "entityName");
if (entityName != null) {
entityName = entityName.trim();
if (!Naming.isNcname(entityName)) {
er.warning("entity_name_not_ncname", entityName, inc.getSourceLocation());
entityName = null;
}
}
if (entityName == null) {
String uri = inc.getUri();
int slash = uri.lastIndexOf('/');
if (slash >= 0)
uri = uri.substring(slash + 1);
int dot = uri.lastIndexOf('.');
if (dot > 0)
uri = uri.substring(0, dot);
if (Naming.isNcname(uri))
entityName = uri;
}
if (entityName == null)
entityName = "ent";
if (!reserveEntityName(entityName)) {
for (int i = 1;; i++) {
String tem = entityName + Integer.toString(i);
if (reserveEntityName(tem)) {
entityName = tem;
break;
}
}
}
return entityName;
}
private boolean reserveEntityName(String name) {
if (reservedEntityNames.contains(name))
return false;
reservedEntityNames.add(name);
return true;
}
void outputParamEntity(DefineComponent def) {
String name = def.getName();
Pattern body = def.getBody();
ContentType t = getContentType(body);
buf.setLength(0);
boolean wrap = true;
if (t.isA(ContentType.MODEL_GROUP) || t.isA(ContentType.NOT_ALLOWED) || t.isA(ContentType.MIXED_ELEMENT_CLASS))
body.accept(nestedContentModelOutput);
else if (t.isA(ContentType.MIXED_MODEL))
body.accept(topLevelContentModelOutput);
else if (t.isA(ContentType.EMPTY)) {
attributeOutput.output(body);
wrap = false;
}
else if (t.isA(ContentType.ENUM))
body.accept(nestedSimpleTypeOutput);
else if (t.isA(ContentType.VALUE)) {
body.accept(valueOutput);
wrap = false;
}
else if (t.isA(ContentType.SIMPLE_TYPE))
body.accept(topLevelSimpleTypeOutput);
String replacement = buf.toString();
outputRequiredComponents();
outputLeadingComments(def);
String elementName = analysis.getParamEntityElementName(name);
if (elementName != null) {
if (replacement.length() > 0) {
outputNewline();
write("');
outputNewline();
}
}
else {
doneParamEntities.add(name);
outputNewline();
String prefix = "";
if (!wrap) {
write(prefix);
write(replacement);
write(suffix);
outputNewline();
}
else
outputModelBreak(prefix, replacement, suffix);
}
outputFollowingComments(def);
}
private void outputModelBreak(String prefix, String replacement, String suffix) {
for (ModelBreaker breaker = new ModelBreaker(prefix, replacement, suffix, lineLength); breaker.hasNextLine();) {
write(breaker.nextLine());
outputNewline();
}
}
void outputElement(ElementPattern p, Annotated def) {
buf.setLength(0);
Pattern content = p.getChild();
ContentType ct = getContentType(content);
if (ct == ContentType.EMPTY)
;
else if (ct == ContentType.MIXED_ELEMENT_CLASS) {
er.warning("mixed_choice_approx", p.getSourceLocation());
buf.append("(");
content.accept(nestedContentModelOutput);
buf.append(")*");
}
else if (ct.isA(ContentType.SIMPLE_TYPE)) {
if (warnDatatypes)
er.warning("data_content_approx", p.getSourceLocation());
buf.append("(#PCDATA)");
}
else if (ct == ContentType.NOT_ALLOWED)
return; // leave it undefined
else
content.accept(topLevelContentModelOutput);
String contentModel = buf.length() == 0 ? "EMPTY" : buf.toString();
buf.setLength(0);
attributeOutput.output(content);
String atts = buf.toString();
outputRequiredComponents();
if (def != null)
outputLeadingComments(def);
outputLeadingComments(p);
List names = NameClassSplitter.split(p.getNameClass());
for (NameNameClass name : names) {
final String ns = name.getNamespaceUri();
String qName = name.getLocalName();
final String prefix = analysis.getElementPrefixForNamespaceUri(ns);
if (prefix != null)
qName = prefix + ":" + qName;
outputNewline();
outputModelBreak("");
boolean needXmlns;
if (ns == NameClass.INHERIT_NS)
needXmlns = false;
else if (prefix == null)
needXmlns = true;
else
needXmlns = !analysis.getAttributeNamespaces(content).contains(ns);
if (atts.length() != 0 || needXmlns) {
write("');
outputNewline();
}
}
if (def != null)
outputFollowingComments(def);
}
void outputAttributeNamespaces(Pattern p) {
Set namespaces = analysis.getAttributeNamespaces(p);
for (String ns : namespaces) {
String prefix = analysis.getPrefixForNamespaceUri(ns);
outputNewline();
outputIndent();
write("xmlns:");
write(prefix);
write(" CDATA #FIXED ");
buf.setLength(0);
attributeValueLiteral(ns);
write(buf.toString());
}
}
void outputLeadingComments(Annotated a) {
outputComments(a.getLeadingComments());
}
void outputInitialChildComments(Annotated a) {
outputComments(a.getChildElementAnnotations());
}
void outputFollowingComments(Annotated a) {
outputComments(a.getFollowingElementAnnotations());
}
void outputComments(List list) {
for (AnnotationChild child : list)
if (child instanceof Comment)
outputComment(((Comment)child).getValue());
}
void outputComment(String value) {
outputNewline();
write("");
outputNewline();
}
void outputIndent() {
for (int i = 0; i < indent; i++)
write(' ');
}
void outputNewline() {
write(lineSep);
}
static class WrappedIOException extends RuntimeException {
final IOException cause;
WrappedIOException(IOException cause) {
this.cause = cause;
}
public Throwable getCause() {
return cause;
}
}
void write(String s) {
try {
writer.write(s);
}
catch (IOException e) {
throw new WrappedIOException(e);
}
}
void write(char c) {
try {
writer.write(c);
}
catch (IOException e) {
throw new WrappedIOException(e);
}
}
void close() {
try {
writer.close();
}
catch (IOException e) {
throw new WrappedIOException(e);
}
}
private static String getDefaultValue(AttributePattern p) {
return getAttributeAnnotation(p, WellKnownNamespaces.RELAX_NG_COMPATIBILITY_ANNOTATIONS, "defaultValue");
}
private static String getAttributeAnnotation(Annotated p, String ns, String localName) {
List list = p.getAttributeAnnotations();
for (int i = 0, len = list.size(); i < len; i++) {
AttributeAnnotation att = list.get(i);
if (att.getLocalName().equals(localName)
&& att.getNamespaceUri().equals(ns))
return att.getValue();
}
return null;
}
}
DtdOutputFormat.java 0000664 0000000 0000000 00000002502 13520105541 0035426 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.output.OutputFormat;
import com.thaiopensource.relaxng.output.OutputDirectory;
import com.thaiopensource.relaxng.output.OutputFailedException;
import com.thaiopensource.relaxng.output.OutputDirectoryParamProcessor;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.translate.util.InvalidParamsException;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import java.io.IOException;
public class DtdOutputFormat implements OutputFormat {
public void output(SchemaCollection sc, final OutputDirectory od, String[] params, String inputFormat, ErrorHandler eh)
throws SAXException, IOException, OutputFailedException, InvalidParamsException {
new OutputDirectoryParamProcessor(od).process(params, eh);
Simplifier.simplify(sc);
try {
ErrorReporter er = new ErrorReporter(eh, DtdOutputFormat.class);
Analysis analysis = new Analysis(sc, er);
if (!er.getHadError())
DtdOutput.output(!inputFormat.equals("xml"), analysis, od, er);
if (er.getHadError())
throw new OutputFailedException();
}
catch (ErrorReporter.WrappedSAXException e) {
throw e.getException();
}
}
}
GrammarPart.java 0000664 0000000 0000000 00000011163 13520105541 0034541 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.edit.Combine;
import com.thaiopensource.relaxng.edit.Component;
import com.thaiopensource.relaxng.edit.ComponentVisitor;
import com.thaiopensource.relaxng.edit.Container;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.DivComponent;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.IncludeComponent;
import com.thaiopensource.relaxng.edit.InterleavePattern;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.util.VoidValue;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
class GrammarPart implements ComponentVisitor {
private final ErrorReporter er;
private final Map defines;
private final Set attlists;
private final Set implicitlyCombinedDefines;
private final Map combineTypes;
private final SchemaCollection schemas;
private final Map parts;
// maps name to component that provides it
private final Map whereProvided = new HashMap();
private final Set pendingIncludes;
public static class IncludeLoopException extends RuntimeException {
private final IncludeComponent include;
public IncludeLoopException(IncludeComponent include) {
this.include = include;
}
public IncludeComponent getInclude() {
return include;
}
}
GrammarPart(ErrorReporter er, Map defines, Set attlists, SchemaCollection schemas, Map parts, GrammarPattern p) {
this.er = er;
this.defines = defines;
this.attlists = attlists;
this.schemas = schemas;
this.parts = parts;
this.pendingIncludes = new HashSet();
this.implicitlyCombinedDefines = new HashSet();
this.combineTypes = new HashMap();
visitContainer(p);
}
private GrammarPart(GrammarPart part, GrammarPattern p) {
er = part.er;
defines = part.defines;
schemas = part.schemas;
parts = part.parts;
attlists = part.attlists;
pendingIncludes = part.pendingIncludes;
implicitlyCombinedDefines = part.implicitlyCombinedDefines;
combineTypes = part.combineTypes;
visitContainer(p);
}
Set providedSet() {
return whereProvided.keySet();
}
public VoidValue visitContainer(Container c) {
List list = c.getComponents();
for (int i = 0, len = list.size(); i < len; i++)
(list.get(i)).accept(this);
return VoidValue.VOID;
}
public VoidValue visitDiv(DivComponent c) {
return visitContainer(c);
}
public VoidValue visitDefine(DefineComponent c) {
String name = c.getName();
Combine combine = c.getCombine();
if (combine == null) {
if (implicitlyCombinedDefines.contains(name))
er.error("multiple_no_combine", name, c.getSourceLocation());
else
implicitlyCombinedDefines.add(name);
}
else {
Combine oldCombine = combineTypes.get(name);
if (oldCombine != null) {
if (oldCombine != combine)
er.error("inconsistent_combine", c.getSourceLocation());
}
else
combineTypes.put(name, combine);
}
Pattern oldDef = defines.get(name);
if (oldDef != null) {
if (combine == Combine.CHOICE)
er.error("sorry_combine_choice", c.getSourceLocation());
else if (combine == Combine.INTERLEAVE) {
InterleavePattern ip = new InterleavePattern();
ip.getChildren().add(oldDef);
ip.getChildren().add(c.getBody());
ip.setSourceLocation(c.getSourceLocation());
defines.put(name, ip);
attlists.add(name);
}
}
else {
defines.put(name, c.getBody());
whereProvided.put(name, c);
}
return VoidValue.VOID;
}
public VoidValue visitInclude(IncludeComponent c) {
String uri = c.getUri();
if (pendingIncludes.contains(uri))
throw new IncludeLoopException(c);
pendingIncludes.add(uri);
GrammarPattern p = (GrammarPattern)(schemas.getSchemaDocumentMap().get(uri)).getPattern();
GrammarPart part = new GrammarPart(this, p);
parts.put(uri, part);
for (String name : part.providedSet())
whereProvided.put(name, c);
pendingIncludes.remove(uri);
return VoidValue.VOID;
}
Component getWhereProvided(String paramEntityName) {
return whereProvided.get(paramEntityName);
}
}
ModelBreaker.java 0000664 0000000 0000000 00000011163 13520105541 0034660 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import java.util.NoSuchElementException;
class ModelBreaker {
private boolean done = false;
private BreakIterator iter;
private final String prefix;
private final String model;
private final String suffix;
private final int maxLineLength;
private int modelPos;
private ModelBreaker nested = null;
private static class BreakIterator {
private final String model;
private int pos = 0;
private final int length;
BreakIterator(String model) {
this.model = model;
this.length = model.length();
}
int getPos() {
return pos;
}
boolean advance() {
boolean advanced = false;
int level = 0;
for (; pos < length; pos++) {
switch (model.charAt(pos)) {
case '(':
level++;
break;
case ')':
level--;
break;
case ',':
if (level != 0)
break;
if (++pos != length)
return true;
break;
case '|':
if (level != 0 || !advanced)
break;
return true;
case ' ':
if (level != 0 || !advanced)
break;
return true;
}
advanced = true;
}
return false;
}
}
ModelBreaker(String prefix, String model, String suffix, int maxLineLength) {
if (isSingleGroup(model)) {
int open = model.indexOf('(') + 1;
this.prefix = prefix + model.substring(0, open);
this.model = model.substring(open);
}
else {
this.prefix = prefix;
this.model = model;
}
this.suffix = suffix;
this.maxLineLength = maxLineLength;
this.modelPos = 0;
}
boolean hasNextLine() {
if (nested != null && nested.hasNextLine())
return true;
return !done;
}
String nextLine() {
if (nested != null && nested.hasNextLine())
return nested.nextLine();
if (done)
throw new NoSuchElementException();
int avail = maxLineLength - prefix.length();
int breakPos;
boolean tooBig = false;
if ((model.length() - modelPos) + suffix.length() > avail) {
if (iter == null)
iter = new BreakIterator(model);
breakPos = -1;
do {
int pos = iter.getPos();
if (pos >= model.length())
break;
int w = pos - modelPos;
if (w > 0) {
if (w > avail) {
if (breakPos == -1) {
breakPos = pos;
tooBig = true;
}
break;
}
breakPos = pos;
}
} while (iter.advance());
if (breakPos == -1) {
tooBig = true;
breakPos = model.length();
}
}
else
breakPos = model.length();
int nextModelPos;
if (breakPos < model.length() && model.charAt(breakPos) == ' ')
nextModelPos = breakPos + 1;
else
nextModelPos = breakPos;
StringBuffer buf = new StringBuffer();
if (modelPos == 0)
buf.append(prefix);
else {
for (int i = 0, len = prefix.length(); i < len; i++)
buf.append(' ');
}
if (tooBig && (modelPos != 0 || breakPos != model.length())) {
String nestSuffix;
if (breakPos == model.length()) {
done = true;
nestSuffix = suffix;
}
else
nestSuffix = "";
nested = new ModelBreaker(buf.toString(), model.substring(modelPos, breakPos), nestSuffix, maxLineLength);
modelPos = nextModelPos;
return nested.nextLine();
}
buf.append(model.substring(modelPos, breakPos));
if (nextModelPos == model.length()) {
done = true;
buf.append(suffix);
}
modelPos = nextModelPos;
return buf.toString();
}
private static boolean isSingleGroup(String model) {
int length = model.length();
if (length == 0)
return false;
int i = 0;
if (model.charAt(0) == '|')
i++;
if (model.charAt(i) != '(')
return false;
loop:
while (length > i) {
switch (model.charAt(length - 1)) {
case '*': case '+': case '?': case ',': case '|': case ')':
length--;
break;
default:
break loop;
}
}
int level = 0;
for (++i; i < length; i++)
switch (model.charAt(i)) {
case '(':
level++;
break;
case ')':
if (level == 0)
return false;
level--;
break;
}
return true;
}
static public void main(String[] args) throws NumberFormatException {
for (ModelBreaker breaker = new ModelBreaker(args[0], args[1], args[2], Integer.parseInt(args[3]));
breaker.hasNextLine();)
System.err.println(breaker.nextLine());
}
}
NamespaceManager.java 0000664 0000000 0000000 00000004022 13520105541 0035507 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.edit.NameClass;
import com.thaiopensource.relaxng.edit.NameNameClass;
import com.thaiopensource.xml.util.WellKnownNamespaces;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
class NamespaceManager {
// map namespace URIs to non-empty prefix
private final Map namespaceUriMap = new HashMap();
private String defaultNamespaceUri = null;
private final Set usedPrefixes = new HashSet();
private final Set unassignedNamespaceUris = new HashSet();
NamespaceManager() {
usedPrefixes.add("xml");
namespaceUriMap.put(WellKnownNamespaces.XML, "xml");
}
String getPrefixForNamespaceUri(String ns) {
return namespaceUriMap.get(ns);
}
String getDefaultNamespaceUri() {
return defaultNamespaceUri;
}
void assignPrefixes() {
if (defaultNamespaceUri == null)
defaultNamespaceUri = "";
int n = 0;
for (String ns : unassignedNamespaceUris) {
for (; ;) {
++n;
String prefix = "ns" + Integer.toString(n);
if (!usedPrefixes.contains(prefix)) {
namespaceUriMap.put(ns, prefix);
break;
}
}
}
}
void noteName(NameNameClass nc, boolean defaultable) {
String ns = nc.getNamespaceUri();
if (ns.equals("") || ns == NameClass.INHERIT_NS) {
if (defaultable)
defaultNamespaceUri = "";
return;
}
String assignedPrefix = namespaceUriMap.get(ns);
if (assignedPrefix != null)
return;
String prefix = nc.getPrefix();
if (prefix == null) {
if (defaultNamespaceUri == null && defaultable)
defaultNamespaceUri = ns;
unassignedNamespaceUris.add(ns);
}
else {
if (usedPrefixes.contains(prefix))
unassignedNamespaceUris.add(ns);
else {
usedPrefixes.add(prefix);
namespaceUriMap.put(ns, prefix);
unassignedNamespaceUris.remove(ns);
}
}
}
}
Simplifier.java 0000664 0000000 0000000 00000010653 13520105541 0034432 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd package com.thaiopensource.relaxng.output.dtd;
import com.thaiopensource.relaxng.edit.AbstractPatternVisitor;
import com.thaiopensource.relaxng.edit.Annotated;
import com.thaiopensource.relaxng.edit.ChoicePattern;
import com.thaiopensource.relaxng.edit.Component;
import com.thaiopensource.relaxng.edit.ComponentVisitor;
import com.thaiopensource.relaxng.edit.CompositePattern;
import com.thaiopensource.relaxng.edit.Container;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.DivComponent;
import com.thaiopensource.relaxng.edit.EmptyPattern;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.IncludeComponent;
import com.thaiopensource.relaxng.edit.InterleavePattern;
import com.thaiopensource.relaxng.edit.MixedPattern;
import com.thaiopensource.relaxng.edit.NotAllowedPattern;
import com.thaiopensource.relaxng.edit.OneOrMorePattern;
import com.thaiopensource.relaxng.edit.OptionalPattern;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.SchemaCollection;
import com.thaiopensource.relaxng.edit.SchemaDocument;
import com.thaiopensource.relaxng.edit.TextPattern;
import com.thaiopensource.relaxng.edit.UnaryPattern;
import com.thaiopensource.util.VoidValue;
import com.thaiopensource.relaxng.edit.ZeroOrMorePattern;
import java.util.Iterator;
import java.util.List;
class Simplifier extends AbstractPatternVisitor implements ComponentVisitor {
public static void simplify(SchemaCollection sc) {
Simplifier simplifier = new Simplifier();
for (SchemaDocument sd : sc.getSchemaDocumentMap().values())
sd.setPattern(sd.getPattern().accept(simplifier));
}
private Simplifier() {
}
public Pattern visitGrammar(GrammarPattern p) {
visitContainer(p);
return p;
}
public VoidValue visitContainer(Container c) {
for (Component component : c.getComponents())
component.accept(this);
return VoidValue.VOID;
}
public VoidValue visitInclude(IncludeComponent c) {
return visitContainer(c);
}
public VoidValue visitDiv(DivComponent c) {
return visitContainer(c);
}
public VoidValue visitDefine(DefineComponent c) {
c.setBody(c.getBody().accept(this));
return VoidValue.VOID;
}
public Pattern visitChoice(ChoicePattern p) {
boolean hadEmpty = false;
List list = p.getChildren();
for (int i = 0, len = list.size(); i < len; i++)
list.set(i, list.get(i).accept(this));
for (Iterator iter = list.iterator(); iter.hasNext();) {
Pattern child = iter.next();
if (child instanceof NotAllowedPattern)
iter.remove();
else if (child instanceof EmptyPattern) {
hadEmpty = true;
iter.remove();
}
}
if (list.size() == 0)
return copy(new NotAllowedPattern(), p);
Pattern tem;
if (list.size() == 1)
tem = list.get(0);
else
tem = p;
if (hadEmpty && !(tem instanceof OptionalPattern) && !(tem instanceof ZeroOrMorePattern)) {
if (tem instanceof OneOrMorePattern)
tem = new ZeroOrMorePattern(((OneOrMorePattern)tem).getChild());
else
tem = new OptionalPattern(tem);
copy(tem, p);
}
return tem;
}
public Pattern visitComposite(CompositePattern p) {
List list = p.getChildren();
for (int i = 0, len = list.size(); i < len; i++)
list.set(i, list.get(i).accept(this));
for (Iterator iter = list.iterator(); iter.hasNext();) {
Pattern child = iter.next();
if (child instanceof EmptyPattern)
iter.remove();
}
if (list.size() == 0)
return copy(new EmptyPattern(), p);
if (list.size() == 1)
return p.getChildren().get(0);
return p;
}
public Pattern visitInterleave(InterleavePattern p) {
boolean hadText = false;
for (Iterator iter = p.getChildren().iterator(); iter.hasNext();) {
Pattern child = iter.next();
if (child instanceof TextPattern) {
iter.remove();
hadText = true;
}
}
if (!hadText)
return visitComposite(p);
return copy(new MixedPattern(visitComposite(p)), p);
}
public Pattern visitUnary(UnaryPattern p) {
p.setChild(p.getChild().accept(this));
return p;
}
private static T copy(T to, T from) {
to.setSourceLocation(from.getSourceLocation());
return to;
}
public Pattern visitPattern(Pattern p) {
return p;
}
}
resources/ 0000775 0000000 0000000 00000000000 13520105541 0033471 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd Messages.properties 0000664 0000000 0000000 00000004432 13520105541 0037361 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-dtd/src/main/com/thaiopensource/relaxng/output/dtd/resources datatype_approx=approximating datatype \"{0}\" by \"{1}\"
value_approx=approximating value by \"{0}\"
data_content_approx=approximating datatype in content by \"#PCDATA\"
datatype_choice_approx=approximating choice of datatypes by \"CDATA\"
empty_attribute_approx=approximating empty attribute by \"CDATA\"
mixed_choice_approx=approximating mixed choice by repeated mixed choice
list_approx=approximating \"list\" by \"CDATA\"
attribute_occur_approx=approximating attribute occurrence
include_loop=include loop
ref_loop=illegal recursive reference
bad_attribute_type=illegal content for \"attribute\" content
sorry_choice=sorry, cannot handle this kind of \"choice\"
sorry_external_ref=sorry, \"externalRef\" is not supported
sorry_group=sorry, cannot handle this kind of \"group\"
sorry_include_depend=sorry, include depend
sorry_interleave=sorry, cannot handle this kind of \"interleave\"
sorry_mixed=sorry, cannot handle this kind of \"mixed\"
multiple_no_combine=multiple definitions of \"{0}\" without a \"combine\" attribute
inconsistent_combine=inconsistent values for the \"combine\" attribute
sorry_combine_choice=sorry, combining definitions with combine=\"choice\" is not supported
sorry_nested_grammar=sorry, nested grammars are not supported
sorry_one_or_more=sorry, cannot handle this kind of \"oneOrMore\"
sorry_optional=sorry, cannot handle this kind of \"optional\"
sorry_parent_ref=sorry, \"parent\" is not supported
sorry_wildcard=sorry, wildcards are not supported
sorry_zero_or_more=sorry, cannot handle this kind of \"zeroOrMore\"
undefined_ref=reference to undefined pattern
unrecognized_datatype=unrecognized datatype
sorry_include_override=sorry, cannot handle overrides inside \"include\"
sorry_multiple_element=sorry, not handled: duplicate declaration of element \"{1}\" from namespace \"{0}\"
other_element=other element declaration is here
sorry_choice_attribute_name=sorry, ambiguous attribute choice not handled (attribute \"{1}\" from namespace \"{0}\")
not_attlist=\"{0}\" does not correspond to an ATTLIST declarations and so cannot be combined with \"interleave\"
ignore_param=ignoring parameter \"{0}\" of datatype \"{1}\"
ignore_except=ignoring exception applying to datatype \"{0}\"
entity_name_not_ncname=value of entityName annotation attribute \"{0}\" is not allowed as an XML entity name jing-trang-20181222+dfsg2/mod/convert-to-dtd/todo.txt 0000664 0000000 0000000 00000002456 13520105541 0022157 0 ustar 00root root 0000000 0000000 Generate comments from a:documentation elements
Avoid warning for content that is data of type string
Option to generate namespace declarations only on start elements
Generate parameter entities to allow change of namespace prefix
Support nested grammars
Check for non-deterministic content models
Option to protect attlist/element declarations with marked section
Allow mixed(repeat(NOT_ALLOWED))
Prettier formatting of ATTLISTs
Order requiredParamEntities by definition order
Customizable indent and line length
Approximate by NMTOKENS when possible
Have a top-level annotation indicating a redefinition point (as in DocBook)
Recognize definitions being used as INCLUDE/IGNORE (as in TEI)
Give warnings for definitions that had to be expanded
Closer approximation of choice of datatypes
Approximate when single element restriction is violated
Allow choice of attributes and data
Try to push namespace declarations down into appropriate attribute groups
Support for ANY
used as a model-group hook
Approximate wildcards intelligently
Handle interleave of zero or more element class with model group
Turn elements with content into EMPTY.
Deal with characters outside repertoire of character encoding.
Investigate using compact syntax pretty-printer for formatting content models.
jing-trang-20181222+dfsg2/mod/convert-to-xsd/ 0000775 0000000 0000000 00000000000 13520105541 0020465 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/mod.xml 0000664 0000000 0000000 00000000320 13520105541 0021761 0 ustar 00root root 0000000 0000000
jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/ 0000775 0000000 0000000 00000000000 13520105541 0021254 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/ 0000775 0000000 0000000 00000000000 13520105541 0022200 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/ 0000775 0000000 0000000 00000000000 13520105541 0022756 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/thaiopensource/ 0000775 0000000 0000000 00000000000 13520105541 0026006 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/thaiopensource/relaxng/ 0000775 0000000 0000000 00000000000 13520105541 0027446 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/thaiopensource/relaxng/output/ 0000775 0000000 0000000 00000000000 13520105541 0031006 5 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/thaiopensource/relaxng/output/xsd/ 0000775 0000000 0000000 00000000000 13520105541 0031604 5 ustar 00root root 0000000 0000000 AbstractElementTypeSelector.java 0000664 0000000 0000000 00000013661 13520105541 0040017 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/thaiopensource/relaxng/output/xsd package com.thaiopensource.relaxng.output.xsd;
import com.thaiopensource.relaxng.output.xsd.basic.AttributeGroup;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexType;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexTypeComplexContent;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexTypeNotAllowedContent;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexTypeSimpleContent;
import com.thaiopensource.relaxng.output.xsd.basic.Element;
import com.thaiopensource.relaxng.output.xsd.basic.Particle;
import com.thaiopensource.relaxng.output.xsd.basic.Schema;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleType;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleTypeRef;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleTypeRestriction;
import com.thaiopensource.xml.util.Name;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
class AbstractElementTypeSelector {
private final Schema schema;
private final NamespaceManager nsm;
private final ComplexTypeSelector complexTypeSelector;
private final Map abstractElementComplexTypeMap = new HashMap();
private final ComplexType urType = new ComplexTypeNotAllowedContent();
AbstractElementTypeSelector(Schema schema, NamespaceManager nsm, ComplexTypeSelector complexTypeSelector) {
this.schema = schema;
this.nsm = nsm;
this.complexTypeSelector = complexTypeSelector;
}
ComplexType getAbstractElementType(Name name) {
ComplexType ct = abstractElementComplexTypeMap.get(name);
if (ct == null) {
ct = computeAbstractElementType(name);
if (ct == null)
ct = urType;
abstractElementComplexTypeMap.put(name, ct);
}
if (ct == urType)
return null;
return ct;
}
private ComplexType computeAbstractElementType(Name name) {
List members = nsm.getAbstractElementSubstitutionGroupMembers(name);
if (members == null)
return null;
ComplexType commonType = null;
for (Name member : members) {
ComplexType ct = getElementType(member, nsm);
if (ct == null)
return null;
if (commonType == null)
commonType = ct;
else {
commonType = commonBaseType(commonType, ct);
if (commonType == null)
return null;
}
}
return commonType;
}
private ComplexType commonBaseType(ComplexType ct1, ComplexType ct2) {
if (ct1.equals(ct2))
return ct1;
if (isValidlyDerived(ct1, ct2))
return ct2;
if (isValidlyDerived(ct2, ct1))
return ct1;
return null;
}
private boolean isValidlyDerived(ComplexType ct1, ComplexType ct2) {
if (ct1 instanceof ComplexTypeComplexContent && ct2 instanceof ComplexTypeComplexContent)
return isComplexContentValidlyDerived((ComplexTypeComplexContent)ct1, (ComplexTypeComplexContent)ct2);
if (ct1 instanceof ComplexTypeSimpleContent && ct2 instanceof ComplexTypeSimpleContent)
return isSimpleContentValidlyDerived((ComplexTypeSimpleContent)ct1, (ComplexTypeSimpleContent)ct2);
return false;
}
private boolean isComplexContentValidlyDerived(ComplexTypeComplexContent ct1, ComplexTypeComplexContent ct2) {
ComplexTypeComplexContentExtension ex = complexTypeSelector.transformComplexContent(ct2);
String base = ex.getBase();
if (base == null || ex.getParticle() != null || !ex.getAttributeUses().equals(AttributeGroup.EMPTY) || ex.isMixed())
return false;
Particle particle = ct1.getParticle();
for (;;) {
String tem = complexTypeSelector.particleBase(particle);
if (base.equals(tem))
return true;
if (tem == null)
break;
if (!complexTypeSelector.isComplexType(tem))
break;
particle = schema.getGroup(tem).getParticle();
}
return false;
}
private boolean isSimpleContentValidlyDerived(ComplexTypeSimpleContent ct1, ComplexTypeSimpleContent ct2) {
ComplexTypeSimpleContentExtension ex = complexTypeSelector.transformSimpleContent(ct2);
if (!ex.getAttributeUses().equals(AttributeGroup.EMPTY))
return false;
String base = ex.getBase();
if (base == null)
return isSimpleTypeValidlyDerived(ct1.getSimpleType(), ex.getSimpleType());
else
return isSimpleTypeValidlyDerivedFromName(ct1.getSimpleType(), base);
}
private boolean isSimpleTypeValidlyDerived(SimpleType st1, SimpleType st2) {
// XXX take advantage of cos-st-derived-ok 2.2.4 (SQC seems to have bugs here)
if (st2.getAnnotation() != null)
return false;
if (st2 instanceof SimpleTypeRef)
return isSimpleTypeValidlyDerivedFromName(st1, ((SimpleTypeRef)st2).getName());
if (st2 instanceof SimpleTypeRestriction) {
SimpleTypeRestriction restriction = (SimpleTypeRestriction)st2;
if (restriction.getFacets().size() > 0)
return false;
return isSimpleTypeValidlyDerivedFromBuiltin(st1, restriction.getName());
}
return false;
}
private boolean isSimpleTypeValidlyDerivedFromName(SimpleType st, String typeName) {
while (st instanceof SimpleTypeRef) {
String tem = ((SimpleTypeRef)st).getName();
if (tem.equals(typeName))
return true;
st = schema.getSimpleType(tem).getSimpleType();
}
return false;
}
private boolean isSimpleTypeValidlyDerivedFromBuiltin(SimpleType st, String builtinTypeName) {
while (st instanceof SimpleTypeRef)
st = schema.getSimpleType(((SimpleTypeRef)st).getName()).getSimpleType();
if (!(st instanceof SimpleTypeRestriction))
return false;
String tem = ((SimpleTypeRestriction)st).getName();
do {
if (tem.equals(builtinTypeName))
return true;
tem = BuiltinSimpleTypeHierarchy.getParentType(tem);
} while (tem != null);
return false;
}
private ComplexType getElementType(Name name, NamespaceManager nsm) {
Element element = nsm.getGlobalElement(name);
if (element != null)
return element.getComplexType();
return getAbstractElementType(name);
}
}
BasicBuilder.java 0000664 0000000 0000000 00000076474 13520105541 0034742 0 ustar 00root root 0000000 0000000 jing-trang-20181222+dfsg2/mod/convert-to-xsd/src/main/com/thaiopensource/relaxng/output/xsd package com.thaiopensource.relaxng.output.xsd;
import com.thaiopensource.relaxng.edit.AbstractPatternVisitor;
import com.thaiopensource.relaxng.edit.Annotated;
import com.thaiopensource.relaxng.edit.AnnotationChild;
import com.thaiopensource.relaxng.edit.AttributePattern;
import com.thaiopensource.relaxng.edit.ChoicePattern;
import com.thaiopensource.relaxng.edit.Comment;
import com.thaiopensource.relaxng.edit.ComponentVisitor;
import com.thaiopensource.relaxng.edit.CompositePattern;
import com.thaiopensource.relaxng.edit.DataPattern;
import com.thaiopensource.relaxng.edit.DefineComponent;
import com.thaiopensource.relaxng.edit.DivComponent;
import com.thaiopensource.relaxng.edit.ElementAnnotation;
import com.thaiopensource.relaxng.edit.ElementPattern;
import com.thaiopensource.relaxng.edit.EmptyPattern;
import com.thaiopensource.relaxng.edit.GrammarPattern;
import com.thaiopensource.relaxng.edit.GroupPattern;
import com.thaiopensource.relaxng.edit.IncludeComponent;
import com.thaiopensource.relaxng.edit.InterleavePattern;
import com.thaiopensource.relaxng.edit.ListPattern;
import com.thaiopensource.relaxng.edit.MixedPattern;
import com.thaiopensource.relaxng.edit.NameNameClass;
import com.thaiopensource.relaxng.edit.OneOrMorePattern;
import com.thaiopensource.relaxng.edit.OptionalPattern;
import com.thaiopensource.relaxng.edit.Param;
import com.thaiopensource.relaxng.edit.Pattern;
import com.thaiopensource.relaxng.edit.PatternVisitor;
import com.thaiopensource.relaxng.edit.RefPattern;
import com.thaiopensource.relaxng.edit.SourceLocation;
import com.thaiopensource.relaxng.edit.TextAnnotation;
import com.thaiopensource.relaxng.edit.TextPattern;
import com.thaiopensource.relaxng.edit.UnaryPattern;
import com.thaiopensource.relaxng.edit.ValuePattern;
import com.thaiopensource.util.VoidValue;
import com.thaiopensource.relaxng.edit.ZeroOrMorePattern;
import com.thaiopensource.relaxng.output.common.ErrorReporter;
import com.thaiopensource.relaxng.output.common.NameClassSplitter;
import com.thaiopensource.relaxng.output.xsd.basic.Annotation;
import com.thaiopensource.relaxng.output.xsd.basic.Attribute;
import com.thaiopensource.relaxng.output.xsd.basic.AttributeGroup;
import com.thaiopensource.relaxng.output.xsd.basic.AttributeGroupRef;
import com.thaiopensource.relaxng.output.xsd.basic.AttributeUse;
import com.thaiopensource.relaxng.output.xsd.basic.AttributeUseChoice;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexType;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexTypeComplexContent;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexTypeNotAllowedContent;
import com.thaiopensource.relaxng.output.xsd.basic.ComplexTypeSimpleContent;
import com.thaiopensource.relaxng.output.xsd.basic.Element;
import com.thaiopensource.relaxng.output.xsd.basic.Facet;
import com.thaiopensource.relaxng.output.xsd.basic.GroupRef;
import com.thaiopensource.relaxng.output.xsd.basic.Occurs;
import com.thaiopensource.relaxng.output.xsd.basic.OptionalAttribute;
import com.thaiopensource.relaxng.output.xsd.basic.Particle;
import com.thaiopensource.relaxng.output.xsd.basic.ParticleAll;
import com.thaiopensource.relaxng.output.xsd.basic.ParticleChoice;
import com.thaiopensource.relaxng.output.xsd.basic.ParticleRepeat;
import com.thaiopensource.relaxng.output.xsd.basic.ParticleSequence;
import com.thaiopensource.relaxng.output.xsd.basic.Schema;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleType;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleTypeList;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleTypeRef;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleTypeRestriction;
import com.thaiopensource.relaxng.output.xsd.basic.SimpleTypeUnion;
import com.thaiopensource.relaxng.output.xsd.basic.Wildcard;
import com.thaiopensource.relaxng.output.xsd.basic.WildcardAttribute;
import com.thaiopensource.relaxng.output.xsd.basic.WildcardElement;
import com.thaiopensource.xml.util.Name;
import com.thaiopensource.xml.util.WellKnownNamespaces;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
public class BasicBuilder {
private final PatternVisitor simpleTypeBuilder = new SimpleTypeBuilder();
private final PatternVisitor attributeUseBuilder = new AttributeUseBuilder();
private final PatternVisitor optionalAttributeUseBuilder = new OptionalAttributeUseBuilder();
private final PatternVisitor particleBuilder = new ParticleBuilder();
private final PatternVisitor occursCalculator = new OccursCalculator();
private final ComponentVisitor schemaBuilder;
private final ErrorReporter er;
private final String inheritedNamespace;
private final Schema schema;
private final SchemaInfo si;
private final Guide guide;
/**
* Preconditions for calling visit methods in this class are that the child type
* - contains DATA
* - does not contains ELEMENT
* - does not contain TEXT
*/
private class SimpleTypeBuilder extends AbstractPatternVisitor {
public SimpleType visitData(DataPattern p) {
String library = p.getDatatypeLibrary();
String type = p.getType();
List