emscripten/src/shell.js at universal-python · JavaScriptIOT/emscripten · GitHub

History

229 lines (202 loc) · 7.89 KB

Raw

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

166

167

168

169

170

171

172

173

174

175

176

177

178

179

180

181

182

183

184

185

186

187

188

189

190

191

192

193

194

195

196

197

198

199

200

201

202

203

204

205

206

207

208

209

210

211

212

213

214

215

216

217

218

219

220

221

222

223

224

225

226

227

228

229

// The Module object: Our interface to the outside world. We import

// and export values on it, and do the work to get that through

// closure compiler if necessary. There are various ways Module can be used:

// 1. Not defined. We create it here

// 2. A function parameter, function(Module) { ..generated code.. }

// 3. pre-run appended it, var Module = {}; ..generated code..

// 4. External script tag defines var Module.

// We need to do an eval in order to handle the closure compiler

// case, where this code here is minified but Module was defined

// elsewhere (e.g. case 4 above). We also need to check if Module

// already exists (e.g. case 3 above).

// Note that if you want to run closure, and also to use Module

// after the generated code, you will need to define var Module = {};

// before the code. Then that object will be used in the code, and you

// can continue to use Module afterwards as well.

var Module;

#if USE_CLOSURE_COMPILER

if (!Module) Module = eval('(function() { try { return {{{ EXPORT_NAME }}} || {} } catch(e) { return {} } })()');

#else

if (!Module) Module = (typeof {{{ EXPORT_NAME }}} !== 'undefined' ? {{{ EXPORT_NAME }}} : null) || {};

#endif

// Sometimes an existing Module object exists with properties

// meant to overwrite the default module functionality. Here

// we collect those properties and reapply _after_ we configure

// the current environment's defaults to avoid having to be so

// defensive during initialization.

var moduleOverrides = {};

