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 com.liferay.dynamic.data.lists.service
Show all versions of com.liferay.dynamic.data.lists.service
Liferay Dynamic Data Lists Service
/* 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 java.util.*;
import java.util.zip.ZipFile;
import java.util.zip.ZipEntry;
import java.io.*;
import java.math.BigInteger;
import org.apache.xmlbeans.impl.common.QNameHelper;
import org.apache.xmlbeans.impl.util.HexBin;
import org.apache.xmlbeans.QNameSet;
import org.apache.xmlbeans.SchemaLocalAttribute;
import org.apache.xmlbeans.SchemaParticle;
import org.apache.xmlbeans.SchemaProperty;
import org.apache.xmlbeans.SchemaType;
import org.apache.xmlbeans.soap.SOAPArrayType;
import org.apache.xmlbeans.XmlException;
import org.apache.xmlbeans.XmlObject;
import org.apache.xmlbeans.XmlOptions;
import javax.xml.namespace.QName;
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 (int i = 0; i < args.length; i++)
{
dump(new File(args[i]), true);
}
}
private static void dump(File file, boolean force)
{
if (file.isDirectory())
{
File[] files = file.listFiles(
new FileFilter()
{
public boolean accept(File file)
{ return file.isDirectory() || file.isFile() && file.getName().endsWith(".xsb"); }
}
);
for (int i = 0; i < files.length; i++)
{
dump(files[i], 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 = (ZipEntry)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 DataInputStream(stream);
_indent = indent;
_out = ostream;
}
void flush() { _out.flush(); }
void emit(String str) { _out.println(_indent + str); flush(); }
void emit() { _out.println(); flush(); }
void error(Exception e) { _out.println(e.toString()); flush(); IllegalStateException e2 = new IllegalStateException( e.getMessage() ); e2.initCause( e ); throw e2; }
void error(String str) { _out.println(str); flush(); IllegalStateException e2 = new IllegalStateException( str ); throw e2; }
private String _indent;
private 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)
{
StringBuffer result = new StringBuffer();
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)
{
StringBuffer result = new StringBuffer();
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)
{
StringBuffer result = new StringBuffer();
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 List intsToStrings = new ArrayList();
private Map stringsToInts = new HashMap();
StringPool()
{
intsToStrings.add(null);
}
String stringForCode(int code)
{
if (code == 0)
return null;
return (String)intsToStrings.get(code);
}
int codeForString(String str)
{
if (str == null)
return 0;
Integer result = (Integer)stringsToInts.get(str);
if (result == null)
{
result = new Integer(intsToStrings.size());
intsToStrings.add(str);
stringsToInts.put(str, result);
}
return result.intValue();
}
void readFrom(DataInputStream 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.readUTF();
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.
DataInputStream _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()));
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);
}
static final byte[] SINGLE_ZERO_BYTE = new byte[] { (byte)0 };
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);
}
}