org.apache.xmlbeans.impl.tool.XsbDumper Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of aem-sdk-api Show documentation
Show all versions of aem-sdk-api Show documentation
The Adobe Experience Manager SDK
/* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.xmlbeans.impl.tool;
import org.apache.xmlbeans.*;
import org.apache.xmlbeans.impl.common.QNameHelper;
import org.apache.xmlbeans.impl.util.HexBin;
import org.apache.xmlbeans.impl.util.LongUTFDataInputStream;
import org.apache.xmlbeans.soap.SOAPArrayType;
import javax.xml.namespace.QName;
import java.io.*;
import java.math.BigInteger;
import java.nio.charset.StandardCharsets;
import java.util.*;
import java.util.zip.ZipEntry;
import java.util.zip.ZipFile;
public class XsbDumper {
public static void printUsage() {
System.out.println("Prints the contents of an XSB file in human-readable form.");
System.out.println("An XSB file contains schema meta information needed to ");
System.out.println("perform tasks such as binding and validation.");
System.out.println("Usage: dumpxsb myfile.xsb");
System.out.println(" myfile.xsb - Path to an XSB file.");
System.out.println();
}
public static void main(String[] args) {
if (args.length == 0) {
printUsage();
System.exit(0);
return;
}
for (String arg : args) {
dump(new File(arg), true);
}
}
private static void dump(File file, boolean force) {
if (file.isDirectory()) {
File[] files = file.listFiles(
file1 -> file1.isDirectory() || file1.isFile() && file1.getName().endsWith(".xsb")
);
if (files != null) {
for (File value : files) {
dump(value, false);
}
}
} else if (file.getName().endsWith(".jar") || file.getName().endsWith(".zip")) {
dumpZip(file);
} else if (force || file.getName().endsWith(".xsb")) {
try {
System.out.println(file.toString());
dump(new FileInputStream(file), " ");
System.out.println();
} catch (FileNotFoundException e) {
System.out.println(e.toString());
}
}
}
public static void dumpZip(File file) {
try (ZipFile zipFile = new ZipFile(file)) {
Enumeration e = zipFile.entries();
while (e.hasMoreElements()) {
ZipEntry entry = e.nextElement();
if (entry.getName().endsWith(".xsb")) {
System.out.println(entry.getName());
dump(zipFile.getInputStream(entry), " ");
System.out.println();
}
}
} catch (IOException e) {
System.out.println(e.toString());
}
}
public static void dump(InputStream input) {
dump(input, "", System.out);
}
public static void dump(InputStream input, String indent) {
dump(input, indent, System.out);
}
public static void dump(InputStream input, String indent, PrintStream output) {
XsbDumper dumper = new XsbDumper(input, indent, output);
dumper.dumpAll();
}
private XsbDumper(InputStream stream, String indent, PrintStream ostream) {
_input = new LongUTFDataInputStream(stream);
_indent = indent;
_out = ostream;
}
void flush() {
_out.flush();
}
void emit(String str) {
_out.println(_indent + str);
flush();
}
void error(Exception e) {
_out.println(e.toString());
flush();
throw new IllegalStateException(e.getMessage(), e);
}
void error(String str) {
_out.println(str);
flush();
throw new IllegalStateException(str);
}
private String _indent;
private final PrintStream _out;
void indent() {
_indent += " ";
}
void outdent() {
_indent = _indent.substring(0, _indent.length() - 2);
}
public static final int DATA_BABE = 0xDA7ABABE;
public static final int MAJOR_VERSION = 2;
public static final int MINOR_VERSION = 24;
public static final int FILETYPE_SCHEMAINDEX = 1;
public static final int FILETYPE_SCHEMATYPE = 2;
public static final int FILETYPE_SCHEMAELEMENT = 3;
public static final int FILETYPE_SCHEMAATTRIBUTE = 4;
public static final int FILETYPE_SCHEMAPOINTER = 5;
public static final int FILETYPE_SCHEMAMODELGROUP = 6;
public static final int FILETYPE_SCHEMAATTRIBUTEGROUP = 7;
static String filetypeString(int code) {
switch (code) {
case FILETYPE_SCHEMAINDEX:
return "FILETYPE_SCHEMAINDEX";
case FILETYPE_SCHEMATYPE:
return "FILETYPE_SCHEMATYPE";
case FILETYPE_SCHEMAELEMENT:
return "FILETYPE_SCHEMAELEMENT";
case FILETYPE_SCHEMAATTRIBUTE:
return "FILETYPE_SCHEMAATTRIBUTE";
case FILETYPE_SCHEMAPOINTER:
return "FILETYPE_SCHEMAPOINTER";
case FILETYPE_SCHEMAMODELGROUP:
return "FILETYPE_SCHEMAMODELGROUP";
case FILETYPE_SCHEMAATTRIBUTEGROUP:
return "FILETYPE_SCHEMAATTRIBUTEGROUP";
default:
return "Unknown FILETYPE (" + code + ")";
}
}
public static final int FLAG_PART_SKIPPABLE = 1;
public static final int FLAG_PART_FIXED = 4;
public static final int FLAG_PART_NILLABLE = 8;
public static final int FLAG_PART_BLOCKEXT = 16;
public static final int FLAG_PART_BLOCKREST = 32;
public static final int FLAG_PART_BLOCKSUBST = 64;
public static final int FLAG_PART_ABSTRACT = 128;
public static final int FLAG_PART_FINALEXT = 256;
public static final int FLAG_PART_FINALREST = 512;
static String particleflagsString(int flags) {
StringBuilder result = new StringBuilder();
if ((flags & FLAG_PART_SKIPPABLE) != 0) {
result.append("FLAG_PART_SKIPPABLE | ");
}
if ((flags & FLAG_PART_FIXED) != 0) {
result.append("FLAG_PART_FIXED | ");
}
if ((flags & FLAG_PART_NILLABLE) != 0) {
result.append("FLAG_PART_NILLABLE | ");
}
if ((flags & FLAG_PART_BLOCKEXT) != 0) {
result.append("FLAG_PART_BLOCKEXT | ");
}
if ((flags & FLAG_PART_BLOCKREST) != 0) {
result.append("FLAG_PART_BLOCKREST | ");
}
if ((flags & FLAG_PART_BLOCKSUBST) != 0) {
result.append("FLAG_PART_BLOCKSUBST | ");
}
if ((flags & FLAG_PART_ABSTRACT) != 0) {
result.append("FLAG_PART_ABSTRACT | ");
}
if ((flags & FLAG_PART_FINALEXT) != 0) {
result.append("FLAG_PART_FINALEXT | ");
}
if ((flags & FLAG_PART_FINALREST) != 0) {
result.append("FLAG_PART_FINALREST | ");
}
if (result.length() == 0) {
result.append("0 | ");
}
return result.substring(0, result.length() - 3);
}
public static final int FLAG_PROP_ISATTR = 1;
public static final int FLAG_PROP_JAVASINGLETON = 2;
public static final int FLAG_PROP_JAVAOPTIONAL = 4;
public static final int FLAG_PROP_JAVAARRAY = 8;
static String propertyflagsString(int flags) {
StringBuilder result = new StringBuilder();
if ((flags & FLAG_PROP_ISATTR) != 0) {
result.append("FLAG_PROP_ISATTR | ");
}
if ((flags & FLAG_PROP_JAVASINGLETON) != 0) {
result.append("FLAG_PROP_JAVASINGLETON | ");
}
if ((flags & FLAG_PROP_JAVAOPTIONAL) != 0) {
result.append("FLAG_PROP_JAVAOPTIONAL | ");
}
if ((flags & FLAG_PROP_JAVAARRAY) != 0) {
result.append("FLAG_PROP_JAVAARRAY | ");
}
if (result.length() == 0) {
result.append("0 | ");
}
return result.substring(0, result.length() - 3);
}
public static final int FIELD_NONE = 0;
public static final int FIELD_GLOBAL = 1;
public static final int FIELD_LOCALATTR = 2;
public static final int FIELD_LOCALELT = 3;
static String containerfieldTypeString(int code) {
switch (code) {
case FIELD_NONE:
return "FIELD_NONE";
case FIELD_GLOBAL:
return "FIELD_GLOBAL";
case FIELD_LOCALATTR:
return "FIELD_LOCALATTR";
case FIELD_LOCALELT:
return "FIELD_LOCALELT";
default:
return "Unknown container field type (" + code + ")";
}
}
// type flags
static final int FLAG_SIMPLE_TYPE = 0x1;
static final int FLAG_DOCUMENT_TYPE = 0x2;
static final int FLAG_ORDERED = 0x4;
static final int FLAG_BOUNDED = 0x8;
static final int FLAG_FINITE = 0x10;
static final int FLAG_NUMERIC = 0x20;
static final int FLAG_STRINGENUM = 0x40;
static final int FLAG_UNION_OF_LISTS = 0x80;
static final int FLAG_HAS_PATTERN = 0x100;
static final int FLAG_ORDER_SENSITIVE = 0x200;
static final int FLAG_TOTAL_ORDER = 0x400;
static final int FLAG_COMPILED = 0x800;
static final int FLAG_BLOCK_EXT = 0x1000;
static final int FLAG_BLOCK_REST = 0x2000;
static final int FLAG_FINAL_EXT = 0x4000;
static final int FLAG_FINAL_REST = 0x8000;
static final int FLAG_FINAL_UNION = 0x10000;
static final int FLAG_FINAL_LIST = 0x20000;
static final int FLAG_ABSTRACT = 0x40000;
static final int FLAG_ATTRIBUTE_TYPE = 0x80000;
static String typeflagsString(int flags) {
StringBuilder result = new StringBuilder();
if ((flags & FLAG_SIMPLE_TYPE) != 0) {
result.append("FLAG_SIMPLE_TYPE | ");
}
if ((flags & FLAG_DOCUMENT_TYPE) != 0) {
result.append("FLAG_DOCUMENT_TYPE | ");
}
if ((flags & FLAG_ATTRIBUTE_TYPE) != 0) {
result.append("FLAG_ATTRIBUTE_TYPE | ");
}
if ((flags & FLAG_ORDERED) != 0) {
result.append("FLAG_ORDERED | ");
}
if ((flags & FLAG_BOUNDED) != 0) {
result.append("FLAG_BOUNDED | ");
}
if ((flags & FLAG_FINITE) != 0) {
result.append("FLAG_FINITE | ");
}
if ((flags & FLAG_NUMERIC) != 0) {
result.append("FLAG_NUMERIC | ");
}
if ((flags & FLAG_STRINGENUM) != 0) {
result.append("FLAG_STRINGENUM | ");
}
if ((flags & FLAG_UNION_OF_LISTS) != 0) {
result.append("FLAG_UNION_OF_LISTS | ");
}
if ((flags & FLAG_HAS_PATTERN) != 0) {
result.append("FLAG_HAS_PATTERN | ");
}
if ((flags & FLAG_TOTAL_ORDER) != 0) {
result.append("FLAG_TOTAL_ORDER | ");
}
if ((flags & FLAG_COMPILED) != 0) {
result.append("FLAG_COMPILED | ");
}
if ((flags & FLAG_BLOCK_EXT) != 0) {
result.append("FLAG_BLOCK_EXT | ");
}
if ((flags & FLAG_BLOCK_REST) != 0) {
result.append("FLAG_BLOCK_REST | ");
}
if ((flags & FLAG_FINAL_EXT) != 0) {
result.append("FLAG_FINAL_EXT | ");
}
if ((flags & FLAG_FINAL_REST) != 0) {
result.append("FLAG_FINAL_REST | ");
}
if ((flags & FLAG_FINAL_UNION) != 0) {
result.append("FLAG_FINAL_UNION | ");
}
if ((flags & FLAG_FINAL_LIST) != 0) {
result.append("FLAG_FINAL_LIST | ");
}
if ((flags & FLAG_ABSTRACT) != 0) {
result.append("FLAG_ABSTRACT | ");
}
if (result.length() == 0) {
result.append("0 | ");
}
return result.substring(0, result.length() - 3);
}
void dumpAll() {
int filetype = dumpHeader();
switch (filetype) {
case FILETYPE_SCHEMAINDEX:
dumpIndexData();
return;
case FILETYPE_SCHEMATYPE:
dumpTypeFileData();
break;
case FILETYPE_SCHEMAELEMENT:
dumpParticleData(true);
break;
case FILETYPE_SCHEMAATTRIBUTE:
dumpAttributeData(true);
break;
case FILETYPE_SCHEMAPOINTER:
dumpPointerData();
break;
case FILETYPE_SCHEMAMODELGROUP:
dumpModelGroupData();
break;
case FILETYPE_SCHEMAATTRIBUTEGROUP:
dumpAttributeGroupData();
break;
}
readEnd();
}
static String hex32String(int i) {
return Integer.toHexString(i);
}
protected int dumpHeader() {
int magic = readInt();
emit("Magic cookie: " + hex32String(magic));
if (magic != DATA_BABE) {
emit("Wrong magic cookie.");
return 0;
}
_majorver = readShort();
_minorver = readShort();
if (atLeast(2, 18, 0)) {
_releaseno = readShort();
}
emit("Major version: " + _majorver);
emit("Minor version: " + _minorver);
emit("Release number: " + _releaseno);
if (_majorver != MAJOR_VERSION || _minorver > MINOR_VERSION) {
emit("Incompatible version.");
return 0;
}
int actualfiletype = readShort();
emit("Filetype: " + filetypeString(actualfiletype));
_stringPool = new StringPool();
_stringPool.readFrom(_input);
return actualfiletype;
}
void dumpPointerData() {
emit("Type system: " + readString());
}
protected void dumpIndexData() {
// has a handle pool (count, handle/type, handle/type...)
int size = readShort();
emit("Handle pool (" + size + "):");
indent();
for (int i = 0; i < size; i++) {
String handle = readString();
int code = readShort();
emit(handle + " (" + filetypeString(code) + ")");
}
outdent();
dumpQNameMap("Global elements");
// qname map of global attributes
dumpQNameMap("Global attributes");
// attr groups and model groups
dumpQNameMap("Model groups");
dumpQNameMap("Attribute groups");
dumpQNameMap("Identity constraints");
// qname map of global types
dumpQNameMap("Global types");
// qname map of document types, by the qname of the contained element
dumpQNameMap("Document types");
// qname map of attribute types, by the qname of the contained attribute
dumpQNameMap("Attribute types");
// all the types indexed by classname
dumpClassnameIndex("All types by classname");
// all the namespaces
dumpStringArray("Defined namespaces");
// version 15 stuff for redefines
if (atLeast(2, 15, 0)) {
dumpQNameMap("Redefined global types");
dumpQNameMap("Redfined model groups");
dumpQNameMap("Redfined attribute groups");
}
// version 19 annotations
if (atLeast(2, 19, 0)) {
dumpAnnotations();
}
readEnd();
}
class StringPool {
private final List intsToStrings = new ArrayList<>();
private final Map stringsToInts = new HashMap<>();
StringPool() {
intsToStrings.add(null);
}
String stringForCode(int code) {
if (code == 0) {
return null;
}
return intsToStrings.get(code);
}
int codeForString(String str) {
if (str == null) {
return 0;
}
Integer result = stringsToInts.get(str);
if (result == null) {
result = intsToStrings.size();
intsToStrings.add(str);
stringsToInts.put(str, result);
}
return result;
}
void readFrom(LongUTFDataInputStream input) {
if (intsToStrings.size() != 1 || stringsToInts.size() != 0) {
throw new IllegalStateException();
}
try {
int size = input.readShort();
emit("String pool (" + size + "):");
indent();
for (int i = 1; i < size; i++) {
String str = input.readLongUTF();
int code = codeForString(str);
if (code != i) {
throw new IllegalStateException();
}
emit(code + " = \"" + str + "\"");
}
outdent();
} catch (IOException e) {
emit(e.toString());
}
}
}
// active while loading one type.
LongUTFDataInputStream _input;
StringPool _stringPool;
int readShort() {
try {
return _input.readUnsignedShort();
} catch (IOException e) {
error(e);
return 0;
}
}
int readInt() {
try {
return _input.readInt();
} catch (IOException e) {
error(e);
return 0;
}
}
String readString() {
return _stringPool.stringForCode(readShort());
}
QName readQName() {
String namespace = readString();
String localname = readString();
if (localname == null) {
return null;
}
return new QName(namespace, localname);
}
String readHandle() {
return readString();
}
String readType() {
return readHandle();
}
static String qnameString(QName qname) {
if (qname == null) {
return "(null)";
}
if (qname.getNamespaceURI() != null) {
return qname.getLocalPart() + "@" + qname.getNamespaceURI();
} else {
return qname.getLocalPart();
}
}
static String qnameSetString(QNameSet set) {
return set.toString();
}
void dumpQNameMap(String fieldname) {
int size = readShort();
emit(fieldname + " (" + size + "):");
indent();
for (int i = 0; i < size; i++) {
emit(qnameString(readQName()) + " = " + readHandle());
}
outdent();
}
void dumpTypeArray(String fieldname) {
int size = readShort();
emit(fieldname + " (" + size + "):");
indent();
for (int i = 0; i < size; i++) {
emit(i + " = " + readType());
}
outdent();
}
void dumpClassnameIndex(String fieldname) {
int size = readShort();
emit(fieldname + " (" + size + "):");
indent();
for (int i = 0; i < size; i++) {
emit(readString() + " = " + readType());
}
outdent();
}
void dumpStringArray(String fieldname) {
int size = readShort();
emit(fieldname + " (" + size + "):");
indent();
for (int i = 0; i < size; i++) {
emit(readString());
}
outdent();
}
void readEnd() {
try {
_input.close();
} catch (IOException e) {
// oh, well.
}
_input = null;
_stringPool = null;
}
static String particleTypeString(int spt) {
switch (spt) {
case SchemaParticle.ALL:
return "ALL";
case SchemaParticle.CHOICE:
return "CHOICE";
case SchemaParticle.ELEMENT:
return "ELEMENT";
case SchemaParticle.SEQUENCE:
return "SEQUENCE";
case SchemaParticle.WILDCARD:
return "WILDCARD";
default:
return "Unknown particle type (" + spt + ")";
}
}
static String bigIntegerString(BigInteger bigint) {
if (bigint == null) {
return "(null)";
}
return bigint.toString();
}
static String wcprocessString(int code) {
switch (code) {
case SchemaParticle.STRICT:
return "STRICT";
case SchemaParticle.SKIP:
return "SKIP";
case SchemaParticle.LAX:
return "LAX";
case 0:
return "NOT_WILDCARD";
default:
return "Unknown process type (" + code + ")";
}
}
void dumpAnnotation() {
if (!atLeast(2, 19, 0)) {
return; // no annotations in this version of the file
}
int n = readInt();
if (n == -1) {
return; // no annotation present
}
emit("Annotation");
boolean empty = true;
indent();
if (n > 0) {
emit("Attributes (" + n + "):");
indent();
for (int i = 0; i < n; i++) {
if (atLeast(2, 24, 0)) {
emit("Name: " + qnameString(readQName()) +
", Value: " + readString() +
", ValueURI: " + readString());
} else {
emit("Name: " + qnameString(readQName()) +
", Value: " + readString());
}
}
outdent();
empty = false;
}
n = readInt();
if (n > 0) {
emit("Documentation elements (" + n + "):");
indent();
for (int i = 0; i < n; i++) {
emit(readString());
}
outdent();
empty = false;
}
n = readInt();
if (n > 0) {
emit("Appinfo elements (" + n + "):");
indent();
for (int i = 0; i < n; i++) {
emit(readString());
}
outdent();
empty = false;
}
if (empty) {
emit("");
}
outdent();
}
void dumpAnnotations() {
int n = readInt();
if (n > 0) {
emit("Top-level annotations (" + n + "):");
indent();
for (int i = 0; i < n; i++) {
dumpAnnotation();
}
outdent();
}
}
void dumpParticleData(boolean global) {
int particleType = readShort();
emit(particleTypeString(particleType) + ":");
indent();
int particleFlags = readShort();
emit("Flags: " + particleflagsString(particleFlags));
emit("MinOccurs: " + bigIntegerString(readBigInteger()));
emit("MaxOccurs: " + bigIntegerString(readBigInteger()));
emit("Transition: " + qnameSetString(readQNameSet()));
switch (particleType) {
case SchemaParticle.WILDCARD:
emit("Wildcard set: " + qnameSetString(readQNameSet()));
emit("Wildcard process: " + wcprocessString(readShort()));
break;
case SchemaParticle.ELEMENT:
emit("Name: " + qnameString(readQName()));
emit("Type: " + readType());
emit("Default: " + readString());
if (atLeast(2, 16, 0)) {
emit("Default value: " + readXmlValueObject());
}
emit("WsdlArrayType: " + SOAPArrayTypeString(readSOAPArrayType()));
dumpAnnotation();
if (global) {
if (atLeast(2, 17, 0)) {
emit("Substitution group ref: " + readHandle());
}
int substGroupCount = readShort();
emit("Substitution group members (" + substGroupCount + ")");
indent();
for (int i = 0; i < substGroupCount; i++) {
emit(qnameString(readQName()));
}
outdent();
}
int count = readShort();
emit("Identity constraints (" + count + "):");
indent();
for (int i = 0; i < count; i++) {
emit(readHandle());
}
outdent();
if (global) {
emit("Filename: " + readString());
}
break;
case SchemaParticle.ALL:
case SchemaParticle.SEQUENCE:
case SchemaParticle.CHOICE:
dumpParticleArray("Particle children");
break;
default:
error("Unrecognized schema particle type");
}
outdent();
}
void dumpParticleArray(String fieldname) {
int count = readShort();
emit(fieldname + "(" + count + "):");
indent();
for (int i = 0; i < count; i++) {
dumpParticleData(false);
}
outdent();
}
static String complexVarietyString(int code) {
switch (code) {
case SchemaType.EMPTY_CONTENT:
return "EMPTY_CONTENT";
case SchemaType.SIMPLE_CONTENT:
return "SIMPLE_CONTENT";
case SchemaType.ELEMENT_CONTENT:
return "ELEMENT_CONTENT";
case SchemaType.MIXED_CONTENT:
return "MIXED_CONTENT";
default:
return "Unknown complex variety (" + code + ")";
}
}
static String simpleVarietyString(int code) {
switch (code) {
case SchemaType.ATOMIC:
return "ATOMIC";
case SchemaType.LIST:
return "LIST";
case SchemaType.UNION:
return "UNION";
default:
return "Unknown simple variety (" + code + ")";
}
}
String facetCodeString(int code) {
switch (code) {
case SchemaType.FACET_LENGTH:
return "FACET_LENGTH";
case SchemaType.FACET_MIN_LENGTH:
return "FACET_MIN_LENGTH";
case SchemaType.FACET_MAX_LENGTH:
return "FACET_MAX_LENGTH";
case SchemaType.FACET_MIN_EXCLUSIVE:
return "FACET_MIN_EXCLUSIVE";
case SchemaType.FACET_MIN_INCLUSIVE:
return "FACET_MIN_INCLUSIVE";
case SchemaType.FACET_MAX_INCLUSIVE:
return "FACET_MAX_INCLUSIVE";
case SchemaType.FACET_MAX_EXCLUSIVE:
return "FACET_MAX_EXCLUSIVE";
case SchemaType.FACET_TOTAL_DIGITS:
return "FACET_TOTAL_DIGITS";
case SchemaType.FACET_FRACTION_DIGITS:
return "FACET_FRACTION_DIGITS";
default:
return "Unknown facet code (" + code + ")";
}
}
String whitespaceCodeString(int code) {
switch (code) {
case SchemaType.WS_COLLAPSE:
return "WS_COLLAPSE";
case SchemaType.WS_PRESERVE:
return "WS_PRESERVE";
case SchemaType.WS_REPLACE:
return "WS_REPLACE";
case SchemaType.WS_UNSPECIFIED:
return "WS_UNSPECIFIED";
default:
return "Unknown whitespace code (" + code + ")";
}
}
String derivationTypeString(int code) {
switch (code) {
case SchemaType.DT_NOT_DERIVED:
return "DT_NOT_DERIVED";
case SchemaType.DT_RESTRICTION:
return "DT_RESTRICTION";
case SchemaType.DT_EXTENSION:
return "DT_EXTENSION";
default:
return "Unknown derivation code (" + code + ")";
}
}
void dumpTypeFileData() {
emit("Name: " + qnameString(readQName()));
emit("Outer type: " + readType());
emit("Depth: " + readShort());
emit("Base type: " + readType());
emit("Derivation type: " + derivationTypeString(readShort()));
dumpAnnotation();
emit("Container field:");
indent();
int containerfieldtype = readShort();
emit("Reftype: " + containerfieldTypeString(containerfieldtype));
switch (containerfieldtype) {
case FIELD_GLOBAL:
emit("Handle: " + readHandle());
break;
case FIELD_LOCALATTR:
emit("Index: " + readShort());
break;
case FIELD_LOCALELT:
emit("Index: " + readShort());
break;
}
outdent();
emit("Java class name: " + readString());
emit("Java impl class name: " + readString());
dumpTypeArray("Anonymous types");
emit("Anonymous union member ordinal: " + readShort());
int flags;
flags = readInt();
emit("Flags: " + typeflagsString(flags));
boolean isComplexType = ((flags & FLAG_SIMPLE_TYPE) == 0);
int complexVariety = SchemaType.NOT_COMPLEX_TYPE;
if (isComplexType) {
complexVariety = readShort();
emit("Complex variety: " + complexVarietyString(complexVariety));
if (atLeast(2, 23, 0)) {
emit("Content based on type: " + readType());
}
int attrCount = readShort();
emit("Attribute model (" + attrCount + "):");
indent();
for (int i = 0; i < attrCount; i++) {
dumpAttributeData(false);
}
emit("Wildcard set: " + qnameSetString(readQNameSet()));
emit("Wildcard process: " + wcprocessString(readShort()));
outdent();
// Attribute Property Table
int attrPropCount = readShort();
emit("Attribute properties (" + attrPropCount + "):");
indent();
for (int i = 0; i < attrPropCount; i++) {
dumpPropertyData();
}
outdent();
if (complexVariety == SchemaType.ELEMENT_CONTENT || complexVariety == SchemaType.MIXED_CONTENT) {
emit("IsAll: " + readShort());
// Content model tree
dumpParticleArray("Content model");
// Element Property Table
int elemPropCount = readShort();
emit("Element properties (" + elemPropCount + "):");
indent();
for (int i = 0; i < elemPropCount; i++) {
dumpPropertyData();
}
outdent();
}
}
if (!isComplexType || complexVariety == SchemaType.SIMPLE_CONTENT) {
int simpleVariety = readShort();
emit("Simple type variety: " + simpleVarietyString(simpleVariety));
boolean isStringEnum = ((flags & FLAG_STRINGENUM) != 0);
int facetCount = readShort();
emit("Facets (" + facetCount + "):");
indent();
for (int i = 0; i < facetCount; i++) {
emit(facetCodeString(readShort()));
emit("Value: " + readXmlValueObject());
emit("Fixed: " + readShort());
}
outdent();
emit("Whitespace rule: " + whitespaceCodeString(readShort()));
int patternCount = readShort();
emit("Patterns (" + patternCount + "):");
indent();
for (int i = 0; i < patternCount; i++) {
emit(readString());
}
outdent();
int enumCount = readShort();
emit("Enumeration values (" + enumCount + "):");
indent();
for (int i = 0; i < enumCount; i++) {
emit(readXmlValueObject());
}
outdent();
emit("Base enum type: " + readType());
if (isStringEnum) {
int seCount = readShort();
emit("String enum entries (" + seCount + "):");
indent();
for (int i = 0; i < seCount; i++) {
emit("\"" + readString() + "\" -> " + readShort() + " = " + readString());
}
outdent();
}
switch (simpleVariety) {
case SchemaType.ATOMIC:
emit("Primitive type: " + readType());
emit("Decimal size: " + readInt());
break;
case SchemaType.LIST:
emit("List item type: " + readType());
break;
case SchemaType.UNION:
dumpTypeArray("Union members");
break;
default:
error("Unknown simple type variety");
}
}
emit("Filename: " + readString());
}
static String attruseCodeString(int code) {
switch (code) {
case SchemaLocalAttribute.OPTIONAL:
return "OPTIONAL";
case SchemaLocalAttribute.REQUIRED:
return "REQUIRED";
case SchemaLocalAttribute.PROHIBITED:
return "PROHIBITED";
default:
return "Unknown use code (" + code + ")";
}
}
void dumpAttributeData(boolean global) {
emit("Name: " + qnameString(readQName()));
emit("Type: " + readType());
emit("Use: " + attruseCodeString(readShort()));
emit("Default: " + readString());
if (atLeast(2, 16, 0)) {
emit("Default value: " + readXmlValueObject());
}
emit("Fixed: " + readShort());
emit("WsdlArrayType: " + SOAPArrayTypeString(readSOAPArrayType()));
dumpAnnotation();
if (global) {
emit("Filename: " + readString());
}
}
private static final XmlOptions prettyOptions =
new XmlOptions().setSavePrettyPrint();
void dumpXml() {
String xml = readString();
try {
emit(XmlObject.Factory.parse(xml).xmlText(prettyOptions));
} catch (XmlException x) {
emit("!!!!!! BAD XML !!!!!");
emit(xml);
}
}
void dumpModelGroupData() {
emit("Name: " + qnameString(readQName()));
emit("Target namespace: " + readString());
emit("Chameleon: " + readShort());
if (atLeast(2, 22, 0)) {
emit("Element form default: " + readString());
}
if (atLeast(2, 22, 0)) {
emit("Attribute form default: " + readString());
}
if (atLeast(2, 15, 0)) {
emit("Redefine: " + readShort());
}
emit("Model Group Xml: ");
dumpXml();
dumpAnnotation();
if (atLeast(2, 21, 0)) {
emit("Filename: " + readString());
}
}
void dumpAttributeGroupData() {
emit("Name: " + qnameString(readQName()));
emit("Target namespace: " + readString());
emit("Chameleon: " + readShort());
if (atLeast(2, 22, 0)) {
emit("Form default: " + readString());
}
if (atLeast(2, 15, 0)) {
emit("Redefine: " + readShort());
}
emit("Attribute Group Xml: ");
dumpXml();
dumpAnnotation();
if (atLeast(2, 21, 0)) {
emit("Filename: " + readString());
}
}
static String alwaysString(int code) {
switch (code) {
case SchemaProperty.CONSISTENTLY:
return "CONSISTENTLY";
case SchemaProperty.NEVER:
return "NEVER";
case SchemaProperty.VARIABLE:
return "VARIABLE";
default:
return "Unknown frequency code (" + code + ")";
}
}
static String jtcString(int code) {
switch (code) {
case SchemaProperty.XML_OBJECT:
return "XML_OBJECT";
case SchemaProperty.JAVA_BOOLEAN:
return "JAVA_BOOLEAN";
case SchemaProperty.JAVA_FLOAT:
return "JAVA_FLOAT";
case SchemaProperty.JAVA_DOUBLE:
return "JAVA_DOUBLE";
case SchemaProperty.JAVA_BYTE:
return "JAVA_BYTE";
case SchemaProperty.JAVA_SHORT:
return "JAVA_SHORT";
case SchemaProperty.JAVA_INT:
return "JAVA_INT";
case SchemaProperty.JAVA_LONG:
return "JAVA_LONG";
case SchemaProperty.JAVA_BIG_DECIMAL:
return "JAVA_BIG_DECIMAL";
case SchemaProperty.JAVA_BIG_INTEGER:
return "JAVA_BIG_INTEGER";
case SchemaProperty.JAVA_STRING:
return "JAVA_STRING";
case SchemaProperty.JAVA_BYTE_ARRAY:
return "JAVA_BYTE_ARRAY";
case SchemaProperty.JAVA_GDATE:
return "JAVA_GDATE";
case SchemaProperty.JAVA_GDURATION:
return "JAVA_GDURATION";
case SchemaProperty.JAVA_DATE:
return "JAVA_DATE";
case SchemaProperty.JAVA_QNAME:
return "JAVA_QNAME";
case SchemaProperty.JAVA_CALENDAR:
return "JAVA_CALENDAR";
case SchemaProperty.JAVA_LIST:
return "JAVA_LIST";
case SchemaProperty.JAVA_ENUM:
return "JAVA_ENUM";
case SchemaProperty.JAVA_OBJECT:
return "JAVA_OBJECT";
default:
return "Unknown java type code (" + code + ")";
}
}
void dumpPropertyData() {
emit("Property");
indent();
emit("Name: " + qnameString(readQName()));
emit("Type: " + readType());
int propflags = readShort();
emit("Flags: " + propertyflagsString(propflags));
emit("Container type: " + readType());
emit("Min occurances: " + bigIntegerString(readBigInteger()));
emit("Max occurances: " + bigIntegerString(readBigInteger()));
emit("Nillable: " + alwaysString(readShort()));
emit("Default: " + alwaysString(readShort()));
emit("Fixed: " + alwaysString(readShort()));
emit("Default text: " + readString());
emit("Java prop name: " + readString());
emit("Java type code: " + jtcString(readShort()));
emit("Type for java signature: " + readType());
if (atMost(2, 19, 0)) {
emit("Java setter delimiter: " + qnameSetString(readQNameSet()));
}
if (atLeast(2, 16, 0)) {
emit("Default value: " + readXmlValueObject());
}
if (((propflags & FLAG_PROP_ISATTR) == 0) && atLeast(2, 17, 0)) {
int size = readShort();
emit("Accepted substitutions (" + size + "):");
for (int i = 0; i < size; i++) {
emit(" Accepted name " + readQName());
}
}
outdent();
}
String readXmlValueObject() {
String type = readType();
if (type == null) {
return "null";
}
int btc = readShort();
String value;
switch (btc) {
default:
assert (false);
case 0:
value = "nil";
break;
case SchemaType.BTC_ANY_SIMPLE:
case SchemaType.BTC_ANY_URI:
case SchemaType.BTC_STRING:
case SchemaType.BTC_DURATION:
case SchemaType.BTC_DATE_TIME:
case SchemaType.BTC_TIME:
case SchemaType.BTC_DATE:
case SchemaType.BTC_G_YEAR_MONTH:
case SchemaType.BTC_G_YEAR:
case SchemaType.BTC_G_MONTH_DAY:
case SchemaType.BTC_G_DAY:
case SchemaType.BTC_G_MONTH:
case SchemaType.BTC_DECIMAL:
case SchemaType.BTC_BOOLEAN:
value = readString();
break;
case SchemaType.BTC_BASE_64_BINARY:
case SchemaType.BTC_HEX_BINARY: {
value = new String(HexBin.encode(readByteArray()), StandardCharsets.ISO_8859_1);
if (value.length() > 19) {
value = value.subSequence(0, 16) + "...";
}
break;
}
case SchemaType.BTC_QNAME:
case SchemaType.BTC_NOTATION:
value = QNameHelper.pretty(readQName());
break;
case SchemaType.BTC_FLOAT:
case SchemaType.BTC_DOUBLE:
value = Double.toString(readDouble());
break;
}
return value + " (" + type + ": " + btc + ")";
}
double readDouble() {
try {
return _input.readDouble();
} catch (IOException e) {
error(e);
return 0.0;
}
}
String SOAPArrayTypeString(SOAPArrayType t) {
if (t == null) {
return "null";
}
return QNameHelper.pretty(t.getQName()) + t.soap11DimensionString();
}
SOAPArrayType readSOAPArrayType() {
QName qName = readQName();
String dimensions = readString();
if (qName == null) {
return null;
}
return new SOAPArrayType(qName, dimensions);
}
QNameSet readQNameSet() {
int flag = readShort();
Set uriSet = new HashSet<>();
int uriCount = readShort();
for (int i = 0; i < uriCount; i++) {
uriSet.add(readString());
}
Set qnameSet1 = new HashSet<>();
int qncount1 = readShort();
for (int i = 0; i < qncount1; i++) {
qnameSet1.add(readQName());
}
Set qnameSet2 = new HashSet<>();
int qncount2 = readShort();
for (int i = 0; i < qncount2; i++) {
qnameSet2.add(readQName());
}
if (flag == 1) {
return QNameSet.forSets(uriSet, null, qnameSet1, qnameSet2);
} else {
return QNameSet.forSets(null, uriSet, qnameSet2, qnameSet1);
}
}
byte[] readByteArray() {
try {
int len = _input.readShort();
byte[] result = new byte[len];
_input.readFully(result);
return result;
} catch (IOException e) {
error(e);
return null;
}
}
BigInteger readBigInteger() {
byte[] result = readByteArray();
if (result.length == 0) {
return null;
}
if (result.length == 1 && result[0] == 0) {
return BigInteger.ZERO;
}
if (result.length == 1 && result[0] == 1) {
return BigInteger.ONE;
}
return new BigInteger(result);
}
private int _majorver;
private int _minorver;
private int _releaseno;
protected boolean atLeast(int majorver, int minorver, int releaseno) {
if (_majorver > majorver) {
return true;
}
if (_majorver < majorver) {
return false;
}
if (_minorver > minorver) {
return true;
}
if (_minorver < minorver) {
return false;
}
return (_releaseno >= releaseno);
}
protected boolean atMost(int majorver, int minorver, int releaseno) {
if (_majorver > majorver) {
return false;
}
if (_majorver < majorver) {
return true;
}
if (_minorver > minorver) {
return false;
}
if (_minorver < minorver) {
return true;
}
return (_releaseno <= releaseno);
}
}
© 2015 - 2024 Weber Informatics LLC | Privacy Policy