482 lines
16 KiB
Java
482 lines
16 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.xml.XElem
|
|
* javax.baja.xml.XException
|
|
* javax.baja.xml.XParser
|
|
*/
|
|
package javax.baja.io;
|
|
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.module.NModule;
|
|
import com.tridium.sys.schema.ComponentSlotMap;
|
|
import com.tridium.util.SimpleFactory;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.ByteArrayInputStream;
|
|
import java.io.EOFException;
|
|
import java.io.File;
|
|
import java.io.FileInputStream;
|
|
import java.io.InputStream;
|
|
import java.util.HashMap;
|
|
import java.util.Map;
|
|
import javax.baja.category.BCategoryMask;
|
|
import javax.baja.file.BIFile;
|
|
import javax.baja.io.ValueDocDecoder;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.naming.BOrd;
|
|
import javax.baja.sys.BBoolean;
|
|
import javax.baja.sys.BComplex;
|
|
import javax.baja.sys.BComponent;
|
|
import javax.baja.sys.BDouble;
|
|
import javax.baja.sys.BFacets;
|
|
import javax.baja.sys.BFloat;
|
|
import javax.baja.sys.BInteger;
|
|
import javax.baja.sys.BLong;
|
|
import javax.baja.sys.BObject;
|
|
import javax.baja.sys.BSimple;
|
|
import javax.baja.sys.BValue;
|
|
import javax.baja.sys.Context;
|
|
import javax.baja.sys.Flags;
|
|
import javax.baja.sys.ModuleException;
|
|
import javax.baja.sys.ModuleNotFoundException;
|
|
import javax.baja.sys.Property;
|
|
import javax.baja.sys.Slot;
|
|
import javax.baja.sys.TypeNotFoundException;
|
|
import javax.baja.xml.XElem;
|
|
import javax.baja.xml.XException;
|
|
import javax.baja.xml.XParser;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
public class BogDecoder
|
|
extends XParser {
|
|
static final Log defaultLog = Log.getLog("sys.xml");
|
|
public static final TypeResolver defaultTypeResolver = new TypeResolver();
|
|
HashMap modules;
|
|
Log log;
|
|
int warningCount;
|
|
TypeResolver typeResolver;
|
|
SimpleFactory simpleFactory;
|
|
private Context context;
|
|
|
|
public static BValue unmarshal(String string) throws Exception {
|
|
BogDecoder bogDecoder = new BogDecoder(new ByteArrayInputStream(string.getBytes()));
|
|
bogDecoder.next();
|
|
return bogDecoder.decode();
|
|
}
|
|
|
|
public static BValue unmarshal(String string, TypeResolver typeResolver) throws Exception {
|
|
BogDecoder bogDecoder = new BogDecoder(new ByteArrayInputStream(string.getBytes()));
|
|
bogDecoder.setTypeResolver(typeResolver);
|
|
bogDecoder.next();
|
|
return bogDecoder.decode();
|
|
}
|
|
|
|
public TypeResolver getTypeResolver() {
|
|
return this.typeResolver;
|
|
}
|
|
|
|
public void setTypeResolver(TypeResolver typeResolver) {
|
|
this.typeResolver = typeResolver == null ? defaultTypeResolver : typeResolver;
|
|
}
|
|
|
|
public BValue decodeDocument() throws Exception {
|
|
return this.decodeDocument(true);
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
*/
|
|
public BValue decodeDocument(boolean bl) throws Exception {
|
|
BValue bValue;
|
|
block5: {
|
|
try {
|
|
this.next();
|
|
XElem xElem = this.elem();
|
|
if (!xElem.name().equals("bajaObjectGraph")) {
|
|
throw this.err("Root element must be \"bajaObjectGraph\"");
|
|
}
|
|
String string = xElem.get("version");
|
|
if (!string.equals("1.0")) {
|
|
throw this.err("Only version 1.0 is supported");
|
|
}
|
|
this.next();
|
|
BValue bValue2 = this.decode();
|
|
this.next();
|
|
if (this.type() != 2 || this.elem() != xElem) {
|
|
throw this.err("Expected end tag for \"bajaObjectGraph\"");
|
|
}
|
|
bValue = bValue2;
|
|
Object var3_6 = null;
|
|
if (!bl) break block5;
|
|
}
|
|
catch (Throwable throwable) {
|
|
block6: {
|
|
Object var3_7 = null;
|
|
if (!bl) break block6;
|
|
this.close();
|
|
}
|
|
throw throwable;
|
|
}
|
|
this.close();
|
|
}
|
|
return bValue;
|
|
}
|
|
|
|
public BValue decode() throws Exception {
|
|
BValue bValue = this.parseSlot(null);
|
|
if (bValue == null) {
|
|
throw this.err("Error parsing value");
|
|
}
|
|
return bValue;
|
|
}
|
|
|
|
public Log getLog() {
|
|
return this.log;
|
|
}
|
|
|
|
public void setLog(Log log) {
|
|
if (log == null) {
|
|
throw new NullPointerException();
|
|
}
|
|
this.log = log;
|
|
}
|
|
|
|
public int getWarningCount() {
|
|
return this.warningCount;
|
|
}
|
|
|
|
protected void decodingComponent(BComponent bComponent) throws Exception {
|
|
this.warning("Unknown element <" + this.elem().name() + "> for decodingComponent");
|
|
}
|
|
|
|
void parseSlots(BObject bObject) throws Exception {
|
|
while (true) {
|
|
int n;
|
|
if ((n = this.next()) == -1) {
|
|
throw new EOFException();
|
|
}
|
|
if (n == 2) {
|
|
return;
|
|
}
|
|
if (n != 1) {
|
|
throw this.err("Expected element start");
|
|
}
|
|
this.parseSlot((BComplex)bObject);
|
|
}
|
|
}
|
|
|
|
BValue parseSlot(BComplex bComplex) throws Exception {
|
|
Object object;
|
|
Object object2;
|
|
if (this.type() != 1) {
|
|
throw this.err("Expected element start (" + this.type() + ')');
|
|
}
|
|
XElem xElem = this.elem();
|
|
String string = xElem.name().intern();
|
|
if (string != "p" && string != "a" && string != "t") {
|
|
if (bComplex instanceof BComponent) {
|
|
this.decodingComponent((BComponent)bComplex);
|
|
} else {
|
|
this.warning("Unknown element <" + string + '>');
|
|
}
|
|
return null;
|
|
}
|
|
String string2 = null;
|
|
String string3 = null;
|
|
Object object3 = null;
|
|
Object object4 = null;
|
|
String string4 = null;
|
|
Object object5 = null;
|
|
BFacets bFacets = BFacets.NULL;
|
|
Object object6 = null;
|
|
boolean bl = false;
|
|
int n = xElem.attrSize();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
object2 = xElem.attrName(n2);
|
|
object = xElem.attrValue(n2);
|
|
if (object2 == "n") {
|
|
string2 = object;
|
|
} else if (object2 == "h") {
|
|
string3 = object;
|
|
} else if (object2 == "v") {
|
|
string4 = object;
|
|
} else if (object2 == "t") {
|
|
object4 = object;
|
|
} else if (object2 == "m") {
|
|
object3 = object;
|
|
} else if (object2 == "f") {
|
|
object5 = object;
|
|
} else if (object2 == "x") {
|
|
bFacets = this.decodeFacets((String)object);
|
|
} else if (object2 == "c") {
|
|
object6 = object;
|
|
} else if (((String)object2).equals("stub")) {
|
|
bl = ((String)object).equals("true");
|
|
}
|
|
++n2;
|
|
}
|
|
n2 = this.decodeFlags((String)object5);
|
|
if (object3 != null && !this.getTypeResolver().loadModule(this, bComplex, string2, (String)object3, (String)object4)) {
|
|
int n3 = this.line();
|
|
int n4 = this.column();
|
|
try {
|
|
this.skip();
|
|
}
|
|
catch (XException xException) {
|
|
this.log.warning("Missing module: " + (String)object3 + " [" + n3 + ':' + n4 + ']');
|
|
throw xException;
|
|
}
|
|
catch (Exception exception) {
|
|
this.log.warning("Missing module: " + (String)object3 + " [" + n3 + ':' + n4 + ']');
|
|
throw new XException((Throwable)exception);
|
|
}
|
|
if (this.log.isTraceOn()) {
|
|
this.log.trace("Missing module: " + (String)object3 + " [" + n3 + ':' + n4 + ']');
|
|
}
|
|
return null;
|
|
}
|
|
object2 = null;
|
|
if (bComplex != null) {
|
|
if (string2 == null) {
|
|
throw this.err("Missing \"n\" name attribute");
|
|
}
|
|
object2 = bComplex.getSlot(string2);
|
|
}
|
|
if (object2 != null) {
|
|
if (object5 != null) {
|
|
bComplex.setFlags((Slot)object2, n2, Context.decoding);
|
|
}
|
|
if (!object2.isProperty()) {
|
|
this.skip();
|
|
return null;
|
|
}
|
|
} else {
|
|
if (string == "a") {
|
|
this.warning("Missing frozen action: " + string2);
|
|
return null;
|
|
}
|
|
if (string == "t") {
|
|
this.warning("Missing frozen topic: " + string2);
|
|
return null;
|
|
}
|
|
}
|
|
if (this.decodePrimitive(bComplex, (Property)(object = (Property)object2), string4)) {
|
|
return null;
|
|
}
|
|
BValue bValue = this.getTypeResolver().newInstance(this, bComplex, string2, (Property)object, (String)object4);
|
|
if (bValue == null) {
|
|
return null;
|
|
}
|
|
if (bValue.isSimple() && string4 != null) {
|
|
bValue = this.decodeSimple(bValue, string4);
|
|
}
|
|
if (bValue.isComponent()) {
|
|
((ComponentSlotMap)bValue.fw(1)).setHandle(string3);
|
|
if (!bl) {
|
|
((ComponentSlotMap)bValue.fw(1)).setBrokerPropsLoaded(true);
|
|
}
|
|
if (object6 != null) {
|
|
((BComponent)bValue).setCategoryMask(BCategoryMask.make((String)object6), Context.decoding);
|
|
}
|
|
}
|
|
if (bComplex != null) {
|
|
if (object != null) {
|
|
if (!object.isFrozen()) {
|
|
throw this.err("Duplicate slot " + bComplex.getType().getTypeName() + '.' + string2);
|
|
}
|
|
try {
|
|
bComplex.set((Property)object, bValue, Context.decoding);
|
|
}
|
|
catch (Exception exception) {
|
|
this.warning("Cannot set property " + bComplex.getType().getTypeName() + '.' + string2 + ": " + exception);
|
|
}
|
|
} else if (bComplex.isComponent()) {
|
|
bComplex.asComponent().add(string2, bValue, n2, bFacets, Context.decoding);
|
|
} else {
|
|
this.warning("Missing slot " + bComplex.getType().getTypeName() + '.' + string2);
|
|
}
|
|
}
|
|
this.parseSlots(bValue);
|
|
return bValue;
|
|
}
|
|
|
|
boolean decodePrimitive(BComplex bComplex, Property property, String string) throws Exception {
|
|
if (property == null || string == null) {
|
|
return false;
|
|
}
|
|
if (property.getTypeAccess() == 7) {
|
|
return false;
|
|
}
|
|
switch (property.getTypeAccess()) {
|
|
case 0: {
|
|
bComplex.setBoolean(property, BBoolean.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 2: {
|
|
bComplex.setInt(property, BInteger.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 3: {
|
|
bComplex.setLong(property, BLong.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 4: {
|
|
bComplex.setFloat(property, BFloat.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 5: {
|
|
bComplex.setDouble(property, BDouble.decode(string), Context.decoding);
|
|
break;
|
|
}
|
|
case 6: {
|
|
bComplex.setString(property, string, Context.decoding);
|
|
break;
|
|
}
|
|
default: {
|
|
throw new IllegalStateException("" + property.getTypeAccess());
|
|
}
|
|
}
|
|
int n = this.next();
|
|
if (n != 2) {
|
|
throw this.err("Expecting end of p element for simple property " + property.getName());
|
|
}
|
|
return true;
|
|
}
|
|
|
|
BSimple decodeSimple(BObject bObject, String string) {
|
|
try {
|
|
return this.simpleFactory.make(bObject.getType(), string, this.context);
|
|
}
|
|
catch (Exception exception) {
|
|
throw this.err("Invalid " + bObject.getType().getTypeName() + ": '" + string + '\'', exception);
|
|
}
|
|
}
|
|
|
|
int decodeFlags(String string) {
|
|
if (string == null) {
|
|
return 0;
|
|
}
|
|
return Flags.decodeFromString(string);
|
|
}
|
|
|
|
BFacets decodeFacets(String string) {
|
|
try {
|
|
if (string == null) {
|
|
return BFacets.NULL;
|
|
}
|
|
return (BFacets)this.simpleFactory.make(BFacets.TYPE, string, this.context);
|
|
}
|
|
catch (Exception exception) {
|
|
throw this.err("Invalid facets " + string, exception);
|
|
}
|
|
}
|
|
|
|
XException err(String string, Throwable throwable) {
|
|
return new XException(string, (XParser)this, throwable);
|
|
}
|
|
|
|
XException err(String string) {
|
|
return new XException(string, (XParser)this);
|
|
}
|
|
|
|
void warning(String string) throws XException {
|
|
this.log.warning(string + " [" + this.line() + ':' + this.column() + ']');
|
|
++this.warningCount;
|
|
try {
|
|
this.skip();
|
|
}
|
|
catch (XException xException) {
|
|
throw xException;
|
|
}
|
|
catch (Exception exception) {
|
|
throw new XException((Throwable)exception);
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.modules = new HashMap();
|
|
this.log = defaultLog;
|
|
this.typeResolver = defaultTypeResolver;
|
|
this.simpleFactory = new SimpleFactory();
|
|
this.context = null;
|
|
}
|
|
|
|
public BogDecoder(BOrd bOrd) throws Exception {
|
|
this((BIFile)((Object)bOrd.resolve().get()));
|
|
}
|
|
|
|
public BogDecoder(BIFile bIFile) throws Exception {
|
|
this(new BufferedInputStream(bIFile.getInputStream()));
|
|
}
|
|
|
|
public BogDecoder(File file) throws Exception {
|
|
this(new BufferedInputStream(new FileInputStream(file)));
|
|
}
|
|
|
|
public BogDecoder(InputStream inputStream) throws Exception {
|
|
super(inputStream);
|
|
this.this();
|
|
}
|
|
|
|
public static class TypeResolver {
|
|
public boolean loadModule(BogDecoder bogDecoder, BComplex bComplex, String string, String string2, String string3) {
|
|
try {
|
|
int n = string2.indexOf(61);
|
|
String string4 = string2.substring(0, n).trim();
|
|
String string5 = string2.substring(n + 1).trim();
|
|
NModule nModule = Nre.moduleManager.loadModule(string5);
|
|
this.getModuleMap(bogDecoder).put(string4, nModule);
|
|
}
|
|
catch (ModuleException moduleException) {
|
|
throw bogDecoder.err("Cannot load module '" + string2 + '\'', moduleException);
|
|
}
|
|
catch (Exception exception) {
|
|
throw bogDecoder.err("Invalid module attribute '" + string2 + '\'');
|
|
}
|
|
return true;
|
|
}
|
|
|
|
public BValue newInstance(BogDecoder bogDecoder, BComplex bComplex, String string, Property property, String string2) {
|
|
if (string2 == null) {
|
|
if (property != null) {
|
|
return property.getDefaultValue();
|
|
}
|
|
bogDecoder.warning("Missing frozen property: " + string);
|
|
return null;
|
|
}
|
|
try {
|
|
int n = string2.indexOf(58);
|
|
if (n <= 0) {
|
|
throw bogDecoder.err("Invalid typespec '" + string2 + '\'');
|
|
}
|
|
String string3 = string2.substring(0, n);
|
|
String string4 = string2.substring(n + 1);
|
|
NModule nModule = (NModule)this.getModuleMap(bogDecoder).get(string3);
|
|
if (nModule == null) {
|
|
throw bogDecoder.err("Undeclared module symbol: " + string3, new ModuleNotFoundException(string3));
|
|
}
|
|
return ValueDocDecoder.typeResolverNewInstance(nModule, string4);
|
|
}
|
|
catch (XException xException) {
|
|
throw xException;
|
|
}
|
|
catch (TypeNotFoundException typeNotFoundException) {
|
|
bogDecoder.warning("Type \"" + typeNotFoundException.getMessage() + "\" not found: " + string);
|
|
return null;
|
|
}
|
|
catch (Throwable throwable) {
|
|
throw bogDecoder.err("Cannot instantiate type '" + string2 + '\'', throwable);
|
|
}
|
|
}
|
|
|
|
protected Map getModuleMap(BogDecoder bogDecoder) {
|
|
return bogDecoder.modules;
|
|
}
|
|
}
|
|
}
|
|
|