+let JSMLoader = {
+ SANDBOX: Cu.nukeSandbox,
+
+ get addon() addon,
+
+ currentModule: null,
+
+ factories: [],
+
+ get name() name,
+
+ get module() moduleName,
+
+ globals: {},
+ modules: {},
+
+ times: {
+ all: 0,
+ add: function add(major, minor, delta) {
+ this.all += delta;
+
+ this[major] = (this[major] || 0) + delta;
+ if (minor) {
+ minor = ":" + minor;
+ this[minor] = (this[minor] || 0) + delta;
+ this[major + minor] = (this[major + minor] || 0) + delta;
+ }
+ },
+ clear: function clear() {
+ for (let key in this)
+ if (typeof this[key] !== "number")
+ delete this[key];
+ }
+ },
+
+ getTarget: function getTarget(url) {
+ let uri = Services.io.newURI(url, null, null);
+ if (uri.schemeIs("resource"))
+ return resourceProto.resolveURI(uri);
+
+ let chan = Services.io.newChannelFromURI(uri);
+ try { chan.cancel(Cr.NS_BINDING_ABORTED); } catch (e) {}
+ return chan.name;
+ },
+
+ _atexit: [],
+
+ atexit: function atexit(arg, self) {
+ if (typeof arg !== "string")
+ this._atexit.push(arguments);
+ else
+ for each (let [fn, self] in this._atexit)
+ try {
+ fn.call(self, arg);
+ }
+ catch (e) {
+ reportError(e);
+ }
+ },
+
+ _load: function _load(name, target) {
+ let urls = [name];
+ if (name.indexOf(":") === -1)
+ urls = this.config["module-paths"].map(path => path + name + ".jsm");
+
+ for each (let url in urls)
+ try {
+ var uri = this.getTarget(url);
+ if (uri in this.globals)
+ return this.modules[name] = this.globals[uri];
+
+ this.globals[uri] = this.modules[name];
+ bootstrap_jsm.loadSubScript(url, this.modules[name], "UTF-8");
+ return;
+ }
+ catch (e) {
+ debug("Loading " + name + ": " + e);
+ delete this.globals[uri];
+
+ if (typeof e != "string")
+ throw e;
+ }
+
+ throw Error("No such module: " + name);
+ },
+
+ load: function load(name, target) {
+ if (!this.modules.hasOwnProperty(name)) {
+ this.modules[name] = this.modules.base ? bootstrap.create(this.modules.base)
+ : bootstrap.import({ JSMLoader: this, module: global.module });
+
+ let currentModule = this.currentModule;
+ this.currentModule = this.modules[name];
+
+ try {
+ this._load(name, this.modules[name]);
+ }
+ catch (e) {
+ delete this.modules[name];
+ reportError(e);
+ throw e;
+ }
+ finally {
+ this.currentModule = currentModule;
+ }
+ }
+
+ let module = this.modules[name];
+ if (target)
+ for each (let symbol in module.EXPORTED_SYMBOLS)
+ try {
+ Object.defineProperty(target, symbol, {
+ configurable: true,
+ enumerable: true,
+ writable: true,
+ value: module[symbol]
+ });
+ }
+ catch (e) {
+ target[symbol] = module[symbol];
+ }
+
+ return module;
+ },
+
+ // Cuts down on stupid, fscking url mangling.
+ get loadSubScript() bootstrap_jsm.loadSubScript,
+
+ cleanup: function cleanup() {
+ for (let factory of this.factories.splice(0))
+ manager.unregisterFactory(factory.classID, factory);
+ },
+
+ Factory: function Factory(class_) ({
+ __proto__: class_.prototype,
+
+ createInstance: function (outer, iid) {
+ try {
+ if (outer != null)
+ throw Cr.NS_ERROR_NO_AGGREGATION;
+ if (!class_.instance)
+ class_.instance = new class_();
+ return class_.instance.QueryInterface(iid);
+ }
+ catch (e) {
+ Cu.reportError(e);
+ throw e;
+ }
+ }
+ }),
+
+ registerFactory: function registerFactory(factory) {
+ manager.registerFactory(factory.classID,
+ String(factory.classID),
+ factory.contractID,
+ factory);
+ this.factories.push(factory);
+ }
+};
+
+function init() {
+ debug("bootstrap: init");
+
+ let manifest = JSON.parse(httpGet(getURI("config.json"))
+ .responseText);
+
+ if (!manifest.categories)
+ manifest.categories = [];
+
+ for (let [classID, { contract, path, categories }] of Iterator(manifest.components || {})) {
+ components[classID] = new FactoryProxy(getURI(path).spec, classID, contract);
+ if (categories)
+ for (let [category, id] in Iterator(categories))
+ manifest.categories.push([category, id, contract]);
+ }
+
+ for (let [category, id, value] of manifest.categories)
+ categoryManager.addCategoryEntry(category, id, value,
+ false, true);
+
+ for (let [pkg, path] in Iterator(manifest.resources || {})) {
+ moduleName = moduleName || pkg;
+ resourceProto.setSubstitution(pkg, getURI(path));
+ }
+
+ JSMLoader.config = manifest;
+
+ bootstrap_jsm = module(BOOTSTRAP);
+ if (!JSMLoader.SANDBOX)
+ bootstrap = bootstrap_jsm;
+ else {
+ bootstrap = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"].createInstance(),
+ { sandboxName: BOOTSTRAP });
+ Services.scriptloader.loadSubScript(BOOTSTRAP, bootstrap);
+ }
+ bootstrap.require = JSMLoader.load("base").require;
+
+ let pref = "extensions.dactyl.cacheFlushCheck";
+ let val = addon.version;
+ if (!Services.prefs.prefHasUserValue(pref) || Services.prefs.getCharPref(pref) != val) {
+ var cacheFlush = true;
+ Services.prefs.setCharPref(pref, val);
+ }
+
+ Services.obs.notifyObservers(null, "dactyl-rehash", null);
+
+ JSMLoader.bootstrap = global;
+
+ JSMLoader.load("config", global);
+ JSMLoader.load("main", global);
+
+ JSMLoader.cacheFlush = cacheFlush;
+ JSMLoader.load("base", global);
+
+ if (!(BOOTSTRAP_CONTRACT in Cc)) {
+ // Use Sandbox to prevent closures over this scope
+ let sandbox = Cu.Sandbox(Cc["@mozilla.org/systemprincipal;1"].createInstance());
+ let factory = Cu.evalInSandbox("({ createInstance: function () this })", sandbox);
+
+ factory.classID = Components.ID("{f541c8b0-fe26-4621-a30b-e77d21721fb5}");
+ factory.contractID = BOOTSTRAP_CONTRACT;
+ factory.QueryInterface = XPCOMUtils.generateQI([Ci.nsIFactory]);
+ factory.wrappedJSObject = factory;
+
+ manager.registerFactory(factory.classID, String(factory.classID),
+ BOOTSTRAP_CONTRACT, factory);
+ }
+
+ Cc[BOOTSTRAP_CONTRACT].getService().wrappedJSObject.loader = !Cu.unload && JSMLoader;
+
+ for each (let component in components)
+ component.register();
+
+ updateVersion();
+
+ if (addon !== addonData)
+ require("main", global);
+}
+
+/**
+ * Performs necessary migrations after a version change.
+ */