├── Readme.md ├── bin └── storm ├── examples ├── check_output.js ├── expression.js ├── expression.out.js ├── groups.js ├── groups.out.js ├── if_block.js ├── loop_parallel.js ├── loop_parallel.out.js ├── loop_serial.js ├── loop_serial.out.js ├── mongodb.js ├── parallel.js ├── parallel.out.js ├── serial.js ├── serial.out.js ├── steps.js ├── steps.out.js ├── storm_vs_step.js ├── stuffs.js └── test.js ├── google-code-prettify ├── lang-apollo.js ├── lang-clj.js ├── lang-css.js ├── lang-go.js ├── lang-hs.js ├── lang-lisp.js ├── lang-lua.js ├── lang-ml.js ├── lang-n.js ├── lang-proto.js ├── lang-scala.js ├── lang-sql.js ├── lang-tex.js ├── lang-vb.js ├── lang-vhdl.js ├── lang-wiki.js ├── lang-xq.js ├── lang-yaml.js ├── prettify.css └── prettify.js ├── lib ├── command.js ├── index.js ├── patterns.js └── storm.js ├── package.json └── show.html /Readme.md: -------------------------------------------------------------------------------- 1 | stormjs, intelligent compiler for nodejs 2 | ======== 3 | 4 | Compile js to js 5 | 6 | Serial 7 | ---- 8 | 9 | var a = foo(_); 10 | var b = foo(a, _); 11 | 12 | will compile to 13 | 14 | foo(function(err, _r1){ 15 | if(err) return cb(err); 16 | var a = _r1; 17 | foo(a, function(err, _r2){ 18 | if(err) return cb(err); 19 | var b = _r2; 20 | }); 21 | }); 22 | 23 | Parallel 24 | ---- 25 | 26 | var a = foo(_); 27 | var b = foo(_); 28 | 29 | will compile to 30 | 31 | foo(function(err, _r1){ 32 | if(err) return cb(err); 33 | var a = r1; 34 | }); 35 | 36 | foo(function(err, _r2){ 37 | if(err) return cb(err); 38 | var b = r2; 39 | }); 40 | 41 | Parallel then callback 42 | ---- 43 | 44 | var a = foo(_); 45 | var b = foo(_); 46 | var d = foo(a, b, _); 47 | 48 | will compile to 49 | 50 | var a, b, c; 51 | 52 | var count = 2; 53 | 54 | function update() { 55 | if (--count === 0) { 56 | foo(a, b, function(_err, _r3) { 57 | if (_err) return cb(_err); 58 | c = _r3; 59 | }); 60 | } 61 | } 62 | 63 | foo(function(_err, _r1) { 64 | if (_err) return cb(_err); 65 | a = _r1; 66 | update(); 67 | }); 68 | 69 | foo(function(_err, _r2) { 70 | if (_err) return cb(_err); 71 | b = _r2; 72 | update(); 73 | }); 74 | 75 | Parallel then grouped callback 76 | ---- 77 | 78 | var a = foo(_); 79 | var b = foo(_); 80 | var c = foo(_); 81 | var d = foo(a, b, _); 82 | var e = foo(a, c, _); 83 | var f = foo(b, c, _); 84 | 85 | will compile to 86 | 87 | var a, b, c, d, e, f; 88 | 89 | var _done = 0, triggers = [ function(_index) { 90 | if (3 === (_done & 3)) { 91 | triggers.splice(_index, 1); 92 | foo(a, b, function(_err, _r4) { 93 | if (_err) return cb(_err); 94 | d = _r4; 95 | }); 96 | } 97 | }, function(_index) { 98 | if (5 === (_done & 5)) { 99 | triggers.splice(_index, 1); 100 | foo(a, c, function(_err, _r5) { 101 | if (_err) return cb(_err); 102 | e = _r5; 103 | }); 104 | } 105 | }, function(_index) { 106 | if (6 === (_done & 6)) { 107 | triggers.splice(_index, 1); 108 | foo(b, c, function(_err, _r6) { 109 | if (_err) return cb(_err); 110 | f = _r6; 111 | }); 112 | } 113 | } ]; 114 | 115 | function trigger() { 116 | for (var i = triggers.length - 1; i >= 0; i--) { 117 | triggers[i](); 118 | } 119 | } 120 | 121 | foo(function(_err, _r1) { 122 | if (_err) return cb(_err); 123 | _done |= 1; 124 | process.nextTick(trigger); 125 | a = _r1; 126 | }); 127 | 128 | foo(function(_err, _r2) { 129 | if (_err) return cb(_err); 130 | _done |= 2; 131 | process.nextTick(trigger); 132 | b = _r2; 133 | }); 134 | 135 | foo(function(_err, _r3) { 136 | if (_err) return cb(_err); 137 | _done |= 4; 138 | process.nextTick(trigger); 139 | c = _r3; 140 | }); 141 | 142 | Install 143 | ==== 144 | 145 | npm install storm 146 | 147 | Usage 148 | ==== 149 | 150 | storm filename 151 | 152 | Run examples 153 | ==== 154 | 155 | node examples/check_output.js [-o] [-e] [-nt] [filename...] 156 | 157 | -o overwrite .out.js 158 | -e execute .out.js 159 | -nt no test compile code 160 | 161 | to execute examples/groups.js 162 | 163 | node examples/check_output.js -e groups 164 | 165 | about the foo, foo will log arguments passed in and callback the arguments 166 | after random ms. 167 | -------------------------------------------------------------------------------- /bin/storm: -------------------------------------------------------------------------------- 1 | #! /usr/bin/env node 2 | 3 | require('../lib/command').run(process.argv.slice(2)); 4 | -------------------------------------------------------------------------------- /examples/check_output.js: -------------------------------------------------------------------------------- 1 | // `node check_output.js -o` to overwrite .out.js 2 | // -e to execute code 3 | // no arguments to check output 4 | var fs = require('fs'), 5 | jsp = require('uglify-js').parser, 6 | pro = require('uglify-js').uglify, 7 | storm = require('../lib/storm'), 8 | vm = require('vm'), 9 | assert = require('assert'); 10 | 11 | var args = process.argv.slice(2), arg, options = { 12 | overwrite: false, 13 | check: true, 14 | filenames: [] 15 | }; 16 | 17 | while (arg = args.shift()) { 18 | if (arg === '-o') { 19 | options.overwrite = true; 20 | options.check = false; 21 | } else if (arg === '--ast') { 22 | options.ast = true; 23 | } else if (arg === '-e') { 24 | options.execute = true; 25 | } else if (arg === '-nt') { 26 | options.check = false; 27 | } else if (arg === '-p') { 28 | options.print = true; 29 | } else { 30 | options.filenames.push(arg); 31 | } 32 | } 33 | 34 | if (options.filenames.length === 0) { 35 | options.filenames = ['groups', 'steps', 'serial', 'parallel', 'expression', 'loop_parallel', 'loop_serial']; 36 | } 37 | 38 | function make_log(filename) { 39 | var filename = filename + new Array(16 - filename.length).join(' '); 40 | return function(s) { 41 | console.log(filename + ':' + s); 42 | } 43 | } 44 | 45 | function make_foo(filename) { 46 | var filename = filename + new Array(16 - filename.length).join(' '); 47 | var log = console.log; 48 | return function() { 49 | var args = Array.prototype.slice.call(arguments, 0), 50 | cb = args.pop(), 51 | arg_name = args.toString(), 52 | tab = new Array(12 - arg_name.length).join(' '), 53 | ret = Math.floor(Math.random() * 100); 54 | 55 | console.log(filename + ':foo(' + arg_name + ')'); 56 | setTimeout(function() { 57 | console.log(filename + ':callback ' + arg_name + '#' + ret); 58 | cb(null, arg_name + '#' + ret); 59 | }, ret); 60 | }; 61 | } 62 | 63 | function testFile(filename) { 64 | filename = filename.replace(/\.js$/, ''); 65 | var code = fs.readFileSync(__dirname + '/' + filename + '.js', 'utf-8'); 66 | var target; 67 | var src_ast = jsp.parse(code); 68 | 69 | if (options.ast) { 70 | console.log(filename + ': source ast'); 71 | console.log(storm.astToStr(src_ast, '')); 72 | } 73 | 74 | if (options.print) { 75 | console.log(filename + ': source code'); 76 | console.log(code); 77 | } 78 | 79 | var target_ast = storm.stormfy(src_ast, { 80 | callback_name: 'cb', 81 | keywords: { 82 | async_mark: 'Async', 83 | callback_mark: '_' 84 | } 85 | }); 86 | 87 | if (options.ast) { 88 | console.log(filename + ': target ast'); 89 | console.log(storm.astToStr(target_ast, '')); 90 | } 91 | 92 | var target = pro.gen_code(target_ast, {beautify: true}); 93 | 94 | if (options.print) { 95 | console.log(filename + ': target code'); 96 | console.log(target); 97 | } 98 | 99 | var expect; 100 | if (options.overwrite) { 101 | fs.writeFileSync(__dirname + '/' + filename + '.out.js', target, 'utf-8'); 102 | expect = target; 103 | } else { 104 | expect = fs.readFileSync(__dirname + '/' + filename + '.out.js', 'utf-8'); 105 | } 106 | 107 | if (options.execute) { 108 | var script = vm.createScript(expect); 109 | var sandbox = { 110 | foo: make_foo(filename), 111 | console: { 112 | log: make_log(filename) 113 | }, 114 | process: process 115 | }; 116 | script.runInNewContext(sandbox); 117 | } 118 | 119 | if (options.check) { 120 | assert.equal(target.trim(), expect.trim(), 'the output is not equals expected. filename: ' + filename + '.js'); 121 | } 122 | 123 | } 124 | 125 | options.filenames.forEach(function(filename){ 126 | try{ 127 | testFile(filename); 128 | console.log(filename + ':OK'); 129 | } catch(e) { 130 | console.log(filename + ':Fail'); 131 | console.log(e.stack); 132 | } 133 | }); 134 | -------------------------------------------------------------------------------- /examples/expression.js: -------------------------------------------------------------------------------- 1 | // expression 2 | var sum = foo(foo(_) + foo(_), _); 3 | // empty async call 4 | foo(_); 5 | // empty var; 6 | var m; 7 | // multi var; 8 | var x = 0, y = 1, z; 9 | // multi var with callback; 10 | var a = foo(_), b = foo(_), c = foo(_), d; 11 | 12 | x = foo(_); 13 | x.x = foo(_); 14 | x['y']= foo(_); 15 | x['x'].y = foo(_); 16 | x.y.x = foo(_); 17 | -------------------------------------------------------------------------------- /examples/expression.out.js: -------------------------------------------------------------------------------- 1 | var sum, a, b, c, d, _1, _2, _a, _b, _c, _x_x, _x_y, _x_x_y, _x_y_x, _done = 0; 2 | 3 | var triggers = [ function(_index) { 4 | if (3 === (_done & 3)) { 5 | triggers.splice(_index, 1); 6 | foo(_1 + _2, function(_err, _sum) { 7 | if (_err) return cb(_err); 8 | sum = _sum; 9 | }); 10 | } 11 | }, function(_index) { 12 | if (28 === (_done & 28)) { 13 | triggers.splice(_index, 1); 14 | a = _a; 15 | b = _b; 16 | c = _c; 17 | } 18 | }, function(_index) { 19 | if (96 === (_done & 96)) { 20 | triggers.splice(_index, 1); 21 | x.x = _x_x; 22 | } 23 | }, function(_index) { 24 | if (224 === (_done & 224)) { 25 | triggers.splice(_index, 1); 26 | x["y"] = _x_y; 27 | } 28 | }, function(_index) { 29 | if (480 === (_done & 480)) { 30 | triggers.splice(_index, 1); 31 | x["x"].y = _x_x_y; 32 | } 33 | }, function(_index) { 34 | if (992 === (_done & 992)) { 35 | triggers.splice(_index, 1); 36 | x.y.x = _x_y_x; 37 | } 38 | } ]; 39 | 40 | function trigger(_flag) { 41 | _done |= _flag; 42 | for (var i = triggers.length - 1; i >= 0; i--) { 43 | triggers[i](i); 44 | } 45 | } 46 | 47 | foo(function(_err, __1) { 48 | if (_err) return cb(_err); 49 | _1 = __1; 50 | trigger(1); 51 | }); 52 | 53 | foo(function(_err, __2) { 54 | if (_err) return cb(_err); 55 | _2 = __2; 56 | trigger(2); 57 | }); 58 | 59 | foo(function(_err, _3) { 60 | if (_err) return cb(_err); 61 | }); 62 | 63 | var m; 64 | 65 | var x = 0, y = 1, z; 66 | 67 | foo(function(_err, __a) { 68 | if (_err) return cb(_err); 69 | _a = __a; 70 | trigger(4); 71 | }); 72 | 73 | foo(function(_err, __b) { 74 | if (_err) return cb(_err); 75 | _b = __b; 76 | trigger(8); 77 | }); 78 | 79 | foo(function(_err, __c) { 80 | if (_err) return cb(_err); 81 | _c = __c; 82 | trigger(16); 83 | }); 84 | 85 | foo(function(_err, _x) { 86 | if (_err) return cb(_err); 87 | x = _x; 88 | trigger(32); 89 | }); 90 | 91 | foo(function(_err, __x_x) { 92 | if (_err) return cb(_err); 93 | _x_x = __x_x; 94 | trigger(64); 95 | }); 96 | 97 | foo(function(_err, __x_y) { 98 | if (_err) return cb(_err); 99 | _x_y = __x_y; 100 | trigger(128); 101 | }); 102 | 103 | foo(function(_err, __x_x_y) { 104 | if (_err) return cb(_err); 105 | _x_x_y = __x_x_y; 106 | trigger(256); 107 | }); 108 | 109 | foo(function(_err, __x_y_x) { 110 | if (_err) return cb(_err); 111 | _x_y_x = __x_y_x; 112 | trigger(512); 113 | }); -------------------------------------------------------------------------------- /examples/groups.js: -------------------------------------------------------------------------------- 1 | var a = foo(_); 2 | var b = foo(_); 3 | var c = foo(_); 4 | var d = foo(a, b, _); 5 | var e = foo(a, c, _); 6 | var f = foo(b, c, _); 7 | console.log('a=' + a); 8 | console.log('b=' + b); 9 | console.log('c=' + c); 10 | console.log('d=' + d); 11 | console.log('e=' + e); 12 | console.log('f=' + f); 13 | -------------------------------------------------------------------------------- /examples/groups.out.js: -------------------------------------------------------------------------------- 1 | var a, b, c, d, e, f, _done = 0; 2 | 3 | var triggers = [ function(_index) { 4 | if (3 === (_done & 3)) { 5 | triggers.splice(_index, 1); 6 | foo(a, b, function(_err, _d) { 7 | if (_err) return cb(_err); 8 | d = _d; 9 | console.log("d=" + d); 10 | }); 11 | } 12 | }, function(_index) { 13 | if (5 === (_done & 5)) { 14 | triggers.splice(_index, 1); 15 | foo(a, c, function(_err, _e) { 16 | if (_err) return cb(_err); 17 | e = _e; 18 | console.log("e=" + e); 19 | }); 20 | } 21 | }, function(_index) { 22 | if (6 === (_done & 6)) { 23 | triggers.splice(_index, 1); 24 | foo(b, c, function(_err, _f) { 25 | if (_err) return cb(_err); 26 | f = _f; 27 | console.log("f=" + f); 28 | }); 29 | } 30 | } ]; 31 | 32 | function trigger(_flag) { 33 | _done |= _flag; 34 | for (var i = triggers.length - 1; i >= 0; i--) { 35 | triggers[i](i); 36 | } 37 | } 38 | 39 | foo(function(_err, _a) { 40 | if (_err) return cb(_err); 41 | a = _a; 42 | console.log("a=" + a); 43 | trigger(1); 44 | }); 45 | 46 | foo(function(_err, _b) { 47 | if (_err) return cb(_err); 48 | b = _b; 49 | console.log("b=" + b); 50 | trigger(2); 51 | }); 52 | 53 | foo(function(_err, _c) { 54 | if (_err) return cb(_err); 55 | c = _c; 56 | console.log("c=" + c); 57 | trigger(4); 58 | }); -------------------------------------------------------------------------------- /examples/if_block.js: -------------------------------------------------------------------------------- 1 | var a = 'a'; 2 | if (foo(_)) { 3 | a = bar(_); 4 | } 5 | console.log(a); 6 | 7 | var b = 'b'; 8 | 9 | if(foo(_)) { 10 | b = bar(_); 11 | } else { 12 | b = bar(); 13 | } 14 | 15 | b = bar(b, _); 16 | console.log(b); 17 | -------------------------------------------------------------------------------- /examples/loop_parallel.js: -------------------------------------------------------------------------------- 1 | for (var i = 0; i < 100; i++) foo(i, _); 2 | 3 | var a = foo(_); 4 | 5 | for (var i = foo(_), bar; i < foo(_); i++) { 6 | foo(a, _); 7 | } 8 | 9 | for (var i = 0, bar; i < 100; i++, bar=0) { 10 | foo(a, _); 11 | } 12 | -------------------------------------------------------------------------------- /examples/loop_parallel.out.js: -------------------------------------------------------------------------------- 1 | var a, _i, _2, _done = 0; 2 | 3 | function trigger(_flag) { 4 | if (7 === ((_done |= _flag) & 7)) { 5 | for (var i = _i, bar; i < _2; i++) { 6 | foo(a, function(_err, _3) { 7 | if (_err) return cb(_err); 8 | }); 9 | } 10 | } 11 | } 12 | 13 | for (var i = 0; i < 100; i++) { 14 | foo(i, function(_err, _1) { 15 | if (_err) return cb(_err); 16 | }); 17 | } 18 | 19 | foo(function(_err, _a) { 20 | if (_err) return cb(_err); 21 | a = _a; 22 | for (var i = 0, bar; i < 100; i++, bar = 0) { 23 | foo(a, function(_err, _4) { 24 | if (_err) return cb(_err); 25 | }); 26 | } 27 | trigger(4); 28 | }); 29 | 30 | foo(function(_err, __i) { 31 | if (_err) return cb(_err); 32 | _i = __i; 33 | trigger(1); 34 | }); 35 | 36 | foo(function(_err, __2) { 37 | if (_err) return cb(_err); 38 | _2 = __2; 39 | trigger(2); 40 | }); -------------------------------------------------------------------------------- /examples/loop_serial.js: -------------------------------------------------------------------------------- 1 | var a = 0, b = 0, c; 2 | 3 | for (var i = 0; i < 100; i++) { 4 | a = foo(a, _); 5 | } 6 | 7 | for (var i = 0, j = 0; i < 100; i++, b+=1) { 8 | b = foo(b, j, _); 9 | j = bar(j); 10 | } 11 | 12 | console.log(b); 13 | 14 | for (var i = 0; i < 100; i++) { 15 | c = foo(a, b, c, _); 16 | } 17 | 18 | -------------------------------------------------------------------------------- /examples/loop_serial.out.js: -------------------------------------------------------------------------------- 1 | var _done = 0; 2 | 3 | function trigger(_flag) { 4 | if (3 === ((_done |= _flag) & 3)) { 5 | (function next(i) { 6 | if (i < 100) { 7 | foo(a, b, c, function(_err, _c) { 8 | if (_err) return cb(_err); 9 | c = _c; 10 | }); 11 | next(++i); 12 | } 13 | })(0); 14 | } 15 | } 16 | 17 | var a = 0, b = 0, c; 18 | 19 | (function next(i) { 20 | if (i < 100) { 21 | foo(a, function(_err, _a) { 22 | if (_err) return cb(_err); 23 | a = _a; 24 | }); 25 | next(++i); 26 | } else { 27 | trigger(2); 28 | } 29 | })(0); 30 | 31 | (function next(i, j, after) { 32 | if (i < 100) { 33 | foo(b, j, function(_err, _b) { 34 | if (_err) return cb(_err); 35 | b = _b; 36 | }); 37 | j = bar(j); 38 | b += 1; 39 | next(++i, j); 40 | } else after(); 41 | })(0, 0, function() { 42 | console.log(b); 43 | trigger(1); 44 | }); -------------------------------------------------------------------------------- /examples/mongodb.js: -------------------------------------------------------------------------------- 1 | var mongodb = require('mongodb'); 2 | var db = new mongodb.Db('test', new mongodb.Server('localhost', 27017)); 3 | 4 | db = db.open(_); 5 | 6 | var User = db.collection('user', _); 7 | var Blog = db.collection('blog', _); 8 | var Tag = db.collection('tag', _); 9 | 10 | app.get('/', function(req, res){ 11 | var user = User.find({_id: user_id}, _).toArray(_)[0]; 12 | var blog = Blog.find({user: user}, _).toArray(_); 13 | var tags = Tag.find({}, _).toArray(_); 14 | res.render('index.jade', { 15 | user: user, 16 | blog: blog, 17 | tags: tags 18 | }); 19 | }) 20 | -------------------------------------------------------------------------------- /examples/parallel.js: -------------------------------------------------------------------------------- 1 | var a = foo(_); 2 | var b = foo(_); 3 | console.log('a=' + a); 4 | console.log('b=' + b); 5 | -------------------------------------------------------------------------------- /examples/parallel.out.js: -------------------------------------------------------------------------------- 1 | var a, b; 2 | 3 | foo(function(_err, _a) { 4 | if (_err) return cb(_err); 5 | a = _a; 6 | console.log("a=" + a); 7 | }); 8 | 9 | foo(function(_err, _b) { 10 | if (_err) return cb(_err); 11 | b = _b; 12 | console.log("b=" + b); 13 | }); -------------------------------------------------------------------------------- /examples/serial.js: -------------------------------------------------------------------------------- 1 | var a = foo(_); 2 | var b = foo(a, _); 3 | console.log('a=' + a); 4 | console.log('b=' + b); 5 | -------------------------------------------------------------------------------- /examples/serial.out.js: -------------------------------------------------------------------------------- 1 | var a, b; 2 | 3 | foo(function(_err, _a) { 4 | if (_err) return cb(_err); 5 | a = _a; 6 | foo(a, function(_err, _b) { 7 | if (_err) return cb(_err); 8 | b = _b; 9 | console.log("b=" + b); 10 | }); 11 | console.log("a=" + a); 12 | }); -------------------------------------------------------------------------------- /examples/steps.js: -------------------------------------------------------------------------------- 1 | var a = foo(_); 2 | var c = foo(a, foo(_), _); 3 | console.log('a=' + a); 4 | console.log('c=' + c); 5 | -------------------------------------------------------------------------------- /examples/steps.out.js: -------------------------------------------------------------------------------- 1 | var a, c, _1, _done = 0; 2 | 3 | function trigger(_flag) { 4 | if (3 === ((_done |= _flag) & 3)) { 5 | foo(a, _1, function(_err, _c) { 6 | if (_err) return cb(_err); 7 | c = _c; 8 | console.log("c=" + c); 9 | }); 10 | } 11 | } 12 | 13 | foo(function(_err, _a) { 14 | if (_err) return cb(_err); 15 | a = _a; 16 | console.log("a=" + a); 17 | trigger(1); 18 | }); 19 | 20 | foo(function(_err, __1) { 21 | if (_err) return cb(_err); 22 | _1 = __1; 23 | trigger(2); 24 | }); -------------------------------------------------------------------------------- /examples/storm_vs_step.js: -------------------------------------------------------------------------------- 1 | function loadArticle(name, _) { 2 | var markdown = Git.readFile(path.join("articles", name + ".markdown"), _); 3 | props = markdownPreParse(markdown); 4 | props.name = name; 5 | var author = loadAuthor(props.author, _); 6 | props.author = author; 7 | return props; 8 | } 9 | -------------------------------------------------------------------------------- /examples/stuffs.js: -------------------------------------------------------------------------------- 1 | function fooAsync(a){ 2 | if(!a) 3 | throw new Error('must specify arg a') 4 | return fooAsync(fooAsync())['xx']; 5 | } 6 | 7 | foo('test', function(err, data){ 8 | doSomething(data); 9 | }); 10 | -------------------------------------------------------------------------------- /examples/test.js: -------------------------------------------------------------------------------- 1 | var a; 2 | 3 | for (var i=0;i<100;i++){ 4 | a = getNextUrl@(a); 5 | a = getNextUrl@(a); 6 | } 7 | 8 | console.log(a); 9 | -------------------------------------------------------------------------------- /google-code-prettify/lang-apollo.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-apollo.js -------------------------------------------------------------------------------- /google-code-prettify/lang-clj.js: -------------------------------------------------------------------------------- 1 | /* 2 | Copyright (C) 2011 Google Inc. 3 | 4 | Licensed under the Apache License, Version 2.0 (the "License"); 5 | you may not use this file except in compliance with the License. 6 | You may obtain a copy of the License at 7 | 8 | http://www.apache.org/licenses/LICENSE-2.0 9 | 10 | Unless required by applicable law or agreed to in writing, software 11 | distributed under the License is distributed on an "AS IS" BASIS, 12 | WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 | See the License for the specific language governing permissions and 14 | limitations under the License. 15 | */ 16 | var a=null; 17 | PR.registerLangHandler(PR.createSimpleLexer([["opn",/^[([{]+/,a,"([{"],["clo",/^[)\]}]+/,a,")]}"],["com",/^;[^\n\r]*/,a,";"],["pln",/^[\t\n\r \xa0]+/,a,"\t\n\r \xa0"],["str",/^"(?:[^"\\]|\\[\S\s])*(?:"|$)/,a,'"']],[["kwd",/^(?:def|if|do|let|quote|var|fn|loop|recur|throw|try|monitor-enter|monitor-exit|defmacro|defn|defn-|macroexpand|macroexpand-1|for|doseq|dosync|dotimes|and|or|when|not|assert|doto|proxy|defstruct|first|rest|cons|defprotocol|deftype|defrecord|reify|defmulti|defmethod|meta|with-meta|ns|in-ns|create-ns|import|intern|refer|alias|namespace|resolve|ref|deref|refset|new|set!|memfn|to-array|into-array|aset|gen-class|reduce|map|filter|find|nil?|empty?|hash-map|hash-set|vec|vector|seq|flatten|reverse|assoc|dissoc|list|list?|disj|get|union|difference|intersection|extend|extend-type|extend-protocol|prn)\b/,a], 18 | ["typ",/^:[\dA-Za-z-]+/]]),["clj"]); 19 | -------------------------------------------------------------------------------- /google-code-prettify/lang-css.js: -------------------------------------------------------------------------------- 1 | PR.registerLangHandler(PR.createSimpleLexer([["pln",/^[\t\n\f\r ]+/,null," \t\r\n "]],[["str",/^"(?:[^\n\f\r"\\]|\\(?:\r\n?|\n|\f)|\\[\S\s])*"/,null],["str",/^'(?:[^\n\f\r'\\]|\\(?:\r\n?|\n|\f)|\\[\S\s])*'/,null],["lang-css-str",/^url\(([^"')]*)\)/i],["kwd",/^(?:url|rgb|!important|@import|@page|@media|@charset|inherit)(?=[^\w-]|$)/i,null],["lang-css-kw",/^(-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*)\s*:/i],["com",/^\/\*[^*]*\*+(?:[^*/][^*]*\*+)*\//],["com", 2 | /^(?:<\!--|--\>)/],["lit",/^(?:\d+|\d*\.\d+)(?:%|[a-z]+)?/i],["lit",/^#[\da-f]{3,6}/i],["pln",/^-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*/i],["pun",/^[^\s\w"']+/]]),["css"]);PR.registerLangHandler(PR.createSimpleLexer([],[["kwd",/^-?(?:[_a-z]|\\[\da-f]+ ?)(?:[\w-]|\\\\[\da-f]+ ?)*/i]]),["css-kw"]);PR.registerLangHandler(PR.createSimpleLexer([],[["str",/^[^"')]+/]]),["css-str"]); 3 | -------------------------------------------------------------------------------- /google-code-prettify/lang-go.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-go.js -------------------------------------------------------------------------------- /google-code-prettify/lang-hs.js: -------------------------------------------------------------------------------- 1 | PR.registerLangHandler(PR.createSimpleLexer([["pln",/^[\t-\r ]+/,null,"\t\n \r "],["str",/^"(?:[^\n\f\r"\\]|\\[\S\s])*(?:"|$)/,null,'"'],["str",/^'(?:[^\n\f\r'\\]|\\[^&])'?/,null,"'"],["lit",/^(?:0o[0-7]+|0x[\da-f]+|\d+(?:\.\d+)?(?:e[+-]?\d+)?)/i,null,"0123456789"]],[["com",/^(?:--+[^\n\f\r]*|{-(?:[^-]|-+[^}-])*-})/],["kwd",/^(?:case|class|data|default|deriving|do|else|if|import|in|infix|infixl|infixr|instance|let|module|newtype|of|then|type|where|_)(?=[^\d'A-Za-z]|$)/, 2 | null],["pln",/^(?:[A-Z][\w']*\.)*[A-Za-z][\w']*/],["pun",/^[^\d\t-\r "'A-Za-z]+/]]),["hs"]); 3 | -------------------------------------------------------------------------------- /google-code-prettify/lang-lisp.js: -------------------------------------------------------------------------------- 1 | var a=null; 2 | PR.registerLangHandler(PR.createSimpleLexer([["opn",/^\(+/,a,"("],["clo",/^\)+/,a,")"],["com",/^;[^\n\r]*/,a,";"],["pln",/^[\t\n\r \xa0]+/,a,"\t\n\r \xa0"],["str",/^"(?:[^"\\]|\\[\S\s])*(?:"|$)/,a,'"']],[["kwd",/^(?:block|c[ad]+r|catch|con[ds]|def(?:ine|un)|do|eq|eql|equal|equalp|eval-when|flet|format|go|if|labels|lambda|let|load-time-value|locally|macrolet|multiple-value-call|nil|progn|progv|quote|require|return-from|setq|symbol-macrolet|t|tagbody|the|throw|unwind)\b/,a], 3 | ["lit",/^[+-]?(?:[#0]x[\da-f]+|\d+\/\d+|(?:\.\d+|\d+(?:\.\d*)?)(?:[de][+-]?\d+)?)/i],["lit",/^'(?:-*(?:\w|\\[!-~])(?:[\w-]*|\\[!-~])[!=?]?)?/],["pln",/^-*(?:[_a-z]|\\[!-~])(?:[\w-]*|\\[!-~])[!=?]?/i],["pun",/^[^\w\t\n\r "'-);\\\xa0]+/]]),["cl","el","lisp","lsp","scm"]); 4 | -------------------------------------------------------------------------------- /google-code-prettify/lang-lua.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-lua.js -------------------------------------------------------------------------------- /google-code-prettify/lang-ml.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-ml.js -------------------------------------------------------------------------------- /google-code-prettify/lang-n.js: -------------------------------------------------------------------------------- 1 | var a=null; 2 | PR.registerLangHandler(PR.createSimpleLexer([["str",/^(?:'(?:[^\n\r'\\]|\\.)*'|"(?:[^\n\r"\\]|\\.)*(?:"|$))/,a,'"'],["com",/^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\n\r]*)/,a,"#"],["pln",/^\s+/,a," \r\n\t\xa0"]],[["str",/^@"(?:[^"]|"")*(?:"|$)/,a],["str",/^<#[^#>]*(?:#>|$)/,a],["str",/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,a],["com",/^\/\/[^\n\r]*/,a],["com",/^\/\*[\S\s]*?(?:\*\/|$)/, 3 | a],["kwd",/^(?:abstract|and|as|base|catch|class|def|delegate|enum|event|extern|false|finally|fun|implements|interface|internal|is|macro|match|matches|module|mutable|namespace|new|null|out|override|params|partial|private|protected|public|ref|sealed|static|struct|syntax|this|throw|true|try|type|typeof|using|variant|virtual|volatile|when|where|with|assert|assert2|async|break|checked|continue|do|else|ensures|for|foreach|if|late|lock|new|nolate|otherwise|regexp|repeat|requires|return|surroundwith|unchecked|unless|using|while|yield)\b/, 4 | a],["typ",/^(?:array|bool|byte|char|decimal|double|float|int|list|long|object|sbyte|short|string|ulong|uint|ufloat|ulong|ushort|void)\b/,a],["lit",/^@[$_a-z][\w$@]*/i,a],["typ",/^@[A-Z]+[a-z][\w$@]*/,a],["pln",/^'?[$_a-z][\w$@]*/i,a],["lit",/^(?:0x[\da-f]+|(?:\d(?:_\d+)*\d*(?:\.\d*)?|\.\d\+)(?:e[+-]?\d+)?)[a-z]*/i,a,"0123456789"],["pun",/^.[^\s\w"-$'./@`]*/,a]],["n","nemerle"])); 5 | -------------------------------------------------------------------------------- /google-code-prettify/lang-proto.js: -------------------------------------------------------------------------------- 1 | PR.registerLangHandler(PR.sourceDecorator({keywords:"bytes,default,double,enum,extend,extensions,false,group,import,max,message,option,optional,package,repeated,required,returns,rpc,service,syntax,to,true",types:/^(bool|(double|s?fixed|[su]?int)(32|64)|float|string)\b/,cStyleComments:!0}),["proto"]); 2 | -------------------------------------------------------------------------------- /google-code-prettify/lang-scala.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-scala.js -------------------------------------------------------------------------------- /google-code-prettify/lang-sql.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-sql.js -------------------------------------------------------------------------------- /google-code-prettify/lang-tex.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-tex.js -------------------------------------------------------------------------------- /google-code-prettify/lang-vb.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-vb.js -------------------------------------------------------------------------------- /google-code-prettify/lang-vhdl.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-vhdl.js -------------------------------------------------------------------------------- /google-code-prettify/lang-wiki.js: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/guileen/stormjs/7145984b315bb499266ba5591c87484859854c51/google-code-prettify/lang-wiki.js -------------------------------------------------------------------------------- /google-code-prettify/lang-xq.js: -------------------------------------------------------------------------------- 1 | PR.registerLangHandler(PR.createSimpleLexer([["var pln",/^\$[\w-]+/,null,"$"]],[["pln",/^[\s=][<>][\s=]/],["lit",/^@[\w-]+/],["tag",/^<\/?[a-z](?:[\w-.:]*\w)?|\/?>$/i],["com",/^\(:[\S\s]*?:\)/],["pln",/^[(),/;[\]{}]$/],["str",/^(?:"(?:[^"\\{]|\\[\S\s])*(?:"|$)|'(?:[^'\\{]|\\[\S\s])*(?:'|$))/,null,"\"'"],["kwd",/^(?:xquery|where|version|variable|union|typeswitch|treat|to|then|text|stable|sortby|some|self|schema|satisfies|returns|return|ref|processing-instruction|preceding-sibling|preceding|precedes|parent|only|of|node|namespace|module|let|item|intersect|instance|in|import|if|function|for|follows|following-sibling|following|external|except|every|else|element|descending|descendant-or-self|descendant|define|default|declare|comment|child|cast|case|before|attribute|assert|ascending|as|ancestor-or-self|ancestor|after|eq|order|by|or|and|schema-element|document-node|node|at)\b/], 2 | ["typ",/^(?:xs:yearMonthDuration|xs:unsignedLong|xs:time|xs:string|xs:short|xs:QName|xs:Name|xs:long|xs:integer|xs:int|xs:gYearMonth|xs:gYear|xs:gMonthDay|xs:gDay|xs:float|xs:duration|xs:double|xs:decimal|xs:dayTimeDuration|xs:dateTime|xs:date|xs:byte|xs:boolean|xs:anyURI|xf:yearMonthDuration)\b/,null],["fun pln",/^(?:xp:dereference|xinc:node-expand|xinc:link-references|xinc:link-expand|xhtml:restructure|xhtml:clean|xhtml:add-lists|xdmp:zip-manifest|xdmp:zip-get|xdmp:zip-create|xdmp:xquery-version|xdmp:word-convert|xdmp:with-namespaces|xdmp:version|xdmp:value|xdmp:user-roles|xdmp:user-last-login|xdmp:user|xdmp:url-encode|xdmp:url-decode|xdmp:uri-is-file|xdmp:uri-format|xdmp:uri-content-type|xdmp:unquote|xdmp:unpath|xdmp:triggers-database|xdmp:trace|xdmp:to-json|xdmp:tidy|xdmp:subbinary|xdmp:strftime|xdmp:spawn-in|xdmp:spawn|xdmp:sleep|xdmp:shutdown|xdmp:set-session-field|xdmp:set-response-encoding|xdmp:set-response-content-type|xdmp:set-response-code|xdmp:set-request-time-limit|xdmp:set|xdmp:servers|xdmp:server-status|xdmp:server-name|xdmp:server|xdmp:security-database|xdmp:security-assert|xdmp:schema-database|xdmp:save|xdmp:role-roles|xdmp:role|xdmp:rethrow|xdmp:restart|xdmp:request-timestamp|xdmp:request-status|xdmp:request-cancel|xdmp:request|xdmp:redirect-response|xdmp:random|xdmp:quote|xdmp:query-trace|xdmp:query-meters|xdmp:product-edition|xdmp:privilege-roles|xdmp:privilege|xdmp:pretty-print|xdmp:powerpoint-convert|xdmp:platform|xdmp:permission|xdmp:pdf-convert|xdmp:path|xdmp:octal-to-integer|xdmp:node-uri|xdmp:node-replace|xdmp:node-kind|xdmp:node-insert-child|xdmp:node-insert-before|xdmp:node-insert-after|xdmp:node-delete|xdmp:node-database|xdmp:mul64|xdmp:modules-root|xdmp:modules-database|xdmp:merging|xdmp:merge-cancel|xdmp:merge|xdmp:md5|xdmp:logout|xdmp:login|xdmp:log-level|xdmp:log|xdmp:lock-release|xdmp:lock-acquire|xdmp:load|xdmp:invoke-in|xdmp:invoke|xdmp:integer-to-octal|xdmp:integer-to-hex|xdmp:http-put|xdmp:http-post|xdmp:http-options|xdmp:http-head|xdmp:http-get|xdmp:http-delete|xdmp:hosts|xdmp:host-status|xdmp:host-name|xdmp:host|xdmp:hex-to-integer|xdmp:hash64|xdmp:hash32|xdmp:has-privilege|xdmp:groups|xdmp:group-serves|xdmp:group-servers|xdmp:group-name|xdmp:group-hosts|xdmp:group|xdmp:get-session-field-names|xdmp:get-session-field|xdmp:get-response-encoding|xdmp:get-response-code|xdmp:get-request-username|xdmp:get-request-user|xdmp:get-request-url|xdmp:get-request-protocol|xdmp:get-request-path|xdmp:get-request-method|xdmp:get-request-header-names|xdmp:get-request-header|xdmp:get-request-field-names|xdmp:get-request-field-filename|xdmp:get-request-field-content-type|xdmp:get-request-field|xdmp:get-request-client-certificate|xdmp:get-request-client-address|xdmp:get-request-body|xdmp:get-current-user|xdmp:get-current-roles|xdmp:get|xdmp:function-name|xdmp:function-module|xdmp:function|xdmp:from-json|xdmp:forests|xdmp:forest-status|xdmp:forest-restore|xdmp:forest-restart|xdmp:forest-name|xdmp:forest-delete|xdmp:forest-databases|xdmp:forest-counts|xdmp:forest-clear|xdmp:forest-backup|xdmp:forest|xdmp:filesystem-file|xdmp:filesystem-directory|xdmp:exists|xdmp:excel-convert|xdmp:eval-in|xdmp:eval|xdmp:estimate|xdmp:email|xdmp:element-content-type|xdmp:elapsed-time|xdmp:document-set-quality|xdmp:document-set-property|xdmp:document-set-properties|xdmp:document-set-permissions|xdmp:document-set-collections|xdmp:document-remove-properties|xdmp:document-remove-permissions|xdmp:document-remove-collections|xdmp:document-properties|xdmp:document-locks|xdmp:document-load|xdmp:document-insert|xdmp:document-get-quality|xdmp:document-get-properties|xdmp:document-get-permissions|xdmp:document-get-collections|xdmp:document-get|xdmp:document-forest|xdmp:document-delete|xdmp:document-add-properties|xdmp:document-add-permissions|xdmp:document-add-collections|xdmp:directory-properties|xdmp:directory-locks|xdmp:directory-delete|xdmp:directory-create|xdmp:directory|xdmp:diacritic-less|xdmp:describe|xdmp:default-permissions|xdmp:default-collections|xdmp:databases|xdmp:database-restore-validate|xdmp:database-restore-status|xdmp:database-restore-cancel|xdmp:database-restore|xdmp:database-name|xdmp:database-forests|xdmp:database-backup-validate|xdmp:database-backup-status|xdmp:database-backup-purge|xdmp:database-backup-cancel|xdmp:database-backup|xdmp:database|xdmp:collection-properties|xdmp:collection-locks|xdmp:collection-delete|xdmp:collation-canonical-uri|xdmp:castable-as|xdmp:can-grant-roles|xdmp:base64-encode|xdmp:base64-decode|xdmp:architecture|xdmp:apply|xdmp:amp-roles|xdmp:amp|xdmp:add64|xdmp:add-response-header|xdmp:access|trgr:trigger-set-recursive|trgr:trigger-set-permissions|trgr:trigger-set-name|trgr:trigger-set-module|trgr:trigger-set-event|trgr:trigger-set-description|trgr:trigger-remove-permissions|trgr:trigger-module|trgr:trigger-get-permissions|trgr:trigger-enable|trgr:trigger-disable|trgr:trigger-database-online-event|trgr:trigger-data-event|trgr:trigger-add-permissions|trgr:remove-trigger|trgr:property-content|trgr:pre-commit|trgr:post-commit|trgr:get-trigger-by-id|trgr:get-trigger|trgr:document-scope|trgr:document-content|trgr:directory-scope|trgr:create-trigger|trgr:collection-scope|trgr:any-property-content|thsr:set-entry|thsr:remove-term|thsr:remove-synonym|thsr:remove-entry|thsr:query-lookup|thsr:lookup|thsr:load|thsr:insert|thsr:expand|thsr:add-synonym|spell:suggest-detailed|spell:suggest|spell:remove-word|spell:make-dictionary|spell:load|spell:levenshtein-distance|spell:is-correct|spell:insert|spell:double-metaphone|spell:add-word|sec:users-collection|sec:user-set-roles|sec:user-set-password|sec:user-set-name|sec:user-set-description|sec:user-set-default-permissions|sec:user-set-default-collections|sec:user-remove-roles|sec:user-privileges|sec:user-get-roles|sec:user-get-description|sec:user-get-default-permissions|sec:user-get-default-collections|sec:user-doc-permissions|sec:user-doc-collections|sec:user-add-roles|sec:unprotect-collection|sec:uid-for-name|sec:set-realm|sec:security-version|sec:security-namespace|sec:security-installed|sec:security-collection|sec:roles-collection|sec:role-set-roles|sec:role-set-name|sec:role-set-description|sec:role-set-default-permissions|sec:role-set-default-collections|sec:role-remove-roles|sec:role-privileges|sec:role-get-roles|sec:role-get-description|sec:role-get-default-permissions|sec:role-get-default-collections|sec:role-doc-permissions|sec:role-doc-collections|sec:role-add-roles|sec:remove-user|sec:remove-role-from-users|sec:remove-role-from-role|sec:remove-role-from-privileges|sec:remove-role-from-amps|sec:remove-role|sec:remove-privilege|sec:remove-amp|sec:protect-collection|sec:privileges-collection|sec:privilege-set-roles|sec:privilege-set-name|sec:privilege-remove-roles|sec:privilege-get-roles|sec:privilege-add-roles|sec:priv-doc-permissions|sec:priv-doc-collections|sec:get-user-names|sec:get-unique-elem-id|sec:get-role-names|sec:get-role-ids|sec:get-privilege|sec:get-distinct-permissions|sec:get-collection|sec:get-amp|sec:create-user-with-role|sec:create-user|sec:create-role|sec:create-privilege|sec:create-amp|sec:collections-collection|sec:collection-set-permissions|sec:collection-remove-permissions|sec:collection-get-permissions|sec:collection-add-permissions|sec:check-admin|sec:amps-collection|sec:amp-set-roles|sec:amp-remove-roles|sec:amp-get-roles|sec:amp-doc-permissions|sec:amp-doc-collections|sec:amp-add-roles|search:unparse|search:suggest|search:snippet|search:search|search:resolve-nodes|search:resolve|search:remove-constraint|search:parse|search:get-default-options|search:estimate|search:check-options|prof:value|prof:reset|prof:report|prof:invoke|prof:eval|prof:enable|prof:disable|prof:allowed|ppt:clean|pki:template-set-request|pki:template-set-name|pki:template-set-key-type|pki:template-set-key-options|pki:template-set-description|pki:template-in-use|pki:template-get-version|pki:template-get-request|pki:template-get-name|pki:template-get-key-type|pki:template-get-key-options|pki:template-get-id|pki:template-get-description|pki:need-certificate|pki:is-temporary|pki:insert-trusted-certificates|pki:insert-template|pki:insert-signed-certificates|pki:insert-certificate-revocation-list|pki:get-trusted-certificate-ids|pki:get-template-ids|pki:get-template-certificate-authority|pki:get-template-by-name|pki:get-template|pki:get-pending-certificate-requests-xml|pki:get-pending-certificate-requests-pem|pki:get-pending-certificate-request|pki:get-certificates-for-template-xml|pki:get-certificates-for-template|pki:get-certificates|pki:get-certificate-xml|pki:get-certificate-pem|pki:get-certificate|pki:generate-temporary-certificate-if-necessary|pki:generate-temporary-certificate|pki:generate-template-certificate-authority|pki:generate-certificate-request|pki:delete-template|pki:delete-certificate|pki:create-template|pdf:make-toc|pdf:insert-toc-headers|pdf:get-toc|pdf:clean|p:status-transition|p:state-transition|p:remove|p:pipelines|p:insert|p:get-by-id|p:get|p:execute|p:create|p:condition|p:collection|p:action|ooxml:runs-merge|ooxml:package-uris|ooxml:package-parts-insert|ooxml:package-parts|msword:clean|mcgm:polygon|mcgm:point|mcgm:geospatial-query-from-elements|mcgm:geospatial-query|mcgm:circle|math:tanh|math:tan|math:sqrt|math:sinh|math:sin|math:pow|math:modf|math:log10|math:log|math:ldexp|math:frexp|math:fmod|math:floor|math:fabs|math:exp|math:cosh|math:cos|math:ceil|math:atan2|math:atan|math:asin|math:acos|map:put|map:map|map:keys|map:get|map:delete|map:count|map:clear|lnk:to|lnk:remove|lnk:insert|lnk:get|lnk:from|lnk:create|kml:polygon|kml:point|kml:interior-polygon|kml:geospatial-query-from-elements|kml:geospatial-query|kml:circle|kml:box|gml:polygon|gml:point|gml:interior-polygon|gml:geospatial-query-from-elements|gml:geospatial-query|gml:circle|gml:box|georss:point|georss:geospatial-query|georss:circle|geo:polygon|geo:point|geo:interior-polygon|geo:geospatial-query-from-elements|geo:geospatial-query|geo:circle|geo:box|fn:zero-or-one|fn:years-from-duration|fn:year-from-dateTime|fn:year-from-date|fn:upper-case|fn:unordered|fn:true|fn:translate|fn:trace|fn:tokenize|fn:timezone-from-time|fn:timezone-from-dateTime|fn:timezone-from-date|fn:sum|fn:subtract-dateTimes-yielding-yearMonthDuration|fn:subtract-dateTimes-yielding-dayTimeDuration|fn:substring-before|fn:substring-after|fn:substring|fn:subsequence|fn:string-to-codepoints|fn:string-pad|fn:string-length|fn:string-join|fn:string|fn:static-base-uri|fn:starts-with|fn:seconds-from-time|fn:seconds-from-duration|fn:seconds-from-dateTime|fn:round-half-to-even|fn:round|fn:root|fn:reverse|fn:resolve-uri|fn:resolve-QName|fn:replace|fn:remove|fn:QName|fn:prefix-from-QName|fn:position|fn:one-or-more|fn:number|fn:not|fn:normalize-unicode|fn:normalize-space|fn:node-name|fn:node-kind|fn:nilled|fn:namespace-uri-from-QName|fn:namespace-uri-for-prefix|fn:namespace-uri|fn:name|fn:months-from-duration|fn:month-from-dateTime|fn:month-from-date|fn:minutes-from-time|fn:minutes-from-duration|fn:minutes-from-dateTime|fn:min|fn:max|fn:matches|fn:lower-case|fn:local-name-from-QName|fn:local-name|fn:last|fn:lang|fn:iri-to-uri|fn:insert-before|fn:index-of|fn:in-scope-prefixes|fn:implicit-timezone|fn:idref|fn:id|fn:hours-from-time|fn:hours-from-duration|fn:hours-from-dateTime|fn:floor|fn:false|fn:expanded-QName|fn:exists|fn:exactly-one|fn:escape-uri|fn:escape-html-uri|fn:error|fn:ends-with|fn:encode-for-uri|fn:empty|fn:document-uri|fn:doc-available|fn:doc|fn:distinct-values|fn:distinct-nodes|fn:default-collation|fn:deep-equal|fn:days-from-duration|fn:day-from-dateTime|fn:day-from-date|fn:data|fn:current-time|fn:current-dateTime|fn:current-date|fn:count|fn:contains|fn:concat|fn:compare|fn:collection|fn:codepoints-to-string|fn:codepoint-equal|fn:ceiling|fn:boolean|fn:base-uri|fn:avg|fn:adjust-time-to-timezone|fn:adjust-dateTime-to-timezone|fn:adjust-date-to-timezone|fn:abs|feed:unsubscribe|feed:subscription|feed:subscribe|feed:request|feed:item|feed:description|excel:clean|entity:enrich|dom:set-pipelines|dom:set-permissions|dom:set-name|dom:set-evaluation-context|dom:set-domain-scope|dom:set-description|dom:remove-pipeline|dom:remove-permissions|dom:remove|dom:get|dom:evaluation-context|dom:domains|dom:domain-scope|dom:create|dom:configuration-set-restart-user|dom:configuration-set-permissions|dom:configuration-set-evaluation-context|dom:configuration-set-default-domain|dom:configuration-get|dom:configuration-create|dom:collection|dom:add-pipeline|dom:add-permissions|dls:retention-rules|dls:retention-rule-remove|dls:retention-rule-insert|dls:retention-rule|dls:purge|dls:node-expand|dls:link-references|dls:link-expand|dls:documents-query|dls:document-versions-query|dls:document-version-uri|dls:document-version-query|dls:document-version-delete|dls:document-version-as-of|dls:document-version|dls:document-update|dls:document-unmanage|dls:document-set-quality|dls:document-set-property|dls:document-set-properties|dls:document-set-permissions|dls:document-set-collections|dls:document-retention-rules|dls:document-remove-properties|dls:document-remove-permissions|dls:document-remove-collections|dls:document-purge|dls:document-manage|dls:document-is-managed|dls:document-insert-and-manage|dls:document-include-query|dls:document-history|dls:document-get-permissions|dls:document-extract-part|dls:document-delete|dls:document-checkout-status|dls:document-checkout|dls:document-checkin|dls:document-add-properties|dls:document-add-permissions|dls:document-add-collections|dls:break-checkout|dls:author-query|dls:as-of-query|dbk:convert|dbg:wait|dbg:value|dbg:stopped|dbg:stop|dbg:step|dbg:status|dbg:stack|dbg:out|dbg:next|dbg:line|dbg:invoke|dbg:function|dbg:finish|dbg:expr|dbg:eval|dbg:disconnect|dbg:detach|dbg:continue|dbg:connect|dbg:clear|dbg:breakpoints|dbg:break|dbg:attached|dbg:attach|cvt:save-converted-documents|cvt:part-uri|cvt:destination-uri|cvt:basepath|cvt:basename|cts:words|cts:word-query-weight|cts:word-query-text|cts:word-query-options|cts:word-query|cts:word-match|cts:walk|cts:uris|cts:uri-match|cts:train|cts:tokenize|cts:thresholds|cts:stem|cts:similar-query-weight|cts:similar-query-nodes|cts:similar-query|cts:shortest-distance|cts:search|cts:score|cts:reverse-query-weight|cts:reverse-query-nodes|cts:reverse-query|cts:remainder|cts:registered-query-weight|cts:registered-query-options|cts:registered-query-ids|cts:registered-query|cts:register|cts:query|cts:quality|cts:properties-query-query|cts:properties-query|cts:polygon-vertices|cts:polygon|cts:point-longitude|cts:point-latitude|cts:point|cts:or-query-queries|cts:or-query|cts:not-query-weight|cts:not-query-query|cts:not-query|cts:near-query-weight|cts:near-query-queries|cts:near-query-options|cts:near-query-distance|cts:near-query|cts:highlight|cts:geospatial-co-occurrences|cts:frequency|cts:fitness|cts:field-words|cts:field-word-query-weight|cts:field-word-query-text|cts:field-word-query-options|cts:field-word-query-field-name|cts:field-word-query|cts:field-word-match|cts:entity-highlight|cts:element-words|cts:element-word-query-weight|cts:element-word-query-text|cts:element-word-query-options|cts:element-word-query-element-name|cts:element-word-query|cts:element-word-match|cts:element-values|cts:element-value-ranges|cts:element-value-query-weight|cts:element-value-query-text|cts:element-value-query-options|cts:element-value-query-element-name|cts:element-value-query|cts:element-value-match|cts:element-value-geospatial-co-occurrences|cts:element-value-co-occurrences|cts:element-range-query-weight|cts:element-range-query-value|cts:element-range-query-options|cts:element-range-query-operator|cts:element-range-query-element-name|cts:element-range-query|cts:element-query-query|cts:element-query-element-name|cts:element-query|cts:element-pair-geospatial-values|cts:element-pair-geospatial-value-match|cts:element-pair-geospatial-query-weight|cts:element-pair-geospatial-query-region|cts:element-pair-geospatial-query-options|cts:element-pair-geospatial-query-longitude-name|cts:element-pair-geospatial-query-latitude-name|cts:element-pair-geospatial-query-element-name|cts:element-pair-geospatial-query|cts:element-pair-geospatial-boxes|cts:element-geospatial-values|cts:element-geospatial-value-match|cts:element-geospatial-query-weight|cts:element-geospatial-query-region|cts:element-geospatial-query-options|cts:element-geospatial-query-element-name|cts:element-geospatial-query|cts:element-geospatial-boxes|cts:element-child-geospatial-values|cts:element-child-geospatial-value-match|cts:element-child-geospatial-query-weight|cts:element-child-geospatial-query-region|cts:element-child-geospatial-query-options|cts:element-child-geospatial-query-element-name|cts:element-child-geospatial-query-child-name|cts:element-child-geospatial-query|cts:element-child-geospatial-boxes|cts:element-attribute-words|cts:element-attribute-word-query-weight|cts:element-attribute-word-query-text|cts:element-attribute-word-query-options|cts:element-attribute-word-query-element-name|cts:element-attribute-word-query-attribute-name|cts:element-attribute-word-query|cts:element-attribute-word-match|cts:element-attribute-values|cts:element-attribute-value-ranges|cts:element-attribute-value-query-weight|cts:element-attribute-value-query-text|cts:element-attribute-value-query-options|cts:element-attribute-value-query-element-name|cts:element-attribute-value-query-attribute-name|cts:element-attribute-value-query|cts:element-attribute-value-match|cts:element-attribute-value-geospatial-co-occurrences|cts:element-attribute-value-co-occurrences|cts:element-attribute-range-query-weight|cts:element-attribute-range-query-value|cts:element-attribute-range-query-options|cts:element-attribute-range-query-operator|cts:element-attribute-range-query-element-name|cts:element-attribute-range-query-attribute-name|cts:element-attribute-range-query|cts:element-attribute-pair-geospatial-values|cts:element-attribute-pair-geospatial-value-match|cts:element-attribute-pair-geospatial-query-weight|cts:element-attribute-pair-geospatial-query-region|cts:element-attribute-pair-geospatial-query-options|cts:element-attribute-pair-geospatial-query-longitude-name|cts:element-attribute-pair-geospatial-query-latitude-name|cts:element-attribute-pair-geospatial-query-element-name|cts:element-attribute-pair-geospatial-query|cts:element-attribute-pair-geospatial-boxes|cts:document-query-uris|cts:document-query|cts:distance|cts:directory-query-uris|cts:directory-query-depth|cts:directory-query|cts:destination|cts:deregister|cts:contains|cts:confidence|cts:collections|cts:collection-query-uris|cts:collection-query|cts:collection-match|cts:classify|cts:circle-radius|cts:circle-center|cts:circle|cts:box-west|cts:box-south|cts:box-north|cts:box-east|cts:box|cts:bearing|cts:arc-intersection|cts:and-query-queries|cts:and-query-options|cts:and-query|cts:and-not-query-positive-query|cts:and-not-query-negative-query|cts:and-not-query|css:get|css:convert|cpf:success|cpf:failure|cpf:document-set-state|cpf:document-set-processing-status|cpf:document-set-last-updated|cpf:document-set-error|cpf:document-get-state|cpf:document-get-processing-status|cpf:document-get-last-updated|cpf:document-get-error|cpf:check-transition|alert:spawn-matching-actions|alert:rule-user-id-query|alert:rule-set-user-id|alert:rule-set-query|alert:rule-set-options|alert:rule-set-name|alert:rule-set-description|alert:rule-set-action|alert:rule-remove|alert:rule-name-query|alert:rule-insert|alert:rule-id-query|alert:rule-get-user-id|alert:rule-get-query|alert:rule-get-options|alert:rule-get-name|alert:rule-get-id|alert:rule-get-description|alert:rule-get-action|alert:rule-action-query|alert:remove-triggers|alert:make-rule|alert:make-log-action|alert:make-config|alert:make-action|alert:invoke-matching-actions|alert:get-my-rules|alert:get-all-rules|alert:get-actions|alert:find-matching-rules|alert:create-triggers|alert:config-set-uri|alert:config-set-trigger-ids|alert:config-set-options|alert:config-set-name|alert:config-set-description|alert:config-set-cpf-domain-names|alert:config-set-cpf-domain-ids|alert:config-insert|alert:config-get-uri|alert:config-get-trigger-ids|alert:config-get-options|alert:config-get-name|alert:config-get-id|alert:config-get-description|alert:config-get-cpf-domain-names|alert:config-get-cpf-domain-ids|alert:config-get|alert:config-delete|alert:action-set-options|alert:action-set-name|alert:action-set-module-root|alert:action-set-module-db|alert:action-set-module|alert:action-set-description|alert:action-remove|alert:action-insert|alert:action-get-options|alert:action-get-name|alert:action-get-module-root|alert:action-get-module-db|alert:action-get-module|alert:action-get-description|zero-or-one|years-from-duration|year-from-dateTime|year-from-date|upper-case|unordered|true|translate|trace|tokenize|timezone-from-time|timezone-from-dateTime|timezone-from-date|sum|subtract-dateTimes-yielding-yearMonthDuration|subtract-dateTimes-yielding-dayTimeDuration|substring-before|substring-after|substring|subsequence|string-to-codepoints|string-pad|string-length|string-join|string|static-base-uri|starts-with|seconds-from-time|seconds-from-duration|seconds-from-dateTime|round-half-to-even|round|root|reverse|resolve-uri|resolve-QName|replace|remove|QName|prefix-from-QName|position|one-or-more|number|not|normalize-unicode|normalize-space|node-name|node-kind|nilled|namespace-uri-from-QName|namespace-uri-for-prefix|namespace-uri|name|months-from-duration|month-from-dateTime|month-from-date|minutes-from-time|minutes-from-duration|minutes-from-dateTime|min|max|matches|lower-case|local-name-from-QName|local-name|last|lang|iri-to-uri|insert-before|index-of|in-scope-prefixes|implicit-timezone|idref|id|hours-from-time|hours-from-duration|hours-from-dateTime|floor|false|expanded-QName|exists|exactly-one|escape-uri|escape-html-uri|error|ends-with|encode-for-uri|empty|document-uri|doc-available|doc|distinct-values|distinct-nodes|default-collation|deep-equal|days-from-duration|day-from-dateTime|day-from-date|data|current-time|current-dateTime|current-date|count|contains|concat|compare|collection|codepoints-to-string|codepoint-equal|ceiling|boolean|base-uri|avg|adjust-time-to-timezone|adjust-dateTime-to-timezone|adjust-date-to-timezone|abs)\b/], 3 | ["pln",/^[\w:-]+/],["pln",/^[\t\n\r \xa0]+/]]),["xq","xquery"]); 4 | -------------------------------------------------------------------------------- /google-code-prettify/lang-yaml.js: -------------------------------------------------------------------------------- 1 | var a=null; 2 | PR.registerLangHandler(PR.createSimpleLexer([["pun",/^[:>?|]+/,a,":|>?"],["dec",/^%(?:YAML|TAG)[^\n\r#]+/,a,"%"],["typ",/^&\S+/,a,"&"],["typ",/^!\S*/,a,"!"],["str",/^"(?:[^"\\]|\\.)*(?:"|$)/,a,'"'],["str",/^'(?:[^']|'')*(?:'|$)/,a,"'"],["com",/^#[^\n\r]*/,a,"#"],["pln",/^\s+/,a," \t\r\n"]],[["dec",/^(?:---|\.\.\.)(?:[\n\r]|$)/],["pun",/^-/],["kwd",/^\w+:[\n\r ]/],["pln",/^\w+/]]),["yaml","yml"]); 3 | -------------------------------------------------------------------------------- /google-code-prettify/prettify.css: -------------------------------------------------------------------------------- 1 | .pln{color:#000}@media screen{.str{color:#080}.kwd{color:#008}.com{color:#800}.typ{color:#606}.lit{color:#066}.pun,.opn,.clo{color:#660}.tag{color:#008}.atn{color:#606}.atv{color:#080}.dec,.var{color:#606}.fun{color:red}}@media print,projection{.str{color:#060}.kwd{color:#006;font-weight:bold}.com{color:#600;font-style:italic}.typ{color:#404;font-weight:bold}.lit{color:#044}.pun,.opn,.clo{color:#440}.tag{color:#006;font-weight:bold}.atn{color:#404}.atv{color:#060}}pre.prettyprint{padding:2px;border:1px solid #888}ol.linenums{margin-top:0;margin-bottom:0}li.L0,li.L1,li.L2,li.L3,li.L5,li.L6,li.L7,li.L8{list-style-type:none}li.L1,li.L3,li.L5,li.L7,li.L9{background:#eee} -------------------------------------------------------------------------------- /google-code-prettify/prettify.js: -------------------------------------------------------------------------------- 1 | var p=null;window.PR_SHOULD_USE_CONTINUATION=!0; 2 | (function(){function L(a){function l(a){var h=a.charCodeAt(0);if(h!==92)return h;var b=a.charAt(1);return(h=q[b])?h:"0"<=b&&b<="7"?parseInt(a.substring(1),8):b==="u"||b==="x"?parseInt(a.substring(2),16):a.charCodeAt(1)}function e(a){if(a<32)return(a<16?"\\x0":"\\x")+a.toString(16);a=String.fromCharCode(a);return a==="\\"||a==="-"||a==="]"||a==="^"?"\\"+a:a}function i(a){var h=a.substring(1,a.length-1).match(/\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\[0-3][0-7]{0,2}|\\[0-7]{1,2}|\\[\S\s]|[^\\]/g),a=[],b= 3 | h[0]==="^",m=["["];b&&m.push("^");for(var b=b?1:0,d=h.length;b122||(f<65||g>90||a.push([Math.max(65,g)|32,Math.min(f,90)|32]),f<97||g>122||a.push([Math.max(97,g)&-33,Math.min(f,122)&-33]))}}a.sort(function(a,b){return a[0]-b[0]||b[1]-a[1]});h=[];d=[];for(b=0;bg[0]&&(g[1]+1>g[0]&&m.push("-"),m.push(e(g[1])));m.push("]");return m.join("")}function y(a){for(var h=a.source.match(/\[(?:[^\\\]]|\\[\S\s])*]|\\u[\dA-Fa-f]{4}|\\x[\dA-Fa-f]{2}|\\\d+|\\[^\dux]|\(\?[!:=]|[()^]|[^()[\\^]+/g),b=h.length,f=[],d=0,g=0;d=2&&a==="["?h[d]=i(c):a!=="\\"&&(h[d]=c.replace(/[A-Za-z]/g,function(a){a=a.charCodeAt(0);return"["+String.fromCharCode(a&-33,a|32)+"]"}));return h.join("")}for(var s=0,r=!1,k=!1,o=0,f=a.length;o=5&&"lang-"===b.substring(0,5))&&!(m&&typeof m[1]==="string"))d=!1,b="src";d||(q[h]=b)}g=f;f+=h.length;if(d){d=m[1];var j=h.indexOf(d),A=j+d.length;m[2]&&(A=h.length-m[2].length,j=A-d.length);b=b.substring(5);B(k+g,h.substring(0,j),e,o);B(k+g+j,d,C(b,d),o);B(k+g+A,h.substring(A),e,o)}else o.push(k+g,b)}a.e=o}var i={},y;(function(){for(var e=a.concat(l),k=[], 9 | o={},f=0,c=e.length;f=0;)i[n.charAt(j)]=q;q=q[1];n=""+q;o.hasOwnProperty(n)||(k.push(q),o[n]=p)}k.push(/[\S\s]/);y=L(k)})();var s=l.length;return e}function t(a){var l=[],e=[];a.tripleQuotedStrings?l.push(["str",/^(?:'''(?:[^'\\]|\\[\S\s]|''?(?=[^']))*(?:'''|$)|"""(?:[^"\\]|\\[\S\s]|""?(?=[^"]))*(?:"""|$)|'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$))/,p,"'\""]):a.multiLineStrings?l.push(["str",/^(?:'(?:[^'\\]|\\[\S\s])*(?:'|$)|"(?:[^"\\]|\\[\S\s])*(?:"|$)|`(?:[^\\`]|\\[\S\s])*(?:`|$))/, 10 | p,"'\"`"]):l.push(["str",/^(?:'(?:[^\n\r'\\]|\\.)*(?:'|$)|"(?:[^\n\r"\\]|\\.)*(?:"|$))/,p,"\"'"]);a.verbatimStrings&&e.push(["str",/^@"(?:[^"]|"")*(?:"|$)/,p]);var i=a.hashComments;i&&(a.cStyleComments?(i>1?l.push(["com",/^#(?:##(?:[^#]|#(?!##))*(?:###|$)|.*)/,p,"#"]):l.push(["com",/^#(?:(?:define|elif|else|endif|error|ifdef|include|ifndef|line|pragma|undef|warning)\b|[^\n\r]*)/,p,"#"]),e.push(["str",/^<(?:(?:(?:\.\.\/)*|\/?)(?:[\w-]+(?:\/[\w-]+)+)?[\w-]+\.h|[a-z]\w*)>/,p])):l.push(["com",/^#[^\n\r]*/, 11 | p,"#"]));a.cStyleComments&&(e.push(["com",/^\/\/[^\n\r]*/,p]),e.push(["com",/^\/\*[\S\s]*?(?:\*\/|$)/,p]));a.regexLiterals&&e.push(["lang-regex",/^(?:^^\.?|[+-]|[!=]={0,2}|#|%=?|&&?=?|\(|\*=?|[+-]=|->|\/=?|::?|<{1,3}=?|[,;?@[{~]|\^\^?=?|\|\|?=?|break|case|continue|delete|do|else|finally|instanceof|return|throw|try|typeof)\s*(\/(?=[^*/])(?:[^/[\\]|\\[\S\s]|\[(?:[^\\\]]|\\[\S\s])*(?:]|$))+\/)/]);(i=a.types)&&e.push(["typ",i]);a=(""+a.keywords).replace(/^ | $/g,"");a.length&&e.push(["kwd",RegExp("^(?:"+ 12 | a.replace(/[\s,]+/g,"|")+")\\b"),p]);l.push(["pln",/^\s+/,p," \r\n\t\xa0"]);e.push(["lit",/^@[$_a-z][\w$@]*/i,p],["typ",/^(?:[@_]?[A-Z]+[a-z][\w$@]*|\w+_t\b)/,p],["pln",/^[$_a-z][\w$@]*/i,p],["lit",/^(?:0x[\da-f]+|(?:\d(?:_\d+)*\d*(?:\.\d*)?|\.\d\+)(?:e[+-]?\d+)?)[a-z]*/i,p,"0123456789"],["pln",/^\\[\S\s]?/,p],["pun",/^.[^\s\w"-$'./@\\`]*/,p]);return u(l,e)}function D(a,l){function e(a){switch(a.nodeType){case 1:if(j.test(a.className))break;if("BR"===a.nodeName)i(a),a.parentNode&&a.parentNode.removeChild(a); 13 | else for(a=a.firstChild;a;a=a.nextSibling)e(a);break;case 3:case 4:if(o){var b=a.nodeValue,c=b.match(s);if(c){var d=b.substring(0,c.index);a.nodeValue=d;(b=b.substring(c.index+c[0].length))&&a.parentNode.insertBefore(r.createTextNode(b),a.nextSibling);i(a);d||a.parentNode.removeChild(a)}}}}function i(a){function b(a,c){var f=c?a.cloneNode(!1):a,e=a.parentNode;if(e){var e=b(e,1),h=a.nextSibling;e.appendChild(f);for(var i=h;i;i=h)h=i.nextSibling,e.appendChild(i)}return f}for(;!a.nextSibling;)if(a=a.parentNode, 14 | !a)return;for(var a=b(a.nextSibling,0),c;(c=a.parentNode)&&c.nodeType===1;)a=c;f.push(a)}var j=/(?:^|\s)nocode(?:\s|$)/,s=/\r\n?|\n/,r=a.ownerDocument,k;a.currentStyle?k=a.currentStyle.whiteSpace:window.getComputedStyle&&(k=r.defaultView.getComputedStyle(a,p).getPropertyValue("white-space"));var o=k&&"pre"===k.substring(0,3);for(k=r.createElement("LI");a.firstChild;)k.appendChild(a.firstChild);for(var f=[k],c=0;c=0;){var i=l[e];w.hasOwnProperty(i)?window.console&&console.warn("cannot override language handler %s",i):w[i]=a}}function C(a,l){if(!a||!w.hasOwnProperty(a))a=/^\s*=m&&(i+=2);e>=d&&(a+=2)}}catch(w){"console"in window&&console.log(w&&w.stack?w.stack:w)}}var v=["break,continue,do,else,for,if,return,while"],x=[[v,"auto,case,char,const,default,double,enum,extern,float,goto,int,long,register,short,signed,sizeof,static,struct,switch,typedef,union,unsigned,void,volatile"],"catch,class,delete,false,import,new,operator,private,protected,public,this,throw,true,try,typeof"], 18 | F=[x,"alignof,align_union,asm,axiom,bool,concept,concept_map,const_cast,constexpr,decltype,dynamic_cast,explicit,export,friend,inline,late_check,mutable,namespace,nullptr,reinterpret_cast,static_assert,static_cast,template,typeid,typename,using,virtual,where"],G=[x,"abstract,boolean,byte,extends,final,finally,implements,import,instanceof,null,native,package,strictfp,super,synchronized,throws,transient"],H=[G,"as,base,by,checked,decimal,delegate,descending,dynamic,event,fixed,foreach,from,group,implicit,in,interface,internal,into,is,lock,object,out,override,orderby,params,partial,readonly,ref,sbyte,sealed,stackalloc,string,select,uint,ulong,unchecked,unsafe,ushort,var"], 19 | x=[x,"debugger,eval,export,function,get,null,set,undefined,var,with,Infinity,NaN"],I=[v,"and,as,assert,class,def,del,elif,except,exec,finally,from,global,import,in,is,lambda,nonlocal,not,or,pass,print,raise,try,with,yield,False,True,None"],J=[v,"alias,and,begin,case,class,def,defined,elsif,end,ensure,false,in,module,next,nil,not,or,redo,rescue,retry,self,super,then,true,undef,unless,until,when,yield,BEGIN,END"],v=[v,"case,done,elif,esac,eval,fi,function,in,local,set,then,until"],K=/^(DIR|FILE|vector|(de|priority_)?queue|list|stack|(const_)?iterator|(multi)?(set|map)|bitset|u?(int|float)\d*)/, 20 | N=/\S/,O=t({keywords:[F,H,x,"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END"+I,J,v],hashComments:!0,cStyleComments:!0,multiLineStrings:!0,regexLiterals:!0}),w={};j(O,["default-code"]);j(u([],[["pln",/^[^]*(?:>|$)/],["com",/^<\!--[\S\s]*?(?:--\>|$)/],["lang-",/^<\?([\S\s]+?)(?:\?>|$)/],["lang-",/^<%([\S\s]+?)(?:%>|$)/],["pun",/^(?:<[%?]|[%?]>)/],["lang-", 21 | /^]*>([\S\s]+?)<\/xmp\b[^>]*>/i],["lang-js",/^]*>([\S\s]*?)(<\/script\b[^>]*>)/i],["lang-css",/^]*>([\S\s]*?)(<\/style\b[^>]*>)/i],["lang-in.tag",/^(<\/?[a-z][^<>]*>)/i]]),["default-markup","htm","html","mxml","xhtml","xml","xsl"]);j(u([["pln",/^\s+/,p," \t\r\n"],["atv",/^(?:"[^"]*"?|'[^']*'?)/,p,"\"'"]],[["tag",/^^<\/?[a-z](?:[\w-.:]*\w)?|\/?>$/i],["atn",/^(?!style[\s=]|on)[a-z](?:[\w:-]*\w)?/i],["lang-uq.val",/^=\s*([^\s"'>]*(?:[^\s"'/>]|\/(?=\s)))/],["pun",/^[/<->]+/], 22 | ["lang-js",/^on\w+\s*=\s*"([^"]+)"/i],["lang-js",/^on\w+\s*=\s*'([^']+)'/i],["lang-js",/^on\w+\s*=\s*([^\s"'>]+)/i],["lang-css",/^style\s*=\s*"([^"]+)"/i],["lang-css",/^style\s*=\s*'([^']+)'/i],["lang-css",/^style\s*=\s*([^\s"'>]+)/i]]),["in.tag"]);j(u([],[["atv",/^[\S\s]+/]]),["uq.val"]);j(t({keywords:F,hashComments:!0,cStyleComments:!0,types:K}),["c","cc","cpp","cxx","cyc","m"]);j(t({keywords:"null,true,false"}),["json"]);j(t({keywords:H,hashComments:!0,cStyleComments:!0,verbatimStrings:!0,types:K}), 23 | ["cs"]);j(t({keywords:G,cStyleComments:!0}),["java"]);j(t({keywords:v,hashComments:!0,multiLineStrings:!0}),["bsh","csh","sh"]);j(t({keywords:I,hashComments:!0,multiLineStrings:!0,tripleQuotedStrings:!0}),["cv","py"]);j(t({keywords:"caller,delete,die,do,dump,elsif,eval,exit,foreach,for,goto,if,import,last,local,my,next,no,our,print,package,redo,require,sub,undef,unless,until,use,wantarray,while,BEGIN,END",hashComments:!0,multiLineStrings:!0,regexLiterals:!0}),["perl","pl","pm"]);j(t({keywords:J,hashComments:!0, 24 | multiLineStrings:!0,regexLiterals:!0}),["rb"]);j(t({keywords:x,cStyleComments:!0,regexLiterals:!0}),["js"]);j(t({keywords:"all,and,by,catch,class,else,extends,false,finally,for,if,in,is,isnt,loop,new,no,not,null,of,off,on,or,return,super,then,true,try,unless,until,when,while,yes",hashComments:3,cStyleComments:!0,multilineStrings:!0,tripleQuotedStrings:!0,regexLiterals:!0}),["coffee"]);j(u([],[["str",/^[\S\s]+/]]),["regex"]);window.prettyPrintOne=function(a,l,e){var i=document.createElement("PRE"); 25 | i.innerHTML=a;e&&D(i,e);E({g:l,i:e,h:i});return i.innerHTML};window.prettyPrint=function(a){function l(){for(var e=window.PR_SHOULD_USE_CONTINUATION?k.now()+250:Infinity;o=0){var j=j.match(c),h,b;if(b=!j){b=n;for(var m=void 0,d=b.firstChild;d;d=d.nextSibling)var g=d.nodeType,m=g===1?m?b:d:g===3?N.test(d.nodeValue)?b:m:m;b=(h=m===b?void 0:m)&&"CODE"===h.tagName}b&&(j=h.className.match(c));j&&(j=j[1]);b=!1;for(m=n.parentNode;m;m= 26 | m.parentNode)if((m.tagName==="pre"||m.tagName==="code"||m.tagName==="xmp")&&m.className&&m.className.indexOf("prettyprint")>=0){b=!0;break}b||((b=(b=n.className.match(/\blinenums\b(?::(\d+))?/))?b[1]&&b[1].length?+b[1]:!0:!1)&&D(n,b),f={g:j,h:n,i:b},E(f))}}o 0) { 34 | this.concurrency++; 35 | var callback = this.pile.shift(); 36 | callback(next); 37 | } 38 | }, 39 | 40 | callback: function(done){ 41 | 42 | } 43 | 44 | }; 45 | 46 | exports.Parallel = Parallel; 47 | -------------------------------------------------------------------------------- /lib/storm.js: -------------------------------------------------------------------------------- 1 | require.paths.unshift('../supports/uglify-js'); 2 | var uglify = require('uglify-js'), 3 | util = require('util'), 4 | jsp = uglify.parser, 5 | pro = uglify.uglify; 6 | 7 | function compile(code, options) { 8 | var ast = jsp.parse(code, false, true); 9 | var new_ast = stormfy(ast, options); 10 | return pro.gen_code(new_ast, { beautify: true }); 11 | } 12 | 13 | function stormfy(ast, options) { 14 | var w = pro.ast_walker(); 15 | var reply_count = 0; 16 | 17 | options || (options = {}); 18 | var keywords = (options.keywords || (options.keywords = {})); 19 | 20 | var callback_name = options.callback_name || 'callback'; 21 | var async_mark = keywords.async_mark || '$'; 22 | var callback_mark = keywords.callback_mark || '$'; 23 | var async_regex = new RegExp(regExpSafe(async_mark) + '$'); 24 | 25 | return w.with_walkers({ 26 | 'toplevel': function(statments) { 27 | return ['toplevel', walk_block(statments)]; 28 | } 29 | }, function() { 30 | return w.walk(ast); 31 | }); 32 | 33 | function isAsyncCall(name) { 34 | return async_regex.test(name); 35 | } 36 | 37 | function normalizeAsyncCall(name) { 38 | return name.replace(async_regex, ''); 39 | } 40 | 41 | function gen_function(name, args, body, name_to_parent_asyncs) { 42 | var index = args.indexOf(callback_mark), 43 | is_async = index >= 0; 44 | 45 | if (isAsyncCall(name)) { 46 | is_async = true; 47 | name = normalizeAsyncCall(name); 48 | } 49 | 50 | if (is_async) { 51 | args[index >= 0 ? index : args.length] = callback_name; 52 | } 53 | 54 | var type = this[0]; 55 | var block_node = gen_block(body, is_async, name_to_parent_asyncs); 56 | var ret = new_node([type, name, args, block_node.toAST()]); 57 | ret.is_async_caller = is_async; 58 | ret.depend_asyncs = block_node.depend_asyncs; 59 | 60 | return ret; 61 | } 62 | 63 | /** 64 | * fn the function AST to be call 65 | * args the args AST to be passed, callback in ['name', '_'] 66 | */ 67 | function make_async_call(fn, args, options) { 68 | var body = [ 69 | ['if', 70 | ['name', '_err'], 71 | ['return', 72 | ['call', ['name', callback_name], [['name', '_err']]]]]]; 73 | var left_name = options && options.left_name; 74 | var index = indexOfName(args, callback_mark); 75 | index = index >= 0 ? index : args.length; 76 | var reply_name = '_' + (left_name ? left_name.replace(/\./g, '_') : ++reply_count); 77 | args[index] = ['function', '', ['_err', reply_name], body]; 78 | return { 79 | is_async: true, 80 | ast: ['call', fn, args], 81 | callback: args[index], 82 | callback_args: args[index][2], 83 | result: ['name', reply_name], 84 | toAST: function() { 85 | return make_async_ast(this); 86 | }, 87 | defined_asyncs: [], 88 | depend_asyncs: [], 89 | body: body 90 | }; 91 | } 92 | 93 | function walk_block(statments, in_async_fun) { 94 | var node = gen_block(statments, in_async_fun); 95 | return node.toAST(); 96 | } 97 | 98 | function gen_block(statments, in_async_fun, name_to_parent_asyncs) { 99 | var nodes = [], name_depend_asyncs, inner_asyncs = [], 100 | locals = [], depend_parent_asyncs = []; 101 | // seperate blocked_callback and io_asyncs 102 | 103 | name_depend_asyncs = clone(name_to_parent_asyncs, true) || {}; 104 | 105 | for (var i = 0; i < statments.length; i++) { 106 | try { 107 | var node = gen_node(statments[i]); 108 | if (Array.isArray(node)) { 109 | for (var j = 0; j < node.length; j++) { 110 | add_result(node[j]); 111 | } 112 | }else { 113 | //TODO: if not depend_asyncs, depends current all asyncs. node.depend_asyncs = asyncs.slice(); 114 | add_result(node); 115 | } 116 | } catch (e) { 117 | console.log('error to handle statment'); 118 | console.log(statments[i]); 119 | throw e; 120 | } 121 | } 122 | 123 | for (var i = 0; i < nodes.length; i++) { 124 | remove_parent_asyncs(nodes[i]); 125 | } 126 | 127 | var node = new_node('NORESULT_BLOCK', function(end_ast) { 128 | return make_block_ast(nodes, true, end_ast); 129 | }); 130 | node.depend_asyncs = depend_parent_asyncs; 131 | node.inner_asyncs = inner_asyncs; 132 | node.global_depend_inner_asyncs = get_global_depend_inner_asyncs(); 133 | 134 | for (var i = 0; i < inner_asyncs.length; i++) { 135 | inner_asyncs[i].block = node; 136 | } 137 | 138 | return node; 139 | 140 | function add_result(node) { 141 | var type = node.result[0]; 142 | pushAll(nodes, node.defined_asyncs); 143 | pushAll(inner_asyncs, node.defined_asyncs); 144 | if (node.is_async) { 145 | addToSet(inner_asyncs, node); 146 | } 147 | if (type == 'function' || type == 'defun') { 148 | nodes.unshift(node); 149 | } else { 150 | addToSet(nodes, node); 151 | } 152 | remove_parent_asyncs(node); 153 | } 154 | 155 | function get_global_depend_inner_asyncs() { 156 | var ret = {}; 157 | for (var name in name_depend_asyncs) { 158 | if (locals.indexOf(name) < 0) { 159 | var map = filter(name_depend_asyncs[name], function(name, obj) { 160 | return !(obj && obj.is_async && inner_asyncs.indexOf(obj) < 0); 161 | }); 162 | if (map['*'].length > 0) ret[name] = map; 163 | } 164 | } 165 | return ret; 166 | } 167 | 168 | function remove_parent_asyncs(node) { 169 | var depends = node.depend_asyncs; 170 | for (var i = depends.length - 1, async; i >= 0; i--) { 171 | async = depends[i]; 172 | // safe than parent_asyncs.indexOf >= 0 173 | if (inner_asyncs.indexOf(async) < 0) { 174 | addToSet(depend_parent_asyncs, async); 175 | // remove parent dependencies from local, else deadly cycle. 176 | depends.splice(i, 1); 177 | } 178 | } 179 | } 180 | 181 | function set_var_depend_asyncs(ast, asyncs) { 182 | _set_var_depend_asyncs(ast, asyncs, name_depend_asyncs); 183 | } 184 | 185 | function add_var_depend_asyncs(ast, asyncs) { 186 | _add_var_depend_asyncs(ast, asyncs, name_depend_asyncs); 187 | } 188 | 189 | function get_var_depend_asyncs(ast) { 190 | var map = _get_var_depend_asyncs(ast, name_depend_asyncs); 191 | return map ? map['*'] : []; 192 | } 193 | 194 | function _set_var_depend_asyncs(ast, asyncs, map) { 195 | switch (ast[0].toString()) { 196 | case 'name': 197 | return map[ast[1]] = {'*' : asyncs.slice()}; 198 | case 'dot': 199 | map = _add_var_depend_asyncs(ast[1], asyncs, map); 200 | return map && _set_var_depend_asyncs(ast[2], asyncs, map); 201 | case 'sub': 202 | //return a['x'] return a.x 203 | map = _add_var_depend_asyncs(ast[1], asyncs, map); 204 | if (map && ast[2][0] == 'string') { 205 | return _set_var_depend_asyncs(['name', ast[2][1]], asyncs, map); 206 | } 207 | return map; 208 | default: 209 | return null; 210 | } 211 | } 212 | 213 | function _add_var_depend_asyncs(ast, asyncs, map) { 214 | switch (ast[0].toString()) { 215 | case 'name': 216 | map = map[ast[1]] || (map[ast[1]] = {'*' : []}); 217 | addAllToSet(map['*'], asyncs); 218 | return map; 219 | case 'dot': 220 | map = _add_var_depend_asyncs(ast[1], asyncs, map); 221 | return map && _add_var_depend_asyncs(ast[2], asyncs, map); 222 | case 'sub': 223 | //return a['x'] return a.x 224 | map = _add_var_depend_asyncs(ast[1], asyncs, map); 225 | if (map && ast[2][0] == 'string') { 226 | return _add_var_depend_asyncs(['name', ast[2][1]], asyncs, map); 227 | } 228 | return map; 229 | default: 230 | return null; 231 | } 232 | } 233 | 234 | function _get_var_depend_asyncs(ast, map) { 235 | switch (ast[0].toString()) { 236 | case 'name': 237 | return map[ast[1]]; 238 | case 'dot': 239 | var map = _get_var_depend_asyncs(ast[1], map); 240 | return _get_var_depend_asyncs(ast[2], map) || map; 241 | case 'sub': 242 | var map = _get_var_depend_asyncs(ast[1], map); 243 | if (map && ast[2][0] == 'string') { 244 | return _get_var_depend_asyncs(['name', ast[2][1]], map) || map; 245 | } 246 | return map; 247 | default: 248 | return null; 249 | } 250 | } 251 | 252 | function _var(ast) { 253 | var defs = ast[1], 254 | rdefs = [], 255 | ret = new_node([ast[0], rdefs]); 256 | for (var j = 0; j < defs.length; j++) { 257 | var def = defs[j]; 258 | locals.push(def[0]); 259 | if (def.length > 1) { 260 | var def1 = gen_node(def[1], {left_name: def[0]}); 261 | rdefs.push([def[0], def1.result]); 262 | join_node(ret, def1); 263 | // we should not modify depend_asyncs outside gen_node 264 | set_var_depend_asyncs(['name', def[0]], ret.depend_asyncs); 265 | } else { 266 | // reset parent depend because redefined. 267 | set_var_depend_asyncs(['name', def[0]], []); 268 | rdefs.push(def); 269 | } 270 | } 271 | return ret; 272 | } 273 | 274 | function _call(ast, options) { 275 | var i = 0, args = ast[2], rargs = [], self_is_async, ret; 276 | for (; i < args.length; i++) { 277 | var arg = args[i]; 278 | if (arg[0] == 'name' && arg[1] == callback_mark) { 279 | self_is_async = true; 280 | rargs[i] = new_node(arg); 281 | } else { 282 | rargs[i] = gen_node(arg); 283 | } 284 | } 285 | 286 | var func = gen_node(ast[1], {calling: true}); 287 | self_is_async || (self_is_async = func.is_async_caller); 288 | if (self_is_async) { 289 | // process all asyncs, and make ret 290 | ret = make_async_call(func.result, rargs.map(function(rargs) {return rargs.result}), options); 291 | }else { 292 | ret = new_node([ast[0], func.result, rargs.map(function(rarg) {return rarg.result})]); 293 | } 294 | 295 | rargs.unshift(func); 296 | 297 | for (var j = 0; j < rargs.length; j++) { 298 | var rarg = rargs[j]; 299 | addAllToSet(ret.defined_asyncs, rarg.defined_asyncs); 300 | addAllToSet(ret.depend_asyncs, rarg.depend_asyncs); 301 | } 302 | 303 | if (self_is_async) { 304 | ret.defined_asyncs.push(ret); 305 | ret.depend_asyncs.push(ret); 306 | } 307 | return ret; 308 | } 309 | 310 | function _array(ast) { 311 | var arr = ast[1]; 312 | var rarr = []; 313 | var ret = new_node([ast[0], rarr]); 314 | for (var i = 0; i < arr.length; i++) { 315 | var node = gen_node(arr[i]); 316 | join_node(ret, node); 317 | rarr.push(node.result); 318 | } 319 | return ret; 320 | } 321 | 322 | function _object(ast) { 323 | var obj = ast[1]; 324 | var robj = []; 325 | var ret = new_node([ast[0], robj]); 326 | for (var i = 0; i < obj.length; i++) { 327 | var pair = obj[i]; 328 | var node = gen_node(pair[1]); 329 | join_node(ret, node); 330 | robj.push([pair[0], node.result]); 331 | } 332 | return ret; 333 | } 334 | 335 | function _block(ast) { 336 | var block = gen_block(ast[1], in_async_fun, name_depend_asyncs); 337 | var ret = new_node([ast[0], block.result]); 338 | join_node(ret, block); 339 | block.inner_asyncs = ret.inner_asyncs; 340 | return ret; 341 | } 342 | 343 | function _for(ast) { 344 | var init = gen_node(ast[1]), 345 | condition = gen_node(ast[2]), 346 | step = gen_node(ast[3]), 347 | body_ast = ast[4], 348 | next_body, body, is_serial; 349 | 350 | if (body_ast[0] == 'block') { 351 | body_ast = body_ast[1]; 352 | } else { 353 | body_ast = [body_ast]; 354 | } 355 | 356 | body = gen_block(body_ast, in_async_fun, name_depend_asyncs); 357 | var _reply_count = reply_count; 358 | next_body = gen_block(body_ast, in_async_fun, body.global_depend_inner_asyncs); 359 | reply_count = _reply_count; 360 | var ret; 361 | // next_body depend_asyncs means depend previous asyncs (global_depend_inner_asyncs) 362 | if (next_body.depend_asyncs.length > 0) { 363 | is_serial = true; 364 | ret = new_node('NORESULT', function() { 365 | return make_serial_loop_ast(init, condition, step, body, this.nodes); 366 | }); 367 | ret.is_async = true; 368 | for (var name in body.global_depend_inner_asyncs) { 369 | set_var_depend_asyncs(['name', name], [ret]); 370 | } 371 | } else { 372 | ret = new_node([ast[0], init.result, condition.result, step.result, ['block', body.toAST()]]); 373 | } 374 | join_node(ret, init); 375 | join_node(ret, condition); 376 | join_node(ret, step); 377 | addAllToSet(ret.depend_asyncs, body.depend_asyncs); 378 | return ret; 379 | } 380 | 381 | function _if(ast) { 382 | var condition = gen_node(ast[1]), 383 | then_ast = ast[2], 384 | else_ast = ast[3], 385 | then_node, else_node, ret; 386 | 387 | if (then_ast[0] == 'block') { 388 | then_ast = then_ast[1]; 389 | } else { 390 | then_ast = [then_ast]; 391 | } 392 | 393 | if (!else_ast) { 394 | else_ast = []; 395 | } else if (else_ast[0] == 'block') { 396 | else_ast = else_ast[1]; 397 | } else { 398 | else_ast = [else_ast]; 399 | } 400 | 401 | then_node = gen_block(then_ast, in_async_fun, name_depend_asyncs); 402 | else_node = gen_block(else_ast, in_async_fun, name_depend_asyncs); 403 | 404 | // update var depend asyncs map 405 | var is_async = false, ret = new_node(); 406 | for (var name in then_node.global_depend_inner_asyncs) { 407 | set_var_depend_asyncs(['name', name], [ret]); 408 | is_async = true; 409 | } 410 | for (var name in else_node.global_depend_inner_asyncs) { 411 | set_var_depend_asyncs(['name', name], [ret]); 412 | is_async = true; 413 | } 414 | 415 | if (is_async) { 416 | ret.result = 'NORESULT-IF'; 417 | ret.toAST = function() { 418 | return make_if_ast(condition, then_node, else_node, this.nodes); 419 | }; 420 | ret.is_async = true; 421 | } else { 422 | ret.result = [ast[0], condition.result, ['block', then_node.toAST()], 423 | else_ast.length > 0 && ['block', else_node.toAST()]]; 424 | } 425 | join_node(ret, condition); 426 | addAllToSet(ret.depend_asyncs, then_node.depend_asyncs); 427 | addAllToSet(ret.depend_asyncs, else_node.depend_asyncs); 428 | return ret; 429 | 430 | } 431 | 432 | /** 433 | * left_name var left_name = foo(_); 434 | * is_sub ['name', 'foo'] foo is after dot or sub 435 | */ 436 | function gen_node(ast, options) { 437 | var type = ast[0], ret; 438 | var is_sub = options && options.is_sub; 439 | switch (type.toString()) { 440 | case 'array': 441 | return _array(ast); 442 | case 'object': 443 | return _object(ast); 444 | case 'block': 445 | return _block(ast); 446 | case 'for': 447 | return _for(ast); 448 | case 'if': 449 | return _if(ast); 450 | case 'binary': 451 | var left = gen_node(ast[2]); 452 | var right = gen_node(ast[3]); 453 | ret = new_node([type, ast[1], left.result, right.result]); 454 | join_node(ret, left); 455 | join_node(ret, right); 456 | break; 457 | case 'assign': 458 | var left = gen_node(ast[2]); 459 | var name = astToNameStr(ast[2]); 460 | var right = gen_node(ast[3], {left_name: name}); 461 | ret = new_node([type, ast[1], left.result, right.result]); 462 | join_node(ret, left); 463 | join_node(ret, right); 464 | if (ret.depend_asyncs.length > 0) { 465 | set_var_depend_asyncs(ast[2], right.depend_asyncs); 466 | } 467 | break; 468 | case 'stat': 469 | var stat = gen_node(ast[1]); 470 | if (stat.is_async) return stat; 471 | ret = new_node([type, stat.result]); 472 | join_node(ret, stat); 473 | break; 474 | case 'return': 475 | var right = gen_node(ast[1], {left_name: 'result'}); 476 | if (in_async_fun) { 477 | ret = new_node(['call', ['name', callback_name], [['name', 'null'], right.result]]); 478 | } else { 479 | ret = new_node([ast[0], right.result]); 480 | } 481 | join_node(ret, right); 482 | break; 483 | case 'throw': 484 | var right = gen_node(ast[1]); 485 | if (in_async_fun) { 486 | ret = new_node(['call', ['name', callback_name], [right.result]]); 487 | } else { 488 | ret = new_node([ast[0], right.result]); 489 | } 490 | join_node(ret, right); 491 | break; 492 | case 'function': 493 | case 'defun': 494 | return gen_function.apply(ast, ast.slice(1).concat(name_depend_asyncs)); 495 | case 'var': 496 | return _var(ast); 497 | case 'call': 498 | return _call(ast, options); 499 | case 'name': 500 | ret = new_node(); 501 | if (options && options.calling && isAsyncCall(ast[1])) { 502 | ret.is_async_caller = true; 503 | ast[1] = normalizeAsyncCall(ast[1]); 504 | } 505 | ret.result = ast; 506 | if (!is_sub) { 507 | addAllToSet(ret.depend_asyncs, get_var_depend_asyncs(ast)); 508 | } 509 | break; 510 | case 'dot': 511 | ret = new_node(); 512 | if (options && options.calling && isAsyncCall(ast[2])) { 513 | ret.is_async_caller = true; 514 | ast[2] = normalizeAsyncCall(ast[2]); 515 | } 516 | var left = gen_node(ast[1], options); 517 | ret.result = [type, left.result, ast[2]]; 518 | join_node(ret, left); 519 | if (!is_sub) { 520 | addAllToSet(ret.depend_asyncs, get_var_depend_asyncs(ast)); 521 | } 522 | break; 523 | case 'sub': 524 | var name = astToNameStr(ast); 525 | var left = gen_node(ast[1], options); 526 | var right = gen_node(ast[2]); 527 | ret = new_node([type, left.result, right.result]); 528 | join_node(ret, left); 529 | join_node(ret, right); 530 | if (!is_sub) { 531 | addAllToSet(ret.depend_asyncs, get_var_depend_asyncs(ast)); 532 | } 533 | break; 534 | default: 535 | var result = [ast[0]]; 536 | ret = new_node(result); 537 | for (var i = 1; i < ast.length; i++) { 538 | if (Array.isArray(ast[i])) { 539 | var node = gen_node(ast[i]); 540 | result.push(node.result); 541 | join_node(ret, node); 542 | } else { 543 | result.push(ast[i]); 544 | } 545 | } 546 | } 547 | return ret; 548 | } 549 | 550 | } 551 | /* ======== end gen_block() ======== */ 552 | 553 | } 554 | 555 | /* ======== end stormfy() ======== */ 556 | 557 | /** 558 | * 559 | * result is what other nodes embed this node as 560 | * e.g. result could be ['name', '_r1'] but toAST is and ['call', ...] 561 | */ 562 | function new_node(result, toAST) { 563 | return { 564 | is_async: false, 565 | defined_asyncs: [], 566 | depend_asyncs: [], 567 | result: result, 568 | toAST: toAST 569 | }; 570 | } 571 | 572 | function join_node(left, right) { 573 | addAllToSet(left.defined_asyncs, right.defined_asyncs); 574 | addAllToSet(left.depend_asyncs, right.depend_asyncs); 575 | if (right.is_async) { 576 | addToSet(left.depend_asyncs, right); 577 | } 578 | } 579 | 580 | /*======== make_block_ast ========*/ 581 | 582 | function get_depends_roots(node) { 583 | if (node.roots) return node.roots; 584 | // remove self 585 | var depends = node.depend_asyncs; 586 | remove(depends, node); 587 | if (depends.length === 0) { 588 | return node.roots = []; 589 | } else { 590 | node.roots = []; 591 | for (var i = 0; i < depends.length; i++) { 592 | var roots = get_depends_roots(depends[i]); 593 | addAllToSet(node.roots, roots.length > 0 ? roots : [depends[i]]); 594 | } 595 | } 596 | return node.roots; 597 | } 598 | 599 | function get_depends_leafs(node) { 600 | if (node.leafs) return node.leafs; 601 | var depends = node.depend_asyncs; 602 | remove(depends, node); 603 | var leafs = depends.slice(); 604 | for (var i = depends.length - 1; i >= 0; i--) { 605 | var depdep = depends[i].depend_asyncs; 606 | for (var j = 0; j < depdep.length; j++) { 607 | if (depends[i] !== depdep[j]) 608 | remove(leafs, depdep[j]); 609 | } 610 | } 611 | return node.leafs = leafs; 612 | } 613 | 614 | function make_nodes_tree(nodes, top, end_ast) { 615 | // each async could have { nodes, multi_depends } 616 | top || (top = { 617 | nodes: [], 618 | multi_depends: [], 619 | used_leafs: [] 620 | }); 621 | 622 | if(end_ast){ 623 | var end_node = new_node(end_ast); 624 | for (var i = 0; i < nodes.length; i++) { 625 | var node = nodes[i]; 626 | if(node.is_async){ 627 | end_node.depend_asyncs.push(node); 628 | } 629 | } 630 | nodes.push(end_node); 631 | } 632 | 633 | for (var i = 0; i < nodes.length; i++) { 634 | var node = nodes[i]; 635 | // reset roots for each levels 636 | node.roots = null; 637 | var roots = get_depends_roots(node); 638 | var len = roots.length; 639 | var leafs = get_depends_leafs(node); 640 | if (len === 0) { 641 | top.nodes.push(node); 642 | } else if (leafs.length === 1) { 643 | (leafs[0].nodes || (leafs[0].nodes = [])).push(node); 644 | } else { 645 | node.is_multi_depends = true; 646 | top.multi_depends.push(node); 647 | addAllToSet(top.used_leafs, leafs); 648 | // defined_asyncs is equals referenced async. 649 | // if in multi_depends, all referenced async must be outside referenced. 650 | for (var j = 0; j < node.defined_asyncs.length; j++) { 651 | var ref_node = node.defined_asyncs[j]; 652 | if (ref_node !== node) { 653 | ref_node.out_ref = true; 654 | } 655 | } 656 | } 657 | } 658 | return top; 659 | } 660 | 661 | function gen_leafs_depend_flag(used_leafs) { 662 | for (var i = 0; i < used_leafs.length; i++) { 663 | var leaf = used_leafs[i]; 664 | leaf.index = i; 665 | leaf.flag = 1 << i; 666 | (leaf.nodes || (leaf.nodes = [])).push(new_node(['stat', ['call', ['name', 'trigger'], [['num', leaf.flag]]]])); 667 | } 668 | } 669 | 670 | function gen_nodes_depend_flag(multi_depends) { 671 | for (var i = 0; i < multi_depends.length; i++) { 672 | var flag = 0, node = multi_depends[i]; 673 | for (var j = 0; j < node.leafs.length; j++) { 674 | flag |= node.leafs[j].flag; 675 | } 676 | node.depend_flag = flag; 677 | } 678 | } 679 | 680 | function make_block_ast(nodes, toplevel, end_ast) { 681 | var bodys = []; 682 | var defs = []; 683 | 684 | if (toplevel) { 685 | set_vars_ast(nodes, defs); 686 | } 687 | 688 | var tree = make_nodes_tree(nodes, null, end_ast); 689 | gen_leafs_depend_flag(tree.used_leafs); 690 | set_out_ref_defs(nodes, defs); 691 | 692 | var nodes = tree.nodes; 693 | var multi_depends = tree.multi_depends; 694 | gen_nodes_depend_flag(multi_depends); 695 | var multi_groups = group_multi_depends(multi_depends); 696 | if (multi_groups.length > 0) { 697 | pushAll(bodys, make_triggers(multi_groups, defs)); 698 | } 699 | 700 | if (defs.length > 0) { 701 | bodys.unshift(['var', defs]); 702 | } 703 | 704 | for (var i = 0; i < nodes.length; i++) { 705 | var node = nodes[i]; 706 | bodys.push( 707 | node.toAST ? node.toAST() : node.result); 708 | } 709 | return bodys; 710 | } 711 | 712 | function make_nodes_ast(nodes) { 713 | var bodys = []; 714 | 715 | for (var i = 0; i < nodes.length; i++) { 716 | var node = nodes[i]; 717 | bodys.push( 718 | node.toAST ? node.toAST() : node.result); 719 | } 720 | return bodys; 721 | } 722 | 723 | function make_trigger(group_flag, nodes, only_one) { 724 | var block = make_nodes_ast(nodes, true, false), arg_name, done_ast, fn_name; 725 | if (only_one) { 726 | arg_name = '_flag'; 727 | fn_name = 'trigger'; 728 | done_ast = ['assign', '|', ['name', '_done'], ['name', '_flag']]; 729 | } else { 730 | arg_name = '_index'; 731 | done_ast = ['name', '_done']; 732 | var remove_me = ['stat', ['call', 733 | ['dot', ['name', 'triggers'], 'splice'], 734 | [ 735 | ['name', '_index'], 736 | ['num', 1]]]]; 737 | block.unshift(remove_me); 738 | } 739 | 740 | return ['function', fn_name, 741 | [arg_name], 742 | [ 743 | ['if', 744 | ['binary', '===', 745 | ['num', group_flag], 746 | ['binary', '&', done_ast, 747 | ['num', group_flag]]], 748 | ['block', block]]]]; 749 | } 750 | 751 | function group_multi_depends(multi_depends) { 752 | var groups = []; 753 | multi_depends.sort(function(a, b) {return a.depend_flag > b.depend_flag}); 754 | var group_flag = -1, nodes, triggers = []; 755 | for (var i = 0, node; i < multi_depends.length; i++) { 756 | node = multi_depends[i]; 757 | if (node.depend_flag !== group_flag) { 758 | if (nodes && nodes.length > 0) { 759 | groups.push([group_flag, nodes]); 760 | } 761 | group_flag = node.depend_flag; 762 | nodes = []; 763 | } 764 | nodes.push(node); 765 | } 766 | if (nodes && nodes.length > 0) { 767 | // last group 768 | groups.push([group_flag, nodes]); 769 | } 770 | return groups; 771 | } 772 | 773 | function make_triggers(groups, defs) { 774 | defs.push(['_done', ['num', 0]]); 775 | if (groups.length === 1) { 776 | return [make_trigger(groups[0][0], groups[0][1], true/* only_one */)]; 777 | } 778 | 779 | var triggers = []; 780 | 781 | for (var i = 0; i < groups.length; i++) { 782 | var group = groups[i]; 783 | triggers.push(make_trigger(group[0], group[1])); 784 | } 785 | 786 | return [['var', [['triggers', ['array', triggers]]]], make_fn_trigger()]; 787 | } 788 | 789 | function make_fn_trigger() { 790 | var fn_trigger = ['defun', 'trigger', 791 | ['_flag'], 792 | [ 793 | ['stat', ['assign', '|', ['name', '_done'], ['name', '_flag']]], 794 | ['for', 795 | ['var', 796 | [ 797 | ['i', 798 | ['binary', '-', 799 | ['dot', 800 | ['name', 'triggers'], 'length'], 801 | ['num', 1]]]]], 802 | ['binary', '>=', 803 | ['name', 'i'], 804 | ['num', 0]], 805 | ['unary-postfix', '--', 806 | ['name', 'i']], 807 | ['block', 808 | [ 809 | ['stat', 810 | ['call', 811 | ['sub', 812 | ['name', 'triggers'], 813 | ['name', 'i']], 814 | [['name', 'i']]]]]]]]]; 815 | return fn_trigger; 816 | } 817 | 818 | function make_async_ast(async) { 819 | if (async.out_ref) { 820 | // use _r1 = __r1 when outside referenced _r1. 821 | async.callback_args[1] = '_' + async.result[1]; 822 | async.body.push(['stat', ['assign', true, 823 | async.result, ['name', '_' + async.result[1]]]]); 824 | } 825 | 826 | if (async.nodes && async.nodes.length > 0) { 827 | pushAll(async.body, make_nodes_ast(async.nodes)); 828 | } 829 | 830 | return ['stat', async.ast]; 831 | } 832 | 833 | function set_out_ref_defs(nodes, defs) { 834 | for (var i = 0; i < nodes.length; i++) { 835 | var node = nodes[i]; 836 | if (node.is_async && node.out_ref) { 837 | defs.push([node.result[1]]); 838 | } 839 | } 840 | } 841 | 842 | function set_vars_ast(nodes, defs) { 843 | for (var i = 0; i < nodes.length; i++) { 844 | var node = nodes[i]; 845 | var result = node.result; 846 | if (result[0] == 'var' && node.depend_asyncs.length > 0) { 847 | var _defs = result[1]; 848 | var _i = i; 849 | for (var j = 0; j < _defs.length; j++) { 850 | var def = _defs[j]; 851 | defs.push([def[0]]); 852 | if (def.length > 1) { 853 | var assign_node = new_node(['stat', ['assign', true, ['name', def[0]], def[1]]]); 854 | join_node(assign_node, node); 855 | nodes.splice(++i, 0, assign_node); 856 | } 857 | } 858 | nodes.splice(_i, 1); 859 | i--; 860 | } 861 | } 862 | } 863 | 864 | /*======== end make_block_ast ========*/ 865 | 866 | /*======== make special ast ========*/ 867 | 868 | function make_serial_loop_ast(init_vars, condition, step, block_node, nodes) { 869 | // vars 870 | var init_defs = []; 871 | var init_values = []; 872 | var next_args = []; 873 | var temp, index; 874 | if (init_vars) { 875 | temp = init_vars.result; 876 | if (temp[0] == 'var') { 877 | temp = temp[1]; 878 | for (var i = 0; i < temp.length; i++) { 879 | var def = temp[i]; 880 | init_defs.push(def[0]); 881 | init_values.push(def[1] || ['name', 'undefined']); 882 | next_args.push(['name', def[0]]); 883 | } 884 | } 885 | } 886 | 887 | var body = block_node.toAST(['stat', ['call', ['name', 'next'], next_args]]); 888 | 889 | if (step) { 890 | temp = step.result; 891 | temp = temp[0] == 'seq' ? temp.slice(1) : [temp]; 892 | for (var i = 0; i < temp.length; i++) { 893 | var ast = temp[i]; 894 | if ((ast[0] == 'unary-postfix' || ast[0] == 'unary-prefix' || ast[0] == 'assign') && 895 | ast[2][0] == 'name' && 896 | (index = init_defs.indexOf(ast[2][1])) >= 0) { 897 | 898 | next_args[index] = ast.slice(); 899 | if (ast[0] == 'unary-postfix') { 900 | next_args[index][0] = 'unary-prefix'; 901 | } 902 | } else { 903 | body.push(['stat', ast]); 904 | } 905 | } 906 | } 907 | 908 | var if_ast = ['if', condition.result, ['block', body]]; 909 | 910 | if (nodes && nodes.length > 0) { 911 | var nodes_ast; 912 | if (use_nodes_fn = (nodes.length > 1 || nodes[0].is_async)) { 913 | init_defs.push('after'); 914 | init_values.push(['function', , [], make_nodes_ast(nodes)]); 915 | nodes_ast = ['stat', ['call', ['name', 'after'], []]]; 916 | } else { 917 | nodes_ast = ['block', 918 | [nodes[0].toAST ? nodes[0].toAST() : nodes[0].result]]; 919 | } 920 | if_ast.push(nodes_ast); 921 | } 922 | 923 | var fn_next = ['function', 'next', init_defs, [if_ast]]; 924 | return ['stat', ['call', fn_next, init_values]]; 925 | } 926 | 927 | function make_if_ast(condition, then_node, else_node, nodes) { 928 | 929 | var init_values = []; 930 | var init_defs = []; 931 | var then_ast = then_node.toAST(); 932 | var else_ast = else_node.toAST(); 933 | 934 | var if_ast = ['if', condition.result, ['block', then_ast]]; 935 | 936 | if (nodes && nodes.length > 0) { 937 | var nodes_ast; 938 | if (use_nodes_fn = (nodes.length > 1 || nodes[0].is_async)) { 939 | init_defs.push('after'); 940 | init_values.push(['function', , [], make_nodes_ast(nodes)]); 941 | nodes_ast = ['stat', ['call', ['name', 'after'], []]]; 942 | } else { 943 | nodes_ast = nodes[0].toAST ? nodes[0].toAST() : nodes[0].result; 944 | } 945 | then_ast.push(nodes_ast); 946 | else_ast.push(nodes_ast); 947 | if_ast.push(['block', else_ast]); 948 | 949 | if (use_nodes_fn) { 950 | var fn_condition = ['function', '', init_defs, [if_ast]]; 951 | return ['stat', ['call', fn_condition, init_values]]; 952 | } 953 | } else { 954 | if (else_ast.length > 0) { 955 | if_ast.push(['block', else_ast]); 956 | } 957 | } 958 | 959 | return if_ast; 960 | } 961 | /*======== end make special ast ========*/ 962 | 963 | /*======== utils ========*/ 964 | 965 | function regExpSafe(str) { 966 | return str.replace(/[$%()*+.?\[\\\]{|}]/g, "\\$&"); 967 | } 968 | 969 | function pushAll(arr, another) { 970 | if (!another) return arr; 971 | for (var i = 0; i < another.length; i++) { 972 | arr.push(another[i]); 973 | } 974 | return arr; 975 | } 976 | 977 | function addToSet(arr, obj) { 978 | if (arr.indexOf(obj) < 0) 979 | arr.push(obj); 980 | } 981 | 982 | 983 | function addAllToSet(arr, another) { 984 | if (!another) return; 985 | for (var i = 0; i < another.length; i++) { 986 | addToSet(arr, another[i]); 987 | } 988 | } 989 | 990 | function remove(arr, obj) { 991 | var index = arr.indexOf(obj); 992 | if (index >= 0) arr.splice(index, 1); 993 | } 994 | 995 | function removeAll(arr, another) { 996 | for (var i = 0; i < another.length; i++) { 997 | remove(arr, another[i]); 998 | } 999 | } 1000 | 1001 | /** 1002 | * merge another to obj, array value will push if not exists 1003 | */ 1004 | function merge(obj, another) { 1005 | for (var i in another) { 1006 | if (! obj[i]) { 1007 | obj[i] = clone(another[i]); 1008 | } else if (Array.isArray(another[i])) { 1009 | addAllToSet(obj[i] || (obj[i] = []), another[i]); 1010 | } else { 1011 | merge(obj[i], another[i]); 1012 | } 1013 | } 1014 | return obj; 1015 | } 1016 | 1017 | function filter(obj, fn) { 1018 | if (typeof obj === 'object' && obj !== null) { 1019 | var new_obj = Array.isArray(obj) ? [] : {}; 1020 | for (var i in obj) { 1021 | if (fn(i, obj[i])) { 1022 | if (Array.isArray(obj)) { 1023 | new_obj.push(obj[i]); 1024 | } else { 1025 | new_obj[i] = filter(obj[i], fn); 1026 | } 1027 | } 1028 | } 1029 | return new_obj; 1030 | } 1031 | return obj; 1032 | } 1033 | 1034 | function clone(obj, recusive) { 1035 | // rule is Array will not clone a.a = a, will die, a.a = [a] is okay. 1036 | if (Array.isArray(obj)) return obj.slice(); 1037 | if (typeof obj === 'object' && obj !== null) { 1038 | var new_obj = {}; 1039 | for (var i in obj) { 1040 | new_obj[i] = recusive ? clone(obj[i]) : obj[i]; 1041 | } 1042 | return new_obj; 1043 | } 1044 | return obj; 1045 | } 1046 | 1047 | /*======== ast utils ========*/ 1048 | 1049 | function indexOfName(args, name) { 1050 | for (var i = 0; i < args.length; i++) { 1051 | if (args[i][0] == 'name' && args[i][1] == name) 1052 | return i; 1053 | } 1054 | return -1; 1055 | } 1056 | 1057 | // sub, dot 1058 | function astToNameStr(ast) { 1059 | switch (ast[0].toString()) { 1060 | case 'name': 1061 | return ast[1]; 1062 | case 'dot': 1063 | var left = astToNameStr(ast[1]); 1064 | return left && (left + '.' + ast[2]); 1065 | case 'sub': 1066 | //return a['x'] return a.x 1067 | var left = astToNameStr(ast[1]); 1068 | if (ast[2][0] == 'string') { 1069 | return left && (left + '.' + ast[2][1]); 1070 | } 1071 | default: 1072 | return null; 1073 | } 1074 | } 1075 | 1076 | exports.astToStr = function astToStr(ast, indent) { 1077 | var ret = []; 1078 | for (var i = 0; i < ast.length; i++) { 1079 | if (Array.isArray(ast[i])) { 1080 | ret.push('\n' + astToStr(ast[i], indent + ' ')); 1081 | } else if (typeof ast[i] === 'string') { 1082 | ret.push('\'' + ast[i] + '\''); 1083 | } else { 1084 | ret.push(ast[i]); 1085 | } 1086 | } 1087 | return indent + '[' + ret.join(',') + ']'; 1088 | }; 1089 | 1090 | exports.stormfy = stormfy; 1091 | exports.compile = compile; 1092 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "author": "Gui Lin ", 3 | "name": "storm", 4 | "description": "StormJS, high performance, intelligence compiler.", 5 | "version": "0.0.1", 6 | "homepage": "http://guileen.github.com/stormjs/", 7 | "repository": { 8 | "type": "git", 9 | "url": "git://github.com/guileen/stormjs.git" 10 | }, 11 | "directories": { 12 | }, 13 | "engines": { 14 | "node": "*" 15 | }, 16 | "dependencies": { 17 | "uglify-js": "*" 18 | }, 19 | "devDependencies": {}, 20 | "bin" : { 21 | "storm": "./bin/storm" 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /show.html: -------------------------------------------------------------------------------- 1 | 2 | 3 | 4 | StormJS, Itelligence compiler for nodejs 5 | 46 | 47 | 48 | 49 |
50 | 51 |
52 |

StormJS, itelligence compiler for nodejs

53 |

Fork me on github

54 |
55 |

56 |

57 |

58 |
59 | 60 | 
 61 |
62 |
63 |
64 | 

 65 |       
Share your code

 66 |       
 67 |     

 68 |     
 69 |     
 92 |     
 93 |     
 97 |     
 98 |     
102 |     
103 |     
104 |     
105 |     
152 |   
153 | 
154 | 


--------------------------------------------------------------------------------