1408 lines
59 KiB
Java
1408 lines
59 KiB
Java
/*
|
|
* Decompiled with CFR 0.152.
|
|
*
|
|
* Could not load the following classes:
|
|
* javax.baja.nre.util.Array
|
|
* javax.baja.nre.util.IntHashMap
|
|
* javax.baja.nre.util.SortUtil
|
|
* javax.baja.nre.util.TextUtil
|
|
* javax.baja.xml.XElem
|
|
* javax.baja.xml.XException
|
|
* javax.baja.xml.XParser
|
|
*/
|
|
package com.tridium.sys.registry;
|
|
|
|
import com.tridium.sys.Nre;
|
|
import com.tridium.sys.registry.ClassScanner;
|
|
import com.tridium.sys.registry.NAdapterInfo;
|
|
import com.tridium.sys.registry.NAgentInfo;
|
|
import com.tridium.sys.registry.NDependencyInfo;
|
|
import com.tridium.sys.registry.NLexiconInfo;
|
|
import com.tridium.sys.registry.NModuleInfo;
|
|
import com.tridium.sys.registry.NRegistry;
|
|
import com.tridium.sys.registry.NTypeInfo;
|
|
import com.tridium.sys.registry.RegistryChecksum;
|
|
import com.tridium.sys.registry.RegistryDatabase;
|
|
import com.tridium.util.ArrayUtil;
|
|
import com.tridium.util.jar.JarEntry;
|
|
import com.tridium.util.jar.JarFile;
|
|
import java.io.BufferedInputStream;
|
|
import java.io.File;
|
|
import java.io.InputStream;
|
|
import java.util.ArrayList;
|
|
import java.util.Comparator;
|
|
import java.util.HashMap;
|
|
import java.util.HashSet;
|
|
import java.util.Iterator;
|
|
import java.util.Map;
|
|
import javax.baja.file.FileUtil;
|
|
import javax.baja.log.Log;
|
|
import javax.baja.nre.util.Array;
|
|
import javax.baja.nre.util.IntHashMap;
|
|
import javax.baja.nre.util.SortUtil;
|
|
import javax.baja.nre.util.TextUtil;
|
|
import javax.baja.registry.DependencyInfo;
|
|
import javax.baja.registry.LexiconInfo;
|
|
import javax.baja.security.BPermissions;
|
|
import javax.baja.sys.BajaRuntimeException;
|
|
import javax.baja.sys.ModuleException;
|
|
import javax.baja.sys.ModuleNotFoundException;
|
|
import javax.baja.util.BTypeSpec;
|
|
import javax.baja.util.Version;
|
|
import javax.baja.xml.XElem;
|
|
import javax.baja.xml.XException;
|
|
import javax.baja.xml.XParser;
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
class Builder {
|
|
static final Log log = Log.getLog("sys.registry");
|
|
static HashSet skipFiles = new HashSet();
|
|
ModuleBuild[] moduleBuilds;
|
|
ArrayList typeBuilds;
|
|
ArrayList adapterBuilds;
|
|
HashMap typeBuildsBySpecString;
|
|
HashMap typesByFileExt;
|
|
HashMap typesByOrdScheme;
|
|
HashMap typesBySpecString;
|
|
HashMap typesByClass;
|
|
HashMap defs;
|
|
HashMap lexicons;
|
|
static /* synthetic */ Class class$com$tridium$sys$registry$NModuleInfo;
|
|
static /* synthetic */ Class class$com$tridium$sys$registry$NTypeInfo;
|
|
static /* synthetic */ Class class$java$lang$String;
|
|
static /* synthetic */ Class class$com$tridium$sys$registry$NAdapterInfo;
|
|
static /* synthetic */ Class class$javax$baja$sys$BComponent;
|
|
|
|
static int rebuild(NRegistry nRegistry) throws Exception {
|
|
Builder.clean(nRegistry);
|
|
ModuleBuild[] moduleBuildArray = Builder.load();
|
|
Builder builder = new Builder();
|
|
builder.init(moduleBuildArray, 0, 0);
|
|
builder.resolveSuperAndInterfaces();
|
|
builder.resolveIsTypes();
|
|
builder.resolveAdapters();
|
|
builder.agentize();
|
|
builder.write(nRegistry);
|
|
return builder.typeBuilds.size();
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
static void syncFiles(NRegistry nRegistry) {
|
|
NRegistry nRegistry2 = nRegistry;
|
|
synchronized (nRegistry2) {
|
|
Object[] objectArray;
|
|
Object[] objectArray2;
|
|
Object object;
|
|
File file = new File(Nre.bajaHome, "modules");
|
|
File[] fileArray = file.listFiles();
|
|
HashMap<Object[], ModuleBuild> hashMap = new HashMap<Object[], ModuleBuild>();
|
|
HashMap<String, ArrayList<ModuleBuild>> hashMap2 = new HashMap<String, ArrayList<ModuleBuild>>();
|
|
HashMap<Object[], ModuleBuild> hashMap3 = new HashMap<Object[], ModuleBuild>();
|
|
int n = 0;
|
|
while (true) {
|
|
if (n >= fileArray.length) {
|
|
if (hashMap.size() != 0 || hashMap3.size() != 0) break;
|
|
return;
|
|
}
|
|
object = fileArray[n];
|
|
if (!skipFiles.contains(object.getName()) && (object.getName().endsWith(".jar") || object.getName().endsWith(".sjar"))) {
|
|
ModuleBuild moduleBuild;
|
|
objectArray2 = object.getName().substring(0, object.getName().length() - 4);
|
|
objectArray = (Object[])nRegistry.db.modulesByName.get(objectArray2);
|
|
if (objectArray == null) {
|
|
try {
|
|
moduleBuild = Builder.readModule((File)object, true);
|
|
if (moduleBuild == null) {
|
|
skipFiles.add(object.getName());
|
|
} else {
|
|
hashMap.put(objectArray2, moduleBuild);
|
|
DependencyInfo[] dependencyInfoArray = moduleBuild.info.depends;
|
|
int n2 = 0;
|
|
while (n2 < dependencyInfoArray.length) {
|
|
ArrayList<ModuleBuild> arrayList = (ArrayList<ModuleBuild>)hashMap2.get(dependencyInfoArray[n2].getModuleName());
|
|
if (arrayList == null) {
|
|
arrayList = new ArrayList<ModuleBuild>();
|
|
hashMap2.put(dependencyInfoArray[n2].getModuleName(), arrayList);
|
|
}
|
|
arrayList.add(moduleBuild);
|
|
++n2;
|
|
}
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot read module " + object.getName(), throwable);
|
|
}
|
|
} else if (objectArray.isReloadableModule) {
|
|
try {
|
|
moduleBuild = Builder.readModule((File)object, true);
|
|
if (moduleBuild.info.getBuildTime() != objectArray.getBuildTime()) {
|
|
hashMap3.put(objectArray2, moduleBuild);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot read module " + object.getName(), throwable);
|
|
}
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
Object object2 = hashMap3.keySet().iterator();
|
|
while (object2.hasNext()) {
|
|
object = (String)object2.next();
|
|
try {
|
|
log.trace("Reload module " + (String)object);
|
|
Builder.reloadModule(nRegistry, (String)object);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot reload module " + (String)object, throwable);
|
|
}
|
|
}
|
|
object2 = hashMap2.keySet().iterator();
|
|
while (object2.hasNext()) {
|
|
Builder.checkDependencies((String)object2.next(), nRegistry, hashMap2, hashMap);
|
|
}
|
|
object2 = new Builder();
|
|
super.init(hashMap.values().toArray(new ModuleBuild[hashMap.size()]), nRegistry);
|
|
super.resolveSuperAndInterfaces();
|
|
super.resolveIsTypes();
|
|
super.resolveAdapters();
|
|
super.agentize();
|
|
object = super.sortModules();
|
|
objectArray2 = (NModuleInfo[])ArrayUtil.add(nRegistry.db.modules, object);
|
|
objectArray = new String[objectArray2.length];
|
|
int n3 = 0;
|
|
while (n3 < objectArray2.length) {
|
|
objectArray[n3] = ((NModuleInfo)objectArray2[n3]).getModuleName();
|
|
++n3;
|
|
}
|
|
SortUtil.sort((Object[])objectArray, (Object[])objectArray2);
|
|
NTypeInfo[] nTypeInfoArray = ((Builder)object2).typesByClass.values().toArray(new NTypeInfo[((Builder)object2).typesByClass.size()]);
|
|
HashMap<String, NTypeInfo> hashMap4 = new HashMap<String, NTypeInfo>();
|
|
int n4 = 0;
|
|
while (n4 < nTypeInfoArray.length) {
|
|
hashMap4.put(nTypeInfoArray[n4].typeSpec.toString(), nTypeInfoArray[n4]);
|
|
++n4;
|
|
}
|
|
NAdapterInfo[] nAdapterInfoArray = new NAdapterInfo[nRegistry.db.adapters.length + ((Builder)object2).adapterBuilds.size()];
|
|
System.arraycopy(nRegistry.db.adapters, 0, nAdapterInfoArray, 0, nRegistry.db.adapters.length);
|
|
int n5 = 0;
|
|
while (n5 < ((Builder)object2).adapterBuilds.size()) {
|
|
nAdapterInfoArray[n5 + nRegistry.db.adapters.length] = ((AdapterBuild)((Builder)object2).adapterBuilds.get((int)n5)).info;
|
|
++n5;
|
|
}
|
|
String[] stringArray = super.sortOrdSchemes();
|
|
String[] stringArray2 = super.sortFileExts();
|
|
HashMap<String, Object> hashMap5 = new HashMap<String, Object>();
|
|
hashMap5.putAll(nRegistry.db.modulesByName);
|
|
int n6 = 0;
|
|
while (n6 < ((Object[])object).length) {
|
|
hashMap5.put(((NModuleInfo)object[n6]).getModuleName(), object[n6]);
|
|
++n6;
|
|
}
|
|
n6 = 0;
|
|
while (n6 < ((Builder)object2).moduleBuilds.length) {
|
|
Iterator iterator = ((Builder)object2).moduleBuilds[n6].agentTypesByTargetSpec.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
String string = (String)iterator.next();
|
|
NTypeInfo nTypeInfo = (NTypeInfo)hashMap4.get(string);
|
|
Object[] objectArray3 = (NTypeInfo[])((Builder)object2).moduleBuilds[n6].agentTypesByTargetSpec.get(string);
|
|
nTypeInfo.agents = (NTypeInfo[])ArrayUtil.add(nTypeInfo.agents, objectArray3);
|
|
}
|
|
++n6;
|
|
}
|
|
nRegistry.db.modules = objectArray2;
|
|
nRegistry.db.modulesByName = hashMap5;
|
|
nRegistry.db.types = nTypeInfoArray;
|
|
nRegistry.db.typesBySpec = hashMap4;
|
|
nRegistry.db.defs = ((Builder)object2).defs;
|
|
nRegistry.db.fileExts = stringArray2;
|
|
nRegistry.db.typesByFileExt = ((Builder)object2).typesByFileExt;
|
|
nRegistry.db.ordSchemes = stringArray;
|
|
nRegistry.db.lexicons = ((Builder)object2).lexicons;
|
|
nRegistry.db.typesByOrdScheme = ((Builder)object2).typesByOrdScheme;
|
|
nRegistry.db.adapters = nAdapterInfoArray;
|
|
return;
|
|
}
|
|
}
|
|
|
|
private static final void checkDependencies(String string, NRegistry nRegistry, Map map, Map map2) {
|
|
ArrayList arrayList = (ArrayList)map.get(string);
|
|
if (arrayList == null) {
|
|
return;
|
|
}
|
|
ModuleBuild moduleBuild = (ModuleBuild)map2.get(string);
|
|
NModuleInfo nModuleInfo = moduleBuild == null ? (NModuleInfo)nRegistry.db.modulesByName.get(string) : moduleBuild.info;
|
|
int n = 0;
|
|
while (n < arrayList.size()) {
|
|
ModuleBuild moduleBuild2 = (ModuleBuild)arrayList.get(n);
|
|
String string2 = moduleBuild2.info.getModuleName();
|
|
if (map2.containsKey(string2)) {
|
|
DependencyInfo[] dependencyInfoArray = moduleBuild2.info.depends;
|
|
int n2 = 0;
|
|
while (n2 < dependencyInfoArray.length) {
|
|
if (dependencyInfoArray[n2].getModuleName().equals(string)) {
|
|
if (nModuleInfo != null && (dependencyInfoArray[n2].getVendorVersion() == null || nModuleInfo.getVendorVersion().compareTo(dependencyInfoArray[n2].getVendorVersion()) >= 0) || map2.remove(string2) == null) break;
|
|
log.error("Cannot load module " + string2 + ".jar, dependency failed: " + dependencyInfoArray[n2]);
|
|
Builder.checkDependencies(string2, nRegistry, map, map2);
|
|
break;
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
static void loadModule(NRegistry nRegistry, String string) throws ModuleNotFoundException {
|
|
NRegistry nRegistry2 = nRegistry;
|
|
synchronized (nRegistry2) {
|
|
Object[] objectArray;
|
|
Object object;
|
|
File file = new File(Nre.bajaHome, "modules");
|
|
HashMap<String, ModuleBuild> hashMap = new HashMap<String, ModuleBuild>();
|
|
HashMap<String, Object[]> hashMap2 = new HashMap<String, Object[]>();
|
|
File file2 = new File(file, string + ".jar");
|
|
if (!file2.exists()) {
|
|
throw new ModuleNotFoundException(string);
|
|
}
|
|
NModuleInfo nModuleInfo = (NModuleInfo)nRegistry.db.modulesByName.get(string);
|
|
if (nModuleInfo == null || !nModuleInfo.isAutoloadModule || nModuleInfo.isReloadableModule) {
|
|
try {
|
|
ModuleBuild moduleBuild = Builder.readModule(file2, true, true);
|
|
hashMap.put(string, moduleBuild);
|
|
object = moduleBuild.info.depends;
|
|
int n = 0;
|
|
while (n < ((DependencyInfo[])object).length) {
|
|
objectArray = (Object[])hashMap2.get(object[n].getModuleName());
|
|
if (objectArray == null) {
|
|
objectArray = new ArrayList();
|
|
hashMap2.put(object[n].getModuleName(), objectArray);
|
|
}
|
|
objectArray.add(moduleBuild);
|
|
++n;
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot read module " + file2.getName(), throwable);
|
|
}
|
|
}
|
|
object = hashMap2.keySet().iterator();
|
|
while (object.hasNext()) {
|
|
Builder.checkDependencies((String)object.next(), nRegistry, hashMap2, hashMap);
|
|
}
|
|
object = new Builder();
|
|
super.init(hashMap.values().toArray(new ModuleBuild[hashMap.size()]), nRegistry);
|
|
super.resolveSuperAndInterfaces();
|
|
super.resolveIsTypes();
|
|
super.resolveAdapters();
|
|
super.agentize();
|
|
Object[] objectArray2 = super.sortModules();
|
|
objectArray = nRegistry.db.modules;
|
|
Class clazz = class$com$tridium$sys$registry$NModuleInfo;
|
|
if (clazz == null) {
|
|
clazz = class$com$tridium$sys$registry$NModuleInfo = Builder.class("[Lcom.tridium.sys.registry.NModuleInfo;", false);
|
|
}
|
|
Array array = new Array(clazz);
|
|
if (nModuleInfo != null) {
|
|
int n = 0;
|
|
while (n < objectArray.length) {
|
|
if (!((NModuleInfo)objectArray[n]).getModuleName().equals(nModuleInfo.getModuleName())) {
|
|
array.add(objectArray[n]);
|
|
}
|
|
++n;
|
|
}
|
|
objectArray = (NModuleInfo[])array.trim();
|
|
}
|
|
objectArray = (NModuleInfo[])ArrayUtil.add(objectArray, objectArray2);
|
|
Object[] objectArray3 = new String[objectArray.length];
|
|
int n = 0;
|
|
while (n < objectArray.length) {
|
|
objectArray3[n] = ((NModuleInfo)objectArray[n]).getModuleName();
|
|
++n;
|
|
}
|
|
SortUtil.sort((Object[])objectArray3, (Object[])objectArray);
|
|
NTypeInfo[] nTypeInfoArray = ((Builder)object).typesByClass.values().toArray(new NTypeInfo[((Builder)object).typesByClass.size()]);
|
|
HashMap<String, NTypeInfo> hashMap3 = new HashMap<String, NTypeInfo>();
|
|
int n2 = 0;
|
|
while (n2 < nTypeInfoArray.length) {
|
|
hashMap3.put(nTypeInfoArray[n2].typeSpec.toString(), nTypeInfoArray[n2]);
|
|
++n2;
|
|
}
|
|
NAdapterInfo[] nAdapterInfoArray = new NAdapterInfo[nRegistry.db.adapters.length + ((Builder)object).adapterBuilds.size()];
|
|
System.arraycopy(nRegistry.db.adapters, 0, nAdapterInfoArray, 0, nRegistry.db.adapters.length);
|
|
int n3 = 0;
|
|
while (n3 < ((Builder)object).adapterBuilds.size()) {
|
|
nAdapterInfoArray[n3 + nRegistry.db.adapters.length] = ((AdapterBuild)((Builder)object).adapterBuilds.get((int)n3)).info;
|
|
++n3;
|
|
}
|
|
String[] stringArray = super.sortOrdSchemes();
|
|
String[] stringArray2 = super.sortFileExts();
|
|
HashMap<String, Object> hashMap4 = new HashMap<String, Object>();
|
|
hashMap4.putAll(nRegistry.db.modulesByName);
|
|
int n4 = 0;
|
|
while (n4 < objectArray2.length) {
|
|
hashMap4.put(((NModuleInfo)objectArray2[n4]).getModuleName(), objectArray2[n4]);
|
|
++n4;
|
|
}
|
|
n4 = 0;
|
|
while (n4 < ((Builder)object).moduleBuilds.length) {
|
|
Iterator iterator = ((Builder)object).moduleBuilds[n4].agentTypesByTargetSpec.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
String string2 = (String)iterator.next();
|
|
NTypeInfo nTypeInfo = (NTypeInfo)hashMap3.get(string2);
|
|
Object[] objectArray4 = (NTypeInfo[])((Builder)object).moduleBuilds[n4].agentTypesByTargetSpec.get(string2);
|
|
nTypeInfo.agents = (NTypeInfo[])ArrayUtil.add(nTypeInfo.agents, objectArray4);
|
|
}
|
|
++n4;
|
|
}
|
|
nRegistry.db.modules = objectArray;
|
|
nRegistry.db.modulesByName = hashMap4;
|
|
nRegistry.db.types = nTypeInfoArray;
|
|
nRegistry.db.typesBySpec = hashMap3;
|
|
nRegistry.db.defs = ((Builder)object).defs;
|
|
nRegistry.db.fileExts = stringArray2;
|
|
nRegistry.db.typesByFileExt = ((Builder)object).typesByFileExt;
|
|
nRegistry.db.ordSchemes = stringArray;
|
|
nRegistry.db.lexicons = ((Builder)object).lexicons;
|
|
nRegistry.db.typesByOrdScheme = ((Builder)object).typesByOrdScheme;
|
|
nRegistry.db.adapters = nAdapterInfoArray;
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* WARNING - Removed try catching itself - possible behaviour change.
|
|
* Unable to fully structure code
|
|
* Enabled aggressive block sorting
|
|
* Enabled unnecessary exception pruning
|
|
* Enabled aggressive exception aggregation
|
|
*/
|
|
static void unloadModule(NRegistry var0, String var1_1) throws Exception {
|
|
var2_2 = (NModuleInfo)var0.db.modulesByName.get(var1_1);
|
|
if (var2_2 == null) {
|
|
throw new Exception("Module not loaded.");
|
|
}
|
|
if (var2_2.isAutoloadModule && !var2_2.isReloadableModule) {
|
|
throw new Exception("Module must not be autoload or must be reloadable");
|
|
}
|
|
var3_3 = new File(Nre.bajaHome, "modules");
|
|
var4_4 = new File(var3_3, var1_1 + ".jar");
|
|
if (!var4_4.exists()) {
|
|
throw new ModuleNotFoundException(var1_1);
|
|
}
|
|
var5_5 = Builder.readModule(var4_4, true, true);
|
|
var6_6 = var0;
|
|
synchronized (var6_6) {
|
|
var8_7 = var2_2.getTypes();
|
|
var9_8 = var0.db.types;
|
|
var10_9 = var0.db.typesBySpec;
|
|
v0 = Builder.class$com$tridium$sys$registry$NTypeInfo;
|
|
if (v0 == null) {
|
|
v0 = Builder.class$com$tridium$sys$registry$NTypeInfo = Builder.class("[Lcom.tridium.sys.registry.NTypeInfo;", false);
|
|
}
|
|
var11_10 = new Array(v0);
|
|
var12_11 = 0;
|
|
while (true) {
|
|
block30: {
|
|
if (var12_11 < var9_8.length) break block30;
|
|
var9_8 = (NTypeInfo[])var11_10.trim();
|
|
var12_12 = var0.db.defs;
|
|
var13_14 = var5_5.defs;
|
|
var14_16 = var13_14.keySet().iterator();
|
|
if (true) ** GOTO lbl52
|
|
}
|
|
var13_13 = false;
|
|
var14_15 = 0;
|
|
while (var14_15 < var8_7.length) {
|
|
if (var9_8[var12_11].equals(var8_7[var14_15])) {
|
|
var13_13 = true;
|
|
var10_9.remove(var9_8[var12_11].getTypeSpec().toString());
|
|
break;
|
|
}
|
|
++var14_15;
|
|
}
|
|
if (!var13_13) {
|
|
var11_10.add((Object)var9_8[var12_11]);
|
|
}
|
|
++var12_11;
|
|
}
|
|
do {
|
|
var15_17 /* !! */ = var14_16.next();
|
|
var12_12.remove(var15_17 /* !! */ );
|
|
lbl52:
|
|
// 2 sources
|
|
|
|
} while (var14_16.hasNext());
|
|
var15_17 /* !! */ = var0.db.fileExts;
|
|
var16_18 = var0.db.typesByFileExt;
|
|
var17_19 = var5_5.typesByFileExt;
|
|
v2 = Builder.class$java$lang$String;
|
|
if (v2 == null) {
|
|
v2 = Builder.class$java$lang$String = Builder.class("[Ljava.lang.String;", false);
|
|
}
|
|
var11_10 = new Array(v2);
|
|
var18_20 = 0;
|
|
while (var18_20 < ((K)var15_17 /* !! */ ).length) {
|
|
var19_22 = false;
|
|
var20_24 = var17_19.keySet().iterator();
|
|
while (var20_24.hasNext()) {
|
|
if (var15_17 /* !! */ [var18_20].equals(var20_24.next())) {
|
|
var16_18.remove(var15_17 /* !! */ [var18_20]);
|
|
}
|
|
var19_22 = true;
|
|
}
|
|
if (!var19_22) {
|
|
var11_10.add(var15_17 /* !! */ [var18_20]);
|
|
}
|
|
++var18_20;
|
|
}
|
|
var15_17 /* !! */ = (String[])var11_10.trim();
|
|
var18_21 = var0.db.ordSchemes;
|
|
var19_23 = var0.db.typesByOrdScheme;
|
|
var20_24 = var5_5.typesByOrdScheme;
|
|
v3 = Builder.class$java$lang$String;
|
|
if (v3 == null) {
|
|
v3 = Builder.class$java$lang$String = Builder.class("[Ljava.lang.String;", false);
|
|
}
|
|
var11_10 = new Array(v3);
|
|
var21_25 = 0;
|
|
while (var21_25 < var18_21.length) {
|
|
var22_27 = false;
|
|
var23_29 = var20_24.keySet().iterator();
|
|
while (var23_29.hasNext()) {
|
|
if (var18_21[var21_25].equals(var23_29.next())) {
|
|
var19_23.remove(var18_21[var21_25]);
|
|
}
|
|
var22_27 = true;
|
|
}
|
|
if (!var22_27) {
|
|
var11_10.add((Object)var18_21[var21_25]);
|
|
}
|
|
++var21_25;
|
|
}
|
|
var18_21 = (String[])var11_10.trim();
|
|
var21_26 = var0.db.lexicons;
|
|
var22_28 = var5_5.lexicons;
|
|
var23_29 = var22_28.keySet().iterator();
|
|
while (var23_29.hasNext()) {
|
|
var21_26.remove(var23_29.next());
|
|
}
|
|
var24_30 = var0.db.adapters;
|
|
var25_31 = var5_5.adapterBuilds;
|
|
v4 = Builder.class$com$tridium$sys$registry$NAdapterInfo;
|
|
if (v4 == null) {
|
|
v4 = Builder.class$com$tridium$sys$registry$NAdapterInfo = Builder.class("[Lcom.tridium.sys.registry.NAdapterInfo;", false);
|
|
}
|
|
var11_10 = new Array(v4);
|
|
var26_32 = 0;
|
|
while (var26_32 < var24_30.length) {
|
|
var27_34 = 0;
|
|
var28_35 = 0;
|
|
while (var26_32 < var25_31.size()) {
|
|
if (var24_30[var26_32].equals(((AdapterBuild)var25_31.get((int)var28_35)).info)) {
|
|
var27_34 = 1;
|
|
}
|
|
++var28_35;
|
|
}
|
|
if (var27_34 == 0) {
|
|
var11_10.add((Object)var24_30[var26_32]);
|
|
}
|
|
++var26_32;
|
|
}
|
|
var24_30 = (NAdapterInfo[])var11_10.trim();
|
|
var26_33 = var0.db.modules;
|
|
var27_34 = 0;
|
|
while (var27_34 < var26_33.length) {
|
|
if (var26_33[var27_34].getModuleName().equals(var2_2.getModuleName())) {
|
|
var26_33[var27_34] = var5_5.info;
|
|
}
|
|
++var27_34;
|
|
}
|
|
var0.db.modules = var26_33;
|
|
var0.db.types = var9_8;
|
|
var0.db.typesBySpec = var10_9;
|
|
var0.db.defs = var12_12;
|
|
var0.db.fileExts = var15_17 /* !! */ ;
|
|
var0.db.typesByFileExt = var16_18;
|
|
var0.db.ordSchemes = var18_21;
|
|
var0.db.typesByOrdScheme = var19_23;
|
|
var0.db.lexicons = var21_26;
|
|
var0.db.adapters = var24_30;
|
|
var2_2.types = NTypeInfo.noTypes;
|
|
Nre.moduleManager.unloadModule(var1_1);
|
|
return;
|
|
}
|
|
}
|
|
|
|
static void reloadModule(NRegistry nRegistry, String string) throws Exception {
|
|
NModuleInfo nModuleInfo = (NModuleInfo)nRegistry.db.modulesByName.get(string);
|
|
if (nModuleInfo == null) {
|
|
throw new BajaRuntimeException("Module not loaded");
|
|
}
|
|
if (!nModuleInfo.isReloadableModule) {
|
|
throw new BajaRuntimeException("Cannot reload this module");
|
|
}
|
|
Builder.unloadModule(nRegistry, string);
|
|
Builder.loadModule(nRegistry, string);
|
|
}
|
|
|
|
private static final void clean(NRegistry nRegistry) throws Exception {
|
|
FileUtil.delete(nRegistry.dir());
|
|
}
|
|
|
|
private static final ModuleBuild[] load() throws Exception {
|
|
if (log.isTraceOn()) {
|
|
log.trace("Builder.read");
|
|
}
|
|
File file = new File(Nre.bajaHome, "modules");
|
|
Object[] objectArray = file.listFiles();
|
|
SortUtil.sort((Object[])objectArray, (Object[])objectArray, (Comparator)new Comparator(){
|
|
|
|
public final int compare(Object object, Object object2) {
|
|
return ((File)object).getName().compareTo(((File)object2).getName());
|
|
}
|
|
});
|
|
ArrayList<ModuleBuild> arrayList = new ArrayList<ModuleBuild>();
|
|
int n = 0;
|
|
while (n < objectArray.length) {
|
|
Object object = objectArray[n];
|
|
skipFiles.clear();
|
|
if (((File)object).getName().endsWith(".jar") || ((File)object).getName().endsWith(".sjar")) {
|
|
try {
|
|
ModuleBuild moduleBuild = Builder.readModule((File)object, false);
|
|
if (moduleBuild == null) {
|
|
skipFiles.add(((File)object).getName());
|
|
} else {
|
|
arrayList.add(moduleBuild);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot read module " + ((File)object).getName(), throwable);
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
return arrayList.toArray(new ModuleBuild[arrayList.size()]);
|
|
}
|
|
|
|
private static final ModuleBuild readModule(File file, boolean bl) throws Exception {
|
|
return Builder.readModule(file, bl, false);
|
|
}
|
|
|
|
private static final ModuleBuild readModule(File file, boolean bl, boolean bl2) throws Exception {
|
|
JarFile jarFile;
|
|
JarEntry jarEntry;
|
|
if (log.isTraceOn()) {
|
|
log.trace("Builder.read \"" + file.getName() + "\"...");
|
|
}
|
|
if ((jarEntry = (jarFile = new JarFile(file)).getJarEntry("META-INF/module.xml")) == null) {
|
|
jarEntry = jarFile.getJarEntry("meta-inf/module.xml");
|
|
}
|
|
if (jarEntry == null) {
|
|
throw new ModuleException("Module missing META-INF/module.xml: " + file);
|
|
}
|
|
XElem xElem = XParser.make((InputStream)new BufferedInputStream(jarEntry.getInputStream())).parse();
|
|
ModuleBuild moduleBuild = Builder.readManifest(xElem, jarFile, bl, bl2);
|
|
if (moduleBuild == null) {
|
|
jarFile.close();
|
|
return null;
|
|
}
|
|
String string = file.getName();
|
|
if (string.endsWith(".jar")) {
|
|
string = string.substring(0, string.length() - ".jar".length());
|
|
} else if (string.endsWith(".sjar")) {
|
|
string = string.substring(0, string.length() - ".sjar".length());
|
|
}
|
|
if (!string.equals(moduleBuild.info.moduleName)) {
|
|
throw new ModuleException("File name does not match manifest: " + string);
|
|
}
|
|
NModuleInfo nModuleInfo = moduleBuild.info;
|
|
boolean bl3 = false;
|
|
if (jarFile.getJarEntry("module.palette") != null) {
|
|
bl3 = true;
|
|
}
|
|
nModuleInfo.hasPalette = bl3;
|
|
jarFile.close();
|
|
moduleBuild.snapshot.size = file.length();
|
|
moduleBuild.snapshot.timestamp = file.lastModified();
|
|
return moduleBuild;
|
|
}
|
|
|
|
private static final ModuleBuild readManifest(XElem xElem, JarFile jarFile, boolean bl, boolean bl2) {
|
|
XElem[] xElemArray;
|
|
XElem xElem2;
|
|
if (!xElem.getb("nre", true) || !xElem.getb("installable", true)) {
|
|
return null;
|
|
}
|
|
ModuleBuild moduleBuild = new ModuleBuild();
|
|
moduleBuild.info.moduleName = xElem.get("name");
|
|
moduleBuild.info.bajaVersion = new Version(xElem.get("bajaVersion"));
|
|
moduleBuild.info.vendor = xElem.get("vendor");
|
|
moduleBuild.info.vendorVersion = new Version(xElem.get("vendorVersion"));
|
|
moduleBuild.info.description = xElem.get("description");
|
|
moduleBuild.info.buildTime = Long.parseLong(xElem.get("buildMillis", "0"));
|
|
moduleBuild.info.moduleContent = xElem.get("archiveInstall", "doc");
|
|
moduleBuild.info.isAutoloadModule = xElem.getb("autoload", true);
|
|
moduleBuild.info.isReloadableModule = xElem.getb("reloadable", false);
|
|
moduleBuild.snapshot.name = moduleBuild.info.moduleName;
|
|
if (moduleBuild.info.isAutoloadModule || bl2 || moduleBuild.info.isReloadableModule) {
|
|
XElem xElem3;
|
|
Object[] objectArray;
|
|
Object object;
|
|
XElem[] xElemArray2;
|
|
xElem2 = xElem.elem("defs");
|
|
if (xElem2 != null) {
|
|
int n = xElem2.contentSize();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
try {
|
|
xElemArray2 = xElem2.elem(n2);
|
|
if (xElemArray2.name().equals("def")) {
|
|
String string = xElemArray2.get("name");
|
|
object = xElemArray2.get("value");
|
|
objectArray = (String[])moduleBuild.defs.get(string);
|
|
objectArray = objectArray != null ? (String[])ArrayUtil.addOne(objectArray, object) : new String[]{object};
|
|
moduleBuild.defs.put(string, objectArray);
|
|
}
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("Error on def in \"" + moduleBuild.info.moduleName + '\"', exception);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
if ((xElemArray = xElem.elem("lexicons")) != null) {
|
|
String string = xElemArray.get("brand", "");
|
|
xElemArray2 = xElemArray.elems("lexicon");
|
|
int n = xElemArray2.length;
|
|
int n3 = 0;
|
|
while (n3 < n) {
|
|
try {
|
|
objectArray = xElemArray2[n3];
|
|
NLexiconInfo nLexiconInfo = new NLexiconInfo((XElem)objectArray, string, moduleBuild.info.moduleName);
|
|
String string2 = nLexiconInfo.getModuleName();
|
|
String string3 = nLexiconInfo.getLanguage();
|
|
String string4 = nLexiconInfo.getContainerModuleName();
|
|
nLexiconInfo.setLastModified(jarFile.getFile().lastModified());
|
|
if (string3 != null && string3.length() > 0) {
|
|
string2 = string2 + '-' + string3;
|
|
}
|
|
string2 = string2 + '-' + string4;
|
|
moduleBuild.lexicons.put(string2, nLexiconInfo);
|
|
}
|
|
catch (Exception exception) {
|
|
log.error("Error on lexicon in \"" + moduleBuild.info.moduleName + '\"', exception);
|
|
}
|
|
++n3;
|
|
}
|
|
}
|
|
if ((xElem3 = xElem.elem("types")) != null) {
|
|
xElemArray2 = xElem3.elems("type");
|
|
moduleBuild.info.types = new NTypeInfo[xElemArray2.length];
|
|
int n = 0;
|
|
while (n < xElemArray2.length) {
|
|
try {
|
|
object = Builder.readType(jarFile, moduleBuild, xElemArray2[n]);
|
|
moduleBuild.typeBuilds.add(object);
|
|
moduleBuild.info.types[n] = ((TypeBuild)object).info;
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Error on type \"" + moduleBuild.info.moduleName + ':' + xElemArray2[n].get("name", "???") + '\"', throwable);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
if (bl) {
|
|
xElem2 = xElem.elem("dependencies");
|
|
if (xElem2 == null) {
|
|
moduleBuild.info.depends = new NDependencyInfo[0];
|
|
} else {
|
|
xElemArray = xElem2.elems("dependency");
|
|
moduleBuild.info.depends = new NDependencyInfo[xElemArray.length];
|
|
int n = 0;
|
|
while (n < xElemArray.length) {
|
|
moduleBuild.info.depends[n] = new NDependencyInfo(xElemArray[n]);
|
|
((NDependencyInfo)moduleBuild.info.depends[n]).module = moduleBuild.info;
|
|
++n;
|
|
}
|
|
}
|
|
}
|
|
return moduleBuild;
|
|
}
|
|
|
|
private static final TypeBuild readType(JarFile jarFile, ModuleBuild moduleBuild, XElem xElem) throws Exception {
|
|
Object object;
|
|
XElem xElem2;
|
|
XElem xElem3;
|
|
XElem xElem4;
|
|
String string = xElem.get("name");
|
|
TypeBuild typeBuild = new TypeBuild(moduleBuild, BTypeSpec.make(moduleBuild.info.moduleName, string));
|
|
String string2 = xElem.get("ordScheme", null);
|
|
if (string2 != null) {
|
|
typeBuild.ordScheme = string2 = TextUtil.toLowerCase((String)string2);
|
|
if (moduleBuild.typesByOrdScheme.get(string2) != null) {
|
|
log.warning("Multiple types registered for ordScheme \"" + string2 + '\"');
|
|
} else {
|
|
moduleBuild.typesByOrdScheme.put(string2, typeBuild.info);
|
|
}
|
|
}
|
|
if ((xElem4 = xElem.elem("file")) != null) {
|
|
Builder.readFile(typeBuild, xElem4);
|
|
}
|
|
if ((xElem3 = xElem.elem("agent")) != null) {
|
|
Builder.readAgent(typeBuild, xElem3);
|
|
}
|
|
if ((xElem2 = xElem.elem("adapter")) != null) {
|
|
Builder.readAdapter(typeBuild, xElem2);
|
|
}
|
|
typeBuild.info.className = xElem.get("class");
|
|
if (jarFile.getFile().getName().endsWith(".jar")) {
|
|
object = jarFile.getJarEntry(typeBuild.info.className.replace('.', '/') + ".class");
|
|
if (object == null) {
|
|
log.error("Missing class for \"" + typeBuild + '\"');
|
|
return typeBuild;
|
|
}
|
|
ClassScanner classScanner = new ClassScanner();
|
|
classScanner.scan(((JarEntry)object).getInputStream());
|
|
typeBuild.info.modifiers = classScanner.modifiers;
|
|
typeBuild.superClass = classScanner.superClass;
|
|
typeBuild.interfaceClasses = classScanner.interfaces;
|
|
if (!classScanner.hasLoadType) {
|
|
log.error("Missing Sys.loadType() " + typeBuild);
|
|
}
|
|
} else if (jarFile.getFile().getName().endsWith(".sjar")) {
|
|
Class clazz = class$javax$baja$sys$BComponent;
|
|
if (clazz == null) {
|
|
clazz = class$javax$baja$sys$BComponent = Builder.class("[Ljavax.baja.sys.BComponent;", false);
|
|
}
|
|
typeBuild.superClass = xElem.get("extends", clazz.getName());
|
|
Builder.readInterfaces(typeBuild, xElem);
|
|
typeBuild.info.modifiers = 1;
|
|
if (xElem.get("abstract", "false").equalsIgnoreCase("true")) {
|
|
typeBuild.info.modifiers |= 0x400;
|
|
}
|
|
if (xElem.get("final", "false").equalsIgnoreCase("true")) {
|
|
typeBuild.info.modifiers |= 0x10;
|
|
}
|
|
} else {
|
|
throw new IllegalStateException();
|
|
}
|
|
object = (NTypeInfo)moduleBuild.typesBySpec.get(typeBuild.toString());
|
|
if (object != null) {
|
|
log.error("Duplicate typespec " + object + " & " + typeBuild);
|
|
} else {
|
|
moduleBuild.typesBySpec.put(typeBuild.toString(), typeBuild.info);
|
|
}
|
|
object = (NTypeInfo)moduleBuild.typesByClass.get(typeBuild.info.className);
|
|
if (object != null) {
|
|
log.error("Duplicate classes " + object + " & " + typeBuild);
|
|
} else {
|
|
moduleBuild.typesByClass.put(typeBuild.info.className, typeBuild.info);
|
|
}
|
|
return typeBuild;
|
|
}
|
|
|
|
private static final void readFile(TypeBuild typeBuild, XElem xElem) {
|
|
try {
|
|
int n = 0;
|
|
while (n < xElem.contentSize()) {
|
|
XElem xElem2 = xElem.elem(n);
|
|
if (xElem2.name().equals("ext")) {
|
|
String string = TextUtil.toLowerCase((String)xElem2.get("name"));
|
|
NTypeInfo nTypeInfo = (NTypeInfo)typeBuild.moduleBuild.typesByFileExt.get(string);
|
|
if (nTypeInfo != null) {
|
|
log.warning("Duplicate files for ext \"" + string + "\": " + nTypeInfo + " & " + typeBuild);
|
|
} else {
|
|
typeBuild.moduleBuild.typesByFileExt.put(string, typeBuild.info);
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot map type as file \"" + typeBuild + '\"', throwable);
|
|
}
|
|
}
|
|
|
|
private static final void readAgent(TypeBuild typeBuild, XElem xElem) {
|
|
try {
|
|
typeBuild.info.agentInfo = new NAgentInfo(typeBuild.info);
|
|
String string = xElem.get("requiredPermissions", null);
|
|
typeBuild.info.agentInfo.permissions = string != null ? BPermissions.make(string) : BPermissions.adminWrite;
|
|
typeBuild.info.agentInfo.appName = xElem.get("app", null);
|
|
String string2 = xElem.get("default", null);
|
|
if (string2 != null && string2.equalsIgnoreCase("true")) {
|
|
typeBuild.info.agentInfo.defaultPreferrence = 1;
|
|
} else if (string2 != null && string2.equalsIgnoreCase("false")) {
|
|
typeBuild.info.agentInfo.defaultPreferrence = 2;
|
|
}
|
|
int n = 0;
|
|
while (n < xElem.contentSize()) {
|
|
XElem xElem2 = xElem.elem(n);
|
|
if (xElem2.name().equals("on")) {
|
|
typeBuild.addAgentOn(xElem2.get("type"));
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
catch (XException xException) {
|
|
log.error("Cannot map type as agent \"" + typeBuild + "\": " + (Object)((Object)xException));
|
|
typeBuild.info.agentInfo = null;
|
|
typeBuild.agentsOn = null;
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot map type as agent \"" + typeBuild + '\"', throwable);
|
|
typeBuild.info.agentInfo = null;
|
|
typeBuild.agentsOn = null;
|
|
}
|
|
}
|
|
|
|
private static final void readAdapter(TypeBuild typeBuild, XElem xElem) {
|
|
try {
|
|
AdapterBuild adapterBuild = new AdapterBuild(typeBuild);
|
|
adapterBuild.fromSpec = xElem.get("from");
|
|
adapterBuild.toSpec = xElem.get("to");
|
|
typeBuild.moduleBuild.adapterBuilds.add(adapterBuild);
|
|
}
|
|
catch (XException xException) {
|
|
log.error("Cannot map type as adapter \"" + typeBuild + "\": " + (Object)((Object)xException));
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot map type as adapter \"" + typeBuild + '\"', throwable);
|
|
}
|
|
}
|
|
|
|
private static final void readInterfaces(TypeBuild typeBuild, XElem xElem) {
|
|
XElem xElem2 = xElem.elem("interfaces");
|
|
if (xElem2 != null) {
|
|
XElem[] xElemArray = xElem2.elems("interface");
|
|
String[] stringArray = new String[xElemArray.length];
|
|
int n = 0;
|
|
while (n < xElemArray.length) {
|
|
stringArray[n] = xElemArray[n].get("class");
|
|
++n;
|
|
}
|
|
typeBuild.interfaceClasses = stringArray;
|
|
} else {
|
|
typeBuild.interfaceClasses = new String[0];
|
|
}
|
|
}
|
|
|
|
private final void init(ModuleBuild[] moduleBuildArray, NRegistry nRegistry) {
|
|
this.typesByFileExt.putAll(nRegistry.db.typesByFileExt);
|
|
this.typesByOrdScheme.putAll(nRegistry.db.typesByOrdScheme);
|
|
this.typesBySpecString.putAll(nRegistry.db.typesBySpec);
|
|
this.defs.putAll(nRegistry.db.defs);
|
|
this.lexicons.putAll(nRegistry.db.lexicons);
|
|
int n = 0;
|
|
while (n < nRegistry.db.types.length) {
|
|
this.typesByClass.put(nRegistry.db.types[n].className, nRegistry.db.types[n]);
|
|
++n;
|
|
}
|
|
this.init(moduleBuildArray, nRegistry.db.modules.length, nRegistry.db.types.length);
|
|
}
|
|
|
|
private final void init(ModuleBuild[] moduleBuildArray, int n, int n2) {
|
|
this.moduleBuilds = moduleBuildArray;
|
|
int n3 = 0;
|
|
while (n3 < moduleBuildArray.length) {
|
|
Object object;
|
|
Object object2;
|
|
Object object3;
|
|
ModuleBuild moduleBuild = moduleBuildArray[n3];
|
|
moduleBuild.info.id = n3 + n;
|
|
int n4 = 0;
|
|
while (n4 < moduleBuild.info.types.length) {
|
|
object3 = moduleBuild.info.types[n4];
|
|
object2 = (TypeBuild)moduleBuild.typeBuilds.get(n4);
|
|
((NTypeInfo)object3).id = this.typeBuilds.size();
|
|
this.typeBuilds.add(object2);
|
|
this.typesBySpecString.put(((NTypeInfo)object3).typeSpec.toString(), object2.info);
|
|
this.typeBuildsBySpecString.put(((NTypeInfo)object3).typeSpec.toString(), object2);
|
|
++n4;
|
|
}
|
|
Iterator iterator = moduleBuild.typesByOrdScheme.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
object3 = (String)iterator.next();
|
|
if (this.typesByOrdScheme.containsKey(object3)) {
|
|
log.warning("Multiple types registered for ordScheme \"" + (String)object3 + '\"');
|
|
continue;
|
|
}
|
|
this.typesByOrdScheme.put(object3, moduleBuild.typesByOrdScheme.get(object3));
|
|
}
|
|
iterator = moduleBuild.typesByFileExt.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
object3 = (String)iterator.next();
|
|
object2 = (NTypeInfo)this.typesByFileExt.get(object3);
|
|
object = (Object[])moduleBuild.typesByFileExt.get(object3);
|
|
if (object2 != null) {
|
|
log.warning("Duplicate files for ext \"" + (String)object3 + "\": " + object2 + " & " + object);
|
|
continue;
|
|
}
|
|
this.typesByFileExt.put(object3, object);
|
|
}
|
|
iterator = moduleBuild.typesByClass.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
object3 = (String)iterator.next();
|
|
object2 = (NTypeInfo)moduleBuild.typesByClass.get(object3);
|
|
object = (NTypeInfo)this.typesByClass.get(object3);
|
|
if (object != null) {
|
|
log.error("Duplicate classes " + object + " & " + object2);
|
|
continue;
|
|
}
|
|
this.typesByClass.put(object3, object2);
|
|
}
|
|
iterator = moduleBuild.defs.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
object3 = (String)iterator.next();
|
|
object2 = (String[])moduleBuild.defs.get(object3);
|
|
object = (String[])this.defs.get(object3);
|
|
if (object == null) {
|
|
this.defs.put(object3, object2);
|
|
continue;
|
|
}
|
|
this.defs.put(object3, (String[])ArrayUtil.add(object, object2));
|
|
}
|
|
iterator = moduleBuild.lexicons.keySet().iterator();
|
|
while (iterator.hasNext()) {
|
|
object3 = (String)iterator.next();
|
|
object2 = (LexiconInfo)moduleBuild.lexicons.get(object3);
|
|
if (object2 == null) continue;
|
|
this.lexicons.put(object3, object2);
|
|
}
|
|
this.adapterBuilds.addAll(moduleBuild.adapterBuilds);
|
|
++n3;
|
|
}
|
|
}
|
|
|
|
private final void resolveSuperAndInterfaces() {
|
|
int n = this.typeBuilds.size();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
TypeBuild typeBuild = (TypeBuild)this.typeBuilds.get(n2);
|
|
try {
|
|
this.resolveSuperAndInterfaces(typeBuild);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot resolve type \"" + typeBuild + '\"', throwable);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
private final void resolveSuperAndInterfaces(TypeBuild typeBuild) throws Exception {
|
|
boolean bl = typeBuild.info.isInterface();
|
|
if (!bl && typeBuild.superClass != null) {
|
|
typeBuild.info.superType = (NTypeInfo)this.typesByClass.get(typeBuild.superClass);
|
|
if (typeBuild.info.superType == null && !typeBuild.info.className.equals("javax.baja.sys.BObject")) {
|
|
log.error("Missing super type \"" + typeBuild.superClass + "\" for \"" + typeBuild + '\"');
|
|
}
|
|
}
|
|
ArrayList<NTypeInfo> arrayList = null;
|
|
if (typeBuild.interfaceClasses != null) {
|
|
int n = 0;
|
|
while (n < typeBuild.interfaceClasses.length) {
|
|
String string = typeBuild.interfaceClasses[n];
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesByClass.get(string);
|
|
if (nTypeInfo == null) {
|
|
int n2 = string.lastIndexOf(36);
|
|
if (n2 < 0) {
|
|
n2 = string.lastIndexOf(46);
|
|
}
|
|
if (n2 > 0 && n2 < string.length() - 3 && string.charAt(n2 + 1) == 'B' && string.charAt(n2 + 2) == 'I') {
|
|
log.error("Missing interface type \"" + string + "\" for \"" + typeBuild + '\"');
|
|
}
|
|
} else {
|
|
if (arrayList == null) {
|
|
arrayList = new ArrayList<NTypeInfo>();
|
|
}
|
|
arrayList.add(nTypeInfo);
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
if (arrayList != null) {
|
|
typeBuild.info.interfaces = arrayList.toArray(new NTypeInfo[arrayList.size()]);
|
|
}
|
|
}
|
|
|
|
private final void resolveIsTypes() {
|
|
int n = this.typeBuilds.size();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
TypeBuild typeBuild = (TypeBuild)this.typeBuilds.get(n2);
|
|
try {
|
|
this.resolveIsTypes(typeBuild);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot resolve type \"" + typeBuild + '\"', throwable);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
private final void resolveIsTypes(TypeBuild typeBuild) throws Exception {
|
|
IsMap isMap = new IsMap();
|
|
NTypeInfo nTypeInfo = typeBuild.info;
|
|
while (nTypeInfo != null) {
|
|
isMap.add(nTypeInfo);
|
|
nTypeInfo = nTypeInfo.superType;
|
|
}
|
|
nTypeInfo = typeBuild.info;
|
|
while (nTypeInfo != null) {
|
|
this.mapInterfaces(isMap, nTypeInfo);
|
|
nTypeInfo = nTypeInfo.superType;
|
|
}
|
|
typeBuild.info.is = isMap.toArray();
|
|
}
|
|
|
|
private final void mapInterfaces(IsMap isMap, NTypeInfo nTypeInfo) {
|
|
if (nTypeInfo.isInterface()) {
|
|
isMap.add(nTypeInfo);
|
|
}
|
|
int n = 0;
|
|
while (n < nTypeInfo.interfaces.length) {
|
|
this.mapInterfaces(isMap, nTypeInfo.interfaces[n]);
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final void resolveAdapters() {
|
|
int n = this.adapterBuilds.size();
|
|
ArrayList<AdapterBuild> arrayList = new ArrayList<AdapterBuild>(n);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
AdapterBuild adapterBuild = (AdapterBuild)this.adapterBuilds.get(n2);
|
|
try {
|
|
if (this.resolveAdapter(adapterBuild)) {
|
|
arrayList.add(adapterBuild);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot resolver adapter \"" + adapterBuild.info.type + '\"', throwable);
|
|
}
|
|
++n2;
|
|
}
|
|
this.adapterBuilds = arrayList;
|
|
}
|
|
|
|
private final boolean resolveAdapter(AdapterBuild adapterBuild) {
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesBySpecString.get(adapterBuild.fromSpec);
|
|
if (nTypeInfo == null) {
|
|
log.error("Cannot find from type \"" + adapterBuild.fromSpec + "\" for \"" + adapterBuild.info.type + '\"');
|
|
return false;
|
|
}
|
|
adapterBuild.info.from = nTypeInfo;
|
|
nTypeInfo = (NTypeInfo)this.typesBySpecString.get(adapterBuild.toSpec);
|
|
if (nTypeInfo == null) {
|
|
log.error("Cannot find to type \"" + adapterBuild.toSpec + "\" for \"" + adapterBuild.info.type + '\"');
|
|
return false;
|
|
}
|
|
adapterBuild.info.to = nTypeInfo;
|
|
return true;
|
|
}
|
|
|
|
private final void agentize() {
|
|
this.agentsToTarget();
|
|
this.agentsToArray();
|
|
}
|
|
|
|
private final void agentsToTarget() {
|
|
int n = this.typeBuilds.size();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
TypeBuild typeBuild = (TypeBuild)this.typeBuilds.get(n2);
|
|
try {
|
|
this.agentToTarget(typeBuild);
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot agentize \"" + typeBuild + '\"', throwable);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
private final void agentToTarget(TypeBuild typeBuild) throws Exception {
|
|
ArrayList arrayList = typeBuild.agentsOn;
|
|
if (arrayList == null) {
|
|
return;
|
|
}
|
|
int n = 0;
|
|
while (n < arrayList.size()) {
|
|
String string = (String)arrayList.get(n);
|
|
NTypeInfo nTypeInfo = (NTypeInfo)this.typesBySpecString.get(string);
|
|
if (nTypeInfo == null) {
|
|
log.error("Cannot find agent target type \"" + string + "\" for \"" + typeBuild + '\"');
|
|
} else {
|
|
TypeBuild typeBuild2 = (TypeBuild)this.typeBuildsBySpecString.get(string);
|
|
if (typeBuild2 == null) {
|
|
typeBuild.moduleBuild.addAgent(typeBuild.info, nTypeInfo);
|
|
} else {
|
|
typeBuild2.addAgent(typeBuild.info);
|
|
}
|
|
}
|
|
++n;
|
|
}
|
|
}
|
|
|
|
private final void agentsToArray() {
|
|
int n = this.typeBuilds.size();
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
TypeBuild typeBuild = (TypeBuild)this.typeBuilds.get(n2);
|
|
try {
|
|
if (typeBuild.agentsList != null && typeBuild.agentsList.size() > 0) {
|
|
typeBuild.info.agents = typeBuild.agentsList.toArray(new NTypeInfo[typeBuild.agentsList.size()]);
|
|
}
|
|
}
|
|
catch (Throwable throwable) {
|
|
log.error("Cannot map agent to array \"" + typeBuild + '\"', throwable);
|
|
}
|
|
++n2;
|
|
}
|
|
}
|
|
|
|
private final void write(NRegistry nRegistry) throws Exception {
|
|
nRegistry.dir().mkdirs();
|
|
this.writeChecksum(nRegistry);
|
|
this.writeDatabase(nRegistry);
|
|
}
|
|
|
|
private final void writeChecksum(NRegistry nRegistry) throws Exception {
|
|
int n = this.moduleBuilds.length;
|
|
HashMap<String, RegistryChecksum.ModuleSnapshot> hashMap = new HashMap<String, RegistryChecksum.ModuleSnapshot>(n * 3);
|
|
int n2 = 0;
|
|
while (n2 < n) {
|
|
hashMap.put(this.moduleBuilds[n2].snapshot.name, this.moduleBuilds[n2].snapshot);
|
|
++n2;
|
|
}
|
|
RegistryChecksum registryChecksum = new RegistryChecksum();
|
|
registryChecksum.modules = hashMap;
|
|
registryChecksum.write(nRegistry.chkFile());
|
|
}
|
|
|
|
private final void writeDatabase(NRegistry nRegistry) throws Exception {
|
|
RegistryDatabase registryDatabase = new RegistryDatabase();
|
|
registryDatabase.modules = this.sortModules();
|
|
registryDatabase.modulesByName = new HashMap(registryDatabase.modules.length * 2);
|
|
int n = 0;
|
|
while (n < registryDatabase.modules.length) {
|
|
registryDatabase.modulesByName.put(registryDatabase.modules[n].moduleName, registryDatabase.modules[n]);
|
|
++n;
|
|
}
|
|
registryDatabase.types = new NTypeInfo[this.typeBuilds.size()];
|
|
n = 0;
|
|
while (n < this.typeBuilds.size()) {
|
|
registryDatabase.types[n] = ((TypeBuild)this.typeBuilds.get((int)n)).info;
|
|
++n;
|
|
}
|
|
registryDatabase.typesBySpec = this.typesBySpecString;
|
|
registryDatabase.defs = this.defs;
|
|
registryDatabase.fileExts = this.sortFileExts();
|
|
registryDatabase.typesByFileExt = this.typesByFileExt;
|
|
registryDatabase.ordSchemes = this.sortOrdSchemes();
|
|
registryDatabase.typesByOrdScheme = this.typesByOrdScheme;
|
|
registryDatabase.lexicons = this.lexicons;
|
|
registryDatabase.adapters = new NAdapterInfo[this.adapterBuilds.size()];
|
|
n = 0;
|
|
while (n < this.adapterBuilds.size()) {
|
|
registryDatabase.adapters[n] = ((AdapterBuild)this.adapterBuilds.get((int)n)).info;
|
|
++n;
|
|
}
|
|
registryDatabase.write(nRegistry.dbFile());
|
|
}
|
|
|
|
private final NModuleInfo[] sortModules() {
|
|
Object[] objectArray = new String[this.moduleBuilds.length];
|
|
Object[] objectArray2 = new NModuleInfo[this.moduleBuilds.length];
|
|
int n = 0;
|
|
while (n < objectArray.length) {
|
|
objectArray[n] = this.moduleBuilds[n].info.moduleName;
|
|
objectArray2[n] = this.moduleBuilds[n].info;
|
|
++n;
|
|
}
|
|
SortUtil.sort((Object[])objectArray, (Object[])objectArray2);
|
|
return objectArray2;
|
|
}
|
|
|
|
private final String[] sortFileExts() {
|
|
Object[] objectArray = this.typesByFileExt.keySet().toArray(new String[this.typesByFileExt.size()]);
|
|
SortUtil.sort((Object[])objectArray);
|
|
return objectArray;
|
|
}
|
|
|
|
private final String[] sortOrdSchemes() {
|
|
Object[] objectArray = this.typesByOrdScheme.keySet().toArray(new String[this.typesByOrdScheme.size()]);
|
|
SortUtil.sort((Object[])objectArray);
|
|
return objectArray;
|
|
}
|
|
|
|
static /* synthetic */ Class class(String string, boolean bl) {
|
|
try {
|
|
Class<?> clazz = Class.forName(string);
|
|
if (!bl) {
|
|
clazz = clazz.getComponentType();
|
|
}
|
|
return clazz;
|
|
}
|
|
catch (ClassNotFoundException classNotFoundException) {
|
|
throw new NoClassDefFoundError(classNotFoundException.getMessage());
|
|
}
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.typeBuilds = new ArrayList();
|
|
this.adapterBuilds = new ArrayList();
|
|
this.typeBuildsBySpecString = new HashMap();
|
|
this.typesByFileExt = new HashMap();
|
|
this.typesByOrdScheme = new HashMap();
|
|
this.typesBySpecString = new HashMap();
|
|
this.typesByClass = new HashMap();
|
|
this.defs = new HashMap();
|
|
this.lexicons = new HashMap();
|
|
}
|
|
|
|
private Builder() {
|
|
this.this();
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
static class ModuleBuild {
|
|
NModuleInfo info;
|
|
RegistryChecksum.ModuleSnapshot snapshot;
|
|
HashMap defs;
|
|
HashMap lexicons;
|
|
ArrayList typeBuilds;
|
|
HashMap typesByOrdScheme;
|
|
HashMap typesBySpec;
|
|
HashMap typesByClass;
|
|
HashMap typesByFileExt;
|
|
ArrayList adapterBuilds;
|
|
HashMap agentTypesByTargetSpec;
|
|
|
|
public void addAgent(NTypeInfo nTypeInfo, NTypeInfo nTypeInfo2) {
|
|
Object[] objectArray = (NTypeInfo[])this.agentTypesByTargetSpec.get(nTypeInfo2.typeSpec.toString());
|
|
objectArray = objectArray == null ? new NTypeInfo[]{nTypeInfo} : (NTypeInfo[])ArrayUtil.addOne(objectArray, nTypeInfo);
|
|
this.agentTypesByTargetSpec.put(nTypeInfo2.typeSpec.toString(), objectArray);
|
|
}
|
|
|
|
public String toString() {
|
|
return this.info.toString();
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.defs = new HashMap();
|
|
this.lexicons = new HashMap();
|
|
this.typeBuilds = new ArrayList();
|
|
this.typesByOrdScheme = new HashMap();
|
|
this.typesBySpec = new HashMap();
|
|
this.typesByClass = new HashMap();
|
|
this.typesByFileExt = new HashMap();
|
|
this.adapterBuilds = new ArrayList();
|
|
this.agentTypesByTargetSpec = new HashMap();
|
|
}
|
|
|
|
ModuleBuild() {
|
|
this.this();
|
|
this.info = new NModuleInfo(-1);
|
|
this.snapshot = new RegistryChecksum.ModuleSnapshot();
|
|
}
|
|
}
|
|
|
|
static class AdapterBuild {
|
|
TypeBuild typeBuild;
|
|
NAdapterInfo info;
|
|
String fromSpec;
|
|
String toSpec;
|
|
|
|
public String toString() {
|
|
return this.info.toString();
|
|
}
|
|
|
|
AdapterBuild(TypeBuild typeBuild) {
|
|
this.typeBuild = typeBuild;
|
|
this.info = new NAdapterInfo();
|
|
this.info.type = typeBuild.info;
|
|
}
|
|
}
|
|
|
|
static class TypeBuild {
|
|
ModuleBuild moduleBuild;
|
|
NTypeInfo info;
|
|
String superClass;
|
|
String[] interfaceClasses;
|
|
String ordScheme;
|
|
ArrayList agentsOn;
|
|
ArrayList agentsList;
|
|
|
|
public void addAgentOn(String string) {
|
|
if (this.agentsOn == null) {
|
|
this.agentsOn = new ArrayList();
|
|
}
|
|
this.agentsOn.add(string);
|
|
}
|
|
|
|
public void addAgent(NTypeInfo nTypeInfo) {
|
|
if (this.agentsList == null) {
|
|
this.agentsList = new ArrayList();
|
|
}
|
|
this.agentsList.add(nTypeInfo);
|
|
}
|
|
|
|
public String toString() {
|
|
return this.info.toString();
|
|
}
|
|
|
|
TypeBuild(ModuleBuild moduleBuild, BTypeSpec bTypeSpec) {
|
|
this.moduleBuild = moduleBuild;
|
|
this.info = new NTypeInfo(-1, bTypeSpec);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Illegal identifiers - consider using --renameillegalidents true
|
|
*/
|
|
static class IsMap {
|
|
private ArrayList list;
|
|
private IntHashMap byId;
|
|
|
|
void add(NTypeInfo nTypeInfo) {
|
|
if (this.byId.get(nTypeInfo.id) != null) {
|
|
return;
|
|
}
|
|
this.list.add(nTypeInfo);
|
|
this.byId.put(nTypeInfo.id, (Object)nTypeInfo);
|
|
}
|
|
|
|
NTypeInfo[] toArray() {
|
|
return this.list.toArray(new NTypeInfo[this.list.size()]);
|
|
}
|
|
|
|
private final /* synthetic */ void this() {
|
|
this.list = new ArrayList();
|
|
this.byId = new IntHashMap();
|
|
}
|
|
|
|
IsMap() {
|
|
this.this();
|
|
}
|
|
}
|
|
}
|
|
|