for (var key in Module) {

if (Module.hasOwnProperty(key)) {

moduleOverrides[key] = Module[key];

}

// The environment setup code below is customized to use Module.

// *** Environment setup code ***

var ENVIRONMENT_IS_WEB = typeof window === 'object';

// Three configurations we can be running in:

// 1) We could be the application main() thread running in the main JS UI thread. (ENVIRONMENT_IS_WORKER == false and ENVIRONMENT_IS_PTHREAD == false)

// 2) We could be the application main() thread proxied to worker. (with Emscripten -s PROXY_TO_WORKER=1) (ENVIRONMENT_IS_WORKER == true, ENVIRONMENT_IS_PTHREAD == false)

// 3) We could be an application pthread running in a worker. (ENVIRONMENT_IS_WORKER == true and ENVIRONMENT_IS_PTHREAD == true)

var ENVIRONMENT_IS_WORKER = typeof importScripts === 'function';

var ENVIRONMENT_IS_NODE = typeof process === 'object' && typeof require === 'function' && !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_WORKER;

#if USE_PTHREADS

var ENVIRONMENT_IS_PTHREAD;

if (!ENVIRONMENT_IS_PTHREAD) ENVIRONMENT_IS_PTHREAD = false; // ENVIRONMENT_IS_PTHREAD=true will have been preset in pthread-main.js. Make it false in the main runtime thread.

var PthreadWorkerInit; // Collects together variables that are needed at initialization time for the web workers that host pthreads.

if (!ENVIRONMENT_IS_PTHREAD) PthreadWorkerInit = {};

var currentScriptUrl = ENVIRONMENT_IS_WORKER ? undefined : document.currentScript.src;

#endif

var ENVIRONMENT_IS_SHELL = !ENVIRONMENT_IS_WEB && !ENVIRONMENT_IS_NODE && !ENVIRONMENT_IS_WORKER;

if (ENVIRONMENT_IS_NODE) {

// Expose functionality in the same simple way that the shells work

// Note that we pollute the global namespace here, otherwise we break in node

if (!Module['print']) Module['print'] = function print(x) {

process['stdout'].write(x + '\n');

};

if (!Module['printErr']) Module['printErr'] = function printErr(x) {

process['stderr'].write(x + '\n');

};

var nodeFS = require('fs');

var nodePath = require('path');

Module['read'] = function read(filename, binary) {

filename = nodePath['normalize'](filename);

var ret = nodeFS['readFileSync'](filename);

// The path is absolute if the normalized version is the same as the resolved.

if (!ret && filename != nodePath['resolve'](filename)) {

filename = path.join(__dirname, '..', 'src', filename);

ret = nodeFS['readFileSync'](filename);

}

if (ret && !binary) ret = ret.toString();

return ret;

};

Module['readBinary'] = function readBinary(filename) {

var ret = Module['read'](filename, true);

if (!ret.buffer) {

ret = new Uint8Array(ret);

}

assert(ret.buffer);

return ret;

};

Module['load'] = function load(f) {

globalEval(read(f));

};

if (!Module['thisProgram']) {

if (process['argv'].length > 1) {

Module['thisProgram'] = process['argv'][1].replace(/\\/g, '/');

} else {

Module['thisProgram'] = 'unknown-program';

}

Module['arguments'] = process['argv'].slice(2);

if (typeof module !== 'undefined') {

module['exports'] = Module;

}

process['on']('uncaughtException', function(ex) {

// suppress ExitStatus exceptions from showing an error

if (!(ex instanceof ExitStatus)) {

throw ex;

}

});

Module['inspect'] = function () { return '[Emscripten Module object]'; };

}

else if (ENVIRONMENT_IS_SHELL) {

if (!Module['print']) Module['print'] = print;

if (typeof printErr != 'undefined') Module['printErr'] = printErr; // not present in v8 or older sm

if (typeof read != 'undefined') {

Module['read'] = read;

} else {

Module['read'] = function read() { throw 'no read() available (jsc?)' };

}

Module['readBinary'] = function readBinary(f) {

if (typeof readbuffer === 'function') {

return new Uint8Array(readbuffer(f));

}

var data = read(f, 'binary');

assert(typeof data === 'object');

return data;

};

if (typeof scriptArgs != 'undefined') {

Module['arguments'] = scriptArgs;

} else if (typeof arguments != 'undefined') {

Module['arguments'] = arguments;

}

#if USE_CLOSURE_COMPILER

eval("if (typeof gc === 'function' && gc.toString().indexOf('[native code]') > 0) var gc = undefined"); // wipe out the SpiderMonkey shell 'gc' function, which can confuse closure (uses it as a minified name, and it is then initted to a non-falsey value unexpectedly)

#endif

}

else if (ENVIRONMENT_IS_WEB || ENVIRONMENT_IS_WORKER) {

Module['read'] = function read(url) {

var xhr = new XMLHttpRequest();

xhr.open('GET', url, false);

xhr.send(null);

return xhr.responseText;

};

if (typeof arguments != 'undefined') {

Module['arguments'] = arguments;

}

if (typeof console !== 'undefined') {

if (!Module['print']) Module['print'] = function print(x) {

console.log(x);

};

if (!Module['printErr']) Module['printErr'] = function printErr(x) {

console.log(x);

};

} else {

// Probably a worker, and without console.log. We can do very little here...

var TRY_USE_DUMP = false;

if (!Module['print']) Module['print'] = (TRY_USE_DUMP && (typeof(dump) !== "undefined") ? (function(x) {

dump(x);

}) : (function(x) {

// self.postMessage(x); // enable this if you want stdout to be sent as messages

}));

}

if (ENVIRONMENT_IS_WORKER) {

Module['load'] = importScripts;

}

if (typeof Module['setWindowTitle'] === 'undefined') {

Module['setWindowTitle'] = function(title) { document.title = title };

}

else {

// Unreachable because SHELL is dependant on the others

throw 'Unknown runtime environment. Where are we?';

}

function globalEval(x) {

#if NO_DYNAMIC_EXECUTION == 0

eval.call(null, x);

#else

throw 'NO_DYNAMIC_EXECUTION was set, cannot eval';

#endif

}

if (!Module['load'] && Module['read']) {

Module['load'] = function load(f) {

globalEval(Module['read'](f));

};

}

if (!Module['print']) {

Module['print'] = function(){};

}

if (!Module['printErr']) {

Module['printErr'] = Module['print'];

}

if (!Module['arguments']) {

Module['arguments'] = [];

}

if (!Module['thisProgram']) {

Module['thisProgram'] = './this.program';

}

// *** Environment setup code ***

// Closure helpers

Module.print = Module['print'];

Module.printErr = Module['printErr'];

// Callbacks

Module['preRun'] = [];

Module['postRun'] = [];

// Merge back in the overrides

for (var key in moduleOverrides) {

if (moduleOverrides.hasOwnProperty(key)) {

Module[key] = moduleOverrides[key];

}

// {{MODULE_ADDITIONS}}

emscripten/src/shell.js at universal-python · JavaScriptIOT/emscripten · GitHub

Uh oh!

Expand file tree

Breadcrumbs

shell.js

Latest commit

History

Breadcrumbs

shell.js

File metadata and controls