├── .gitignore
├── .travis.yml
├── bin
└── common-node
├── examples
├── traceur.js
├── hello.js
├── sleep.js
├── static.js
├── http.js
├── chat.js
├── spawn.js
├── twitter.js
└── base64.js
├── benchmarks
├── set-timeout
│ ├── node.js
│ ├── common-node.js
│ └── ringo.js
├── hello-world
│ ├── common-node.js
│ ├── node.js
│ └── ringo.js
├── buffer-alloc
│ ├── common-node.js
│ ├── node.js
│ └── ringo.js
├── file-read
│ ├── node.js
│ ├── ringo.js
│ └── common-node.js
├── file-stream
│ ├── common-node.js
│ ├── ringo.js
│ └── node.js
├── string-alloc
│ ├── node.js
│ ├── common-node.js
│ └── ringo.js
├── no-alloc
│ ├── ringo.js
│ ├── common-node.js
│ └── node.js
├── run
├── graph
└── run.js
├── test
├── binary
│ ├── all.js
│ ├── bytearray-encodings-tests.js
│ ├── bytestring-encodings-tests.js
│ ├── bytestring-tests.js
│ └── bytearray-tests.js
├── jsgi.js
├── all.js
├── fs-base
│ ├── all.js
│ ├── dirname.js
│ ├── normal.js
│ ├── extension.js
│ ├── relative.js
│ ├── path.js
│ ├── resolve.js
│ ├── main.js
│ └── iterator.js
├── subprocess.js
├── http.js
└── io.js
├── lib
├── all.js
├── global.js
├── console.js
├── run.js
├── test.js
├── assert.js
├── httpserver.js
├── system.js
├── socket.js
├── subprocess.js
├── httpclient.js
└── ringo
│ └── httpclient.js
├── tools
└── jsdoc
│ ├── hosted.html
│ ├── static.html
│ ├── style.css
│ └── jsdoc.css
├── doc
├── static
│ ├── style.css
│ ├── jsdoc.css
│ └── jsdoc.js
├── all
│ └── index.html
├── test
│ └── index.html
├── index.html
├── jsgi
│ └── index.html
├── system
│ └── index.html
└── httpclient
│ └── index.html
├── package.json
└── README.md
/.gitignore:
--------------------------------------------------------------------------------
1 | /node_modules/
--------------------------------------------------------------------------------
/.travis.yml:
--------------------------------------------------------------------------------
1 | language: node_js
2 | node_js:
3 | - "0.10"
4 |
--------------------------------------------------------------------------------
/bin/common-node:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | process.argv.shift();
3 | process.execPath = 'common-node';
4 | require('../lib/run')();
5 |
6 |
--------------------------------------------------------------------------------
/examples/traceur.js:
--------------------------------------------------------------------------------
1 | var {HttpClient} = require('httpclient');
2 |
3 | console.log(new HttpClient({
4 | url: 'http://google.com'
5 | }).finish().body.read(null).decodeToString());
--------------------------------------------------------------------------------
/benchmarks/set-timeout/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 |
3 | http.createServer(function(req, res) {
4 | setTimeout(function() {
5 | res.writeHead(200);
6 | res.end();
7 | }, 20);
8 | }).listen(8080);
--------------------------------------------------------------------------------
/benchmarks/set-timeout/common-node.js:
--------------------------------------------------------------------------------
1 | var sleep = require('system').sleep;
2 |
3 | exports.app = function() {
4 | sleep(20);
5 | return {
6 | status:200,
7 | headers:{},
8 | body:[]
9 | };
10 | };
--------------------------------------------------------------------------------
/examples/hello.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileOverview Hello World example.
3 | */
4 |
5 | exports.app = function(request) {
6 | return {
7 | status: 200,
8 | headers: {},
9 | body: ['Hello World!\n']
10 | };
11 | };
--------------------------------------------------------------------------------
/benchmarks/hello-world/common-node.js:
--------------------------------------------------------------------------------
1 | exports.app = function() {
2 | return {
3 | status:200,
4 | headers:{
5 | 'Content-Type':'text/plain; charset=utf-8'
6 | },
7 | body:['Hello World!\n']
8 | };
9 | };
--------------------------------------------------------------------------------
/benchmarks/hello-world/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 |
3 | http.createServer(function(req, res) {
4 | res.writeHead(200, {"Content-Type":"text/plain; charset=utf-8"});
5 | res.end('Hello World!\n');
6 | }).listen(8080);
--------------------------------------------------------------------------------
/benchmarks/set-timeout/ringo.js:
--------------------------------------------------------------------------------
1 | exports.app = function() {
2 | java.lang.Thread.sleep(100);
3 | return {
4 | status : 200,
5 | headers : {},
6 | body : []
7 | };
8 | };
9 |
10 | if (require.main === module) {
11 | require("ringo/httpserver").main(module.id);
12 | }
13 |
--------------------------------------------------------------------------------
/benchmarks/buffer-alloc/common-node.js:
--------------------------------------------------------------------------------
1 | var ByteArray = require('binary').ByteArray;
2 |
3 | var n = 128 * 1024;
4 | exports.app = function(request) {
5 | var b = new ByteArray(n);
6 | return {
7 | status:200,
8 | headers:{
9 | "Content-Type":"text/plain"
10 | },
11 | body:[b]
12 | };
13 | };
--------------------------------------------------------------------------------
/benchmarks/buffer-alloc/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var Buffer = require('buffer').Buffer;
3 |
4 | var n = 128 * 1024;
5 | http.createServer(function(req, res) {
6 | var b = new Buffer(n);
7 | b.fill(0);
8 | res.writeHead(200, {
9 | "Content-Type":"text/plain"
10 | });
11 | res.end(b);
12 | }).listen(8080);
--------------------------------------------------------------------------------
/benchmarks/hello-world/ringo.js:
--------------------------------------------------------------------------------
1 | exports.app = function() {
2 | var response = {
3 | status: 200,
4 | headers: {
5 | 'Content-Type': 'text/plain'
6 | },
7 | body: ['Hello World!\n']
8 | };
9 | return response;
10 | };
11 |
12 | if(require.main === module) {
13 | require("ringo/httpserver").main(module.id);
14 | }
15 |
--------------------------------------------------------------------------------
/examples/sleep.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileOverview Sleep example. Sleep for one second before returning a
3 | * response.
4 | */
5 | var sleep = require('system').sleep;
6 |
7 | exports.app = function(request) {
8 | sleep(1000);
9 | return {
10 | status: 200,
11 | headers: {},
12 | body: ['Hello Sleep!\n']
13 | };
14 | };
15 |
--------------------------------------------------------------------------------
/benchmarks/file-read/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var fs = require('fs');
3 | var Buffer = require('buffer').Buffer;
4 |
5 | fs.writeFileSync('test.dat', new Buffer(128 * 1024));
6 | http.createServer(function(req, res) {
7 | res.writeHead(200, {"Content-Type":"text/plain; charset=utf-8'"});
8 | res.end(fs.readFileSync('test.dat'));
9 | }).listen(8080);
--------------------------------------------------------------------------------
/benchmarks/file-stream/common-node.js:
--------------------------------------------------------------------------------
1 | var fs = require('fs-base');
2 | var ByteArray = require('binary').ByteArray;
3 |
4 | fs.write('test.dat', new ByteArray(128 * 1024, false));
5 | exports.app = function() {
6 | return {
7 | status:200,
8 | headers:{'Content-Type':'text/plain; charset=utf-8'},
9 | body:fs.openRaw('test.dat')
10 | };
11 | };
--------------------------------------------------------------------------------
/benchmarks/file-stream/ringo.js:
--------------------------------------------------------------------------------
1 | var openRaw = require('fs').openRaw;
2 |
3 | exports.app = function() {
4 | return {
5 | status:200,
6 | headers:{
7 | 'Content-Type':'text/plain'
8 | },
9 | body:openRaw('../README.md')
10 | };
11 | };
12 |
13 | if (require.main === module) {
14 | require("ringo/httpserver").main(module.id);
15 | }
--------------------------------------------------------------------------------
/benchmarks/file-read/ringo.js:
--------------------------------------------------------------------------------
1 | var read = require('fs').read;
2 |
3 | exports.app = function() {
4 | return {
5 | status:200,
6 | headers:{
7 | 'Content-Type':'text/plain'
8 | },
9 | body:[read('../README.md', {binary:true})]
10 | };
11 | };
12 |
13 | if (require.main === module) {
14 | require("ringo/httpserver").main(module.id);
15 | }
--------------------------------------------------------------------------------
/benchmarks/file-read/common-node.js:
--------------------------------------------------------------------------------
1 | var fs = require('fs-base');
2 | var ByteArray = require('binary').ByteArray;
3 |
4 | fs.write('test.dat', new ByteArray(128 * 1024, false));
5 | exports.app = function() {
6 | return {
7 | status:200,
8 | headers:{'Content-Type':'text/plain; charset=utf-8'},
9 | body:[fs.read('test.dat', {binary:true})]
10 | };
11 | };
--------------------------------------------------------------------------------
/test/binary/all.js:
--------------------------------------------------------------------------------
1 | exports['ByteArray'] = require('./bytearray-tests');
2 | exports['ByteArray Encodings'] = require('./bytearray-encodings-tests');
3 | exports['ByteString'] = require('./bytestring-tests');
4 | exports['ByteString Encodings'] = require('./bytestring-encodings-tests');
5 |
6 | if (require.main == module) {
7 | require("../../lib/test").run(exports);
8 | }
9 |
--------------------------------------------------------------------------------
/examples/static.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileOverview Serve a static file from disk. The source code of the current
3 | * module, i.e. this file is served.
4 | */
5 |
6 | var openRaw = require('fs-base').openRaw;
7 |
8 | exports.app = function(request) {
9 | return {
10 | status: 200,
11 | headers: {},
12 | body: openRaw(module.filename)
13 | };
14 | };
15 |
--------------------------------------------------------------------------------
/lib/all.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileoverview Collection of all modules.
3 | */
4 |
5 | [
6 | 'assert',
7 | 'binary',
8 | 'fs-base',
9 | 'global',
10 | 'httpclient',
11 | 'httpserver',
12 | 'io',
13 | 'run',
14 | 'socket',
15 | 'subprocess',
16 | 'system',
17 | 'test',
18 | 'ringo/httpclient'
19 | ].forEach(function(path) {
20 | exports[path] = require('./' + path);
21 | });
--------------------------------------------------------------------------------
/benchmarks/string-alloc/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var Buffer = require('buffer').Buffer;
3 |
4 | var n = 128 * 1024;
5 | var b = new Buffer(n);
6 | for (var i = 0; i < n; i++) {
7 | b[i] = Math.floor(32 + (127 - 32) * Math.random());
8 | }
9 | http.createServer(function(req, res) {
10 | res.writeHead(200, {
11 | "Content-Type":"text/plain"
12 | });
13 | res.end(b.toString("ascii"));
14 | }).listen(8080);
15 |
--------------------------------------------------------------------------------
/test/jsgi.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var jsgi = require('../lib/jsgi').jsgi;
3 |
4 | exports.testServer = function() {
5 | http.createServer(jsgi(function(request) {
6 | return {
7 | status: 200,
8 | headers: {
9 | "Content-Type": "text/plain"
10 | },
11 | body: request.input
12 | };
13 | })).listen(8080);
14 | };
15 |
16 | if (require.main == module) {
17 | require("../lib/test").run(exports);
18 | }
19 |
--------------------------------------------------------------------------------
/benchmarks/string-alloc/common-node.js:
--------------------------------------------------------------------------------
1 | var ByteArray = require('binary').ByteArray;
2 |
3 | var n = 128 * 1024;
4 | var b = new ByteArray(n);
5 | for (var i = 0; i < n; i++) {
6 | b[i] = Math.floor(32 + (127 - 32) * Math.random());
7 | }
8 | exports.app = function(request) {
9 | return {
10 | status:200,
11 | headers:{
12 | "Content-Type":"text/plain"
13 | },
14 | body:[b.decodeToString("ascii")]
15 | };
16 | };
17 |
--------------------------------------------------------------------------------
/test/all.js:
--------------------------------------------------------------------------------
1 | //exports['Assert']
2 | //exports['Console']
3 | //exports['System']
4 | exports['Binary'] = require('./binary/all');
5 | exports['IO'] = require('./io');
6 | exports['Filesystem'] = require('./fs-base/all');
7 | // exports['JSGI'] = require('./jsgi');
8 | exports['HTTP'] = require('./http');
9 | exports['Subprocess'] = require('./subprocess');
10 |
11 | if (require.main === module) {
12 | require("../lib/test").run(exports);
13 | }
--------------------------------------------------------------------------------
/test/fs-base/all.js:
--------------------------------------------------------------------------------
1 | exports.main = require('./main');
2 | exports.path = require('./path');
3 | exports.dirname = require('./dirname');
4 | exports.extension = require('./extension');
5 | exports.iterator = require('./iterator');
6 | exports.normal = require('./normal');
7 | exports.relative = require('./relative');
8 | exports.resolve = require('./resolve');
9 |
10 | if (require.main === module) {
11 | require("../../lib/test").run(exports);
12 | }
--------------------------------------------------------------------------------
/benchmarks/buffer-alloc/ringo.js:
--------------------------------------------------------------------------------
1 | var ByteArray = require('binary').ByteArray;
2 |
3 | exports.app = function(request) {
4 | var n = 1024, b = new ByteArray(n);
5 | for( var i = 1; i < 50; i++)
6 | b = new ByteArray(n);
7 | var response = {
8 | status: 200,
9 | headers: {
10 | "Content-Type": "text/plain"
11 | },
12 | body: [b]
13 | };
14 | return response;
15 | };
16 |
17 | if(require.main === module) {
18 | require("ringo/httpserver").main(module.id);
19 | }
20 |
--------------------------------------------------------------------------------
/benchmarks/no-alloc/ringo.js:
--------------------------------------------------------------------------------
1 | var ByteArray = require('binary').ByteArray;
2 |
3 | var n = 1024;
4 | var b = new ByteArray(n);
5 | for( var i = 0; i < n; i++)
6 | b[i] = 100;
7 |
8 | exports.app = function(request) {
9 | var response = {
10 | status: 200,
11 | headers: {
12 | "Content-Type": "text/plain"
13 | },
14 | body: [b]
15 | };
16 | return response;
17 | };
18 |
19 | if(require.main === module) {
20 | require("ringo/httpserver").main(module.id);
21 | }
22 |
--------------------------------------------------------------------------------
/examples/http.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileOverview HTTP proxy example. Note that rather than first getting the
3 | * response, storing it in a string and then passing it on, we are using the
4 | * Stream directly and are piping data through as it arrives without unnecessary
5 | * buffering.
6 | */
7 |
8 | var HttpClient = require('httpclient').HttpClient;
9 |
10 | exports.app = function(req) {
11 | req.url = 'http://nodejs.org';
12 | return new HttpClient(req).finish();
13 | };
14 |
--------------------------------------------------------------------------------
/benchmarks/no-alloc/common-node.js:
--------------------------------------------------------------------------------
1 | var ByteArray = require('binary').ByteArray;
2 |
3 | var m = 128;
4 | var n = 1024;
5 | var d = [];
6 | for (var i = 0; i < m; i++) {
7 | var b = new ByteArray(n);
8 | for (var j = 0; j < n; j++) {
9 | b[j] = Math.floor(256 * Math.random());
10 | }
11 | d.push(b);
12 | }
13 | exports.app = function(request) {
14 | return {
15 | status:200,
16 | headers:{
17 | "Content-Type":"text/plain"
18 | },
19 | body:d
20 | };
21 | };
22 |
--------------------------------------------------------------------------------
/benchmarks/no-alloc/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var Buffer = require('buffer').Buffer;
3 |
4 | var m = 128;
5 | var n = 1024;
6 | var d = [];
7 | for (var i = 0; i < m; i++) {
8 | var b = new Buffer(n);
9 | for (var j = 0; j < n; j++) {
10 | b[j] = Math.floor(256 * Math.random());
11 | }
12 | d.push(b);
13 | }
14 | http.createServer(function(req, res) {
15 | res.writeHead(200, {"Content-Type":"text/plain"});
16 | d.forEach(function(b) {
17 | res.write(b);
18 | });
19 | res.end();
20 | }).listen(8080);
21 |
22 |
--------------------------------------------------------------------------------
/benchmarks/string-alloc/ringo.js:
--------------------------------------------------------------------------------
1 | var ByteArray = require('binary').ByteArray;
2 |
3 | var n = 1024;
4 | var b = new ByteArray(n);
5 | for( var i = 0; i < n; i++)
6 | b[i] = 100;
7 |
8 | exports.app = function(request) {
9 | for( var i = 1; i <= 50; i++)
10 | b.decodeToString("ascii");
11 | var response = {
12 | status: 200,
13 | headers: {
14 | "Content-Type": "text/plain"
15 | },
16 | body: [b]
17 | };
18 | return response;
19 | };
20 |
21 | if(require.main === module) {
22 | require("ringo/httpserver").main(module.id);
23 | }
24 |
--------------------------------------------------------------------------------
/examples/chat.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileoverview Implementation of a Telnet chat server. After running, telnet
3 | * to port 8080.
4 | */
5 |
6 | var server = new require('socket').Socket().bind('localhost', 8080), clients = [], client;
7 | while(clients.push(client = server.accept().getStream())) {
8 | spawn(function() {
9 | for( var stream = client, line; (line = stream.read(null)).length;) {
10 | clients.forEach(function(c) {
11 | (stream == c) || c.write(line);
12 | });
13 | }
14 | clients.splice(clients.indexOf(stream), 1);
15 | });
16 | }
17 |
--------------------------------------------------------------------------------
/examples/spawn.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileOverview Spawn example. Spawns a new fiber which sleeps for 10 seconds
3 | * before printing to the console while immediately returning an
4 | * HTTP response.
5 | */
6 |
7 | var system = require('system');
8 | var spawn = system.spawn, sleep = system.sleep;
9 |
10 | exports.app = function(request) {
11 | spawn(function() {
12 | sleep(10000);
13 | console.log('Hello Server!');
14 | });
15 | return {
16 | status: 200,
17 | headers: {},
18 | body: ['Hello Client!\n']
19 | };
20 | };
21 |
--------------------------------------------------------------------------------
/benchmarks/file-stream/node.js:
--------------------------------------------------------------------------------
1 | var http = require('http');
2 | var fs = require('fs');
3 | var Buffer = require('buffer').Buffer;
4 |
5 | fs.writeFileSync('test.dat', new Buffer(128 * 1024));
6 | http.createServer(function(req, res) {
7 | res.writeHead(200, {"Content-Type":"text/plain; charset=utf-8"});
8 | var input = fs.createReadStream('test.dat').on('error', function() {
9 | res.end();
10 | }).on('end', function() {
11 | res.end();
12 | }).on('close', function() {
13 | res.end();
14 | }).on('readable', function() {
15 | res.write(input.read());
16 | });
17 | }).listen(8080);
--------------------------------------------------------------------------------
/test/fs-base/dirname.js:
--------------------------------------------------------------------------------
1 | var assert = require('../../lib/assert');
2 | var fs = require('../../lib/fs-base');
3 |
4 | var tests;
5 | tests = [['', '.'], ['.', '.'], ['foo', '.'], ['foo/bar', 'foo']];
6 |
7 | tests.forEach(function(dirs) {
8 | exports['test "' + dirs[0] + '"'] = function() {
9 | var actual = fs.directory(dirs[0]);
10 | assert.strictEqual(dirs[1], actual);
11 | };
12 | });
13 |
14 | tests.forEach(function(dirs) {
15 | exports['testPath "' + dirs[0] + '"'] = function() {
16 | var actual = fs.path(dirs[0]).directory();
17 | assert.strictEqual(dirs[1], actual.toString());
18 | };
19 | });
20 |
21 | if (require.main === module) {
22 | require("../../lib/test").run(exports);
23 | }
--------------------------------------------------------------------------------
/tools/jsdoc/hosted.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {{title}}
6 |
7 |
8 |
9 | {{{head}}}
10 |
11 |
12 |
13 |
14 | {{{content}}}
15 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/tools/jsdoc/static.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 | {{title}}
6 |
7 |
8 |
9 | {{{head}}}
10 |
11 |
12 |
13 |
14 | {{{content}}}
15 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
--------------------------------------------------------------------------------
/doc/static/style.css:
--------------------------------------------------------------------------------
1 | body, html {
2 | margin: 0;
3 | padding: 0;
4 | }
5 |
6 | body {
7 | min-width: 850px;
8 | font-family: sans-serif;
9 | font-size: 80%;
10 | line-height: 170%;
11 | color: #EEEEEE;
12 | background: none repeat scroll 0 0 #22252A;
13 | }
14 |
15 | a {
16 | color: #CCDD55;
17 | text-decoration: none;
18 | }
19 |
20 | h1 {
21 | padding: 14px 0;
22 | }
23 |
24 | div.wrap {
25 | margin: 0 auto;
26 | width: 800px;
27 | }
28 |
29 | div.main {
30 | clear: both;
31 | float: left;
32 | width: 530px;
33 | margin: 0 10px;
34 | padding: 5px;
35 | }
36 |
37 | div.menu {
38 | float: right;
39 | padding-top: 6em;
40 | }
41 |
42 | .hidden {
43 | visibility:hidden;
44 | display:none;
45 | }
46 |
47 |
--------------------------------------------------------------------------------
/tools/jsdoc/style.css:
--------------------------------------------------------------------------------
1 | body, html {
2 | margin: 0;
3 | padding: 0;
4 | }
5 |
6 | body {
7 | min-width: 850px;
8 | font-family: sans-serif;
9 | font-size: 80%;
10 | line-height: 170%;
11 | color: #EEEEEE;
12 | background: none repeat scroll 0 0 #22252A;
13 | }
14 |
15 | a {
16 | color: #CCDD55;
17 | text-decoration: none;
18 | }
19 |
20 | h1 {
21 | padding: 14px 0;
22 | }
23 |
24 | div.wrap {
25 | margin: 0 auto;
26 | width: 800px;
27 | }
28 |
29 | div.main {
30 | clear: both;
31 | float: left;
32 | width: 530px;
33 | margin: 0 10px;
34 | padding: 5px;
35 | }
36 |
37 | div.menu {
38 | float: right;
39 | padding-top: 6em;
40 | }
41 |
42 | .hidden {
43 | visibility:hidden;
44 | display:none;
45 | }
46 |
47 |
--------------------------------------------------------------------------------
/test/fs-base/normal.js:
--------------------------------------------------------------------------------
1 | var assert = require('../../lib/assert');
2 | var fs = require('../../lib/fs-base');
3 | var separator = fs.separator;
4 |
5 | var tests = [
6 | ['', ''], ['.', ''], ['./', ''], ['../', '../'], ['../a', '../a'],
7 | ['../a/', '../a/'], ['a/..', ''], ['a/../', ''], ['a/../b', 'b'],
8 | ['a/../b/', 'b/']
9 | ];
10 |
11 | tests.forEach(function(args) {
12 | exports['test "' + args[0] + '"'] = function() {
13 | var result = fs.normal(localize(args[0]));
14 | assert.strictEqual(localize(args[1]), result);
15 | };
16 | });
17 |
18 | tests.forEach(function(args) {
19 | exports['testPath "' + args[0] + '"'] = function() {
20 | var result = fs.path(localize(args[0])).normal();
21 | assert.strictEqual(localize(args[1]), result.toString());
22 | };
23 | });
24 |
25 | // adapt path to the platform we're running on
26 | function localize(path) {
27 | return path.replace(/\//g, separator);
28 | }
29 |
30 | if (require.main === module) {
31 | require("../../lib/test").run(exports);
32 | }
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "name":"common-node",
3 | "keywords":[
4 | "commonjs"
5 | ],
6 | "description":"Synchronous CommonJS compatibility layer using node-fibers",
7 | "version":"0.10.21",
8 | "author":{
9 | "name":"Oleg Podsechin",
10 | "email":"oleg@ionsquare.com"
11 | },
12 | "contributors":[
13 | {
14 | "name":"Alex Lam",
15 | "email":"alex.lam@nikao-tech.com"
16 | },
17 | {
18 | "name":"Oleg Podsechin",
19 | "email":"oleg@ionsquare.com"
20 | }
21 | ],
22 | "directories":{
23 | "lib":"./lib",
24 | "example":"./examples"
25 | },
26 | "repository":{
27 | "type":"git",
28 | "url":"git://github.com/olegp/common-node.git"
29 | },
30 | "homepage":"http://github.com/olegp/common-node/",
31 | "main":"./lib/all.js",
32 | "scripts":{
33 | "test":"node test/all.js"
34 | },
35 | "bin":{
36 | "common-node":"./bin/common-node"
37 | },
38 | "engines":{
39 | "node":">=0.10.0"
40 | },
41 | "dependencies":{
42 | "fibers":"1.0.2"
43 | },
44 | "preferGlobal":true,
45 | "licenses":[
46 | {
47 | "type":"MIT"
48 | }
49 | ]
50 | }
51 |
--------------------------------------------------------------------------------
/test/fs-base/extension.js:
--------------------------------------------------------------------------------
1 | var assert = require('../../lib/assert');
2 | var fs = require('../../lib/fs-base');
3 |
4 | var tests = [
5 | ['', ''], ['.', ''], ['..', ''], ['.a', ''], ['..a', ''],
6 | ['.a.b', '.b'], ['a.b', '.b'], ['a.b.c', '.c'], ['/', ''], ['/.', ''],
7 | ['/..', ''], ['/..a', ''], ['/.a.b', '.b'], ['/a.b', '.b'],
8 | ['/a.b.c', '.c'], ['foo/', ''], ['foo/.', ''], ['foo/..', ''],
9 | ['foo/..a', ''], ['foo/.a.b', '.b'], ['foo/a.b', '.b'],
10 | ['foo/a.b.c', '.c'], ['/foo/', ''], ['/foo/.', ''], ['/foo/..', ''],
11 | ['/foo/..a', ''], ['/foo/.a.b', '.b'], ['/foo/a.b', '.b'],
12 | ['/foo/a.b.c', '.c']
13 | ];
14 |
15 | tests.forEach(function(dirs) {
16 | exports['test "' + dirs[0] + '"'] = function() {
17 | var actual = fs.extension(dirs[0]);
18 | assert.strictEqual(dirs[1], actual);
19 | };
20 | });
21 |
22 | tests.forEach(function(dirs) {
23 | exports['testPath "' + dirs[0] + '"'] = function() {
24 | var actual = fs.path(dirs[0]).extension();
25 | assert.strictEqual(dirs[1], actual.toString());
26 | };
27 | });
28 |
29 | if (require.main === module) {
30 | require("../../lib/test").run(exports);
31 | }
--------------------------------------------------------------------------------
/examples/twitter.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileOverview Twitter Streaming API usage example. Returns streaming search
3 | * results. To quickly see results search for "test". Run with
4 | *
5 | *
6 | * common-node twitter.js username password keyword
7 | *
8 | */
9 |
10 | var HttpClient = require('httpclient').HttpClient;
11 | var TextStream = require('io').TextStream;
12 | var encode = require('./base64').encode;
13 |
14 | // make an HTTP request and wrap its response stream with TextStream, which lets
15 | // us read one line at a time
16 | var stream = new TextStream(new HttpClient({
17 | method: 'POST',
18 | url: 'https://stream.twitter.com/1/statuses/filter.json',
19 | headers: {
20 | 'Authorization': 'Basic ' + encode(system.args[2] + ':' + system.args[3]),
21 | 'Content-Type': 'application/x-www-form-urlencoded'
22 | },
23 | body: ['track=' + system.args[4]],
24 | timeout: 10000
25 | }).finish().body);
26 |
27 | var line;
28 | while(true) {
29 | // returns an empty string in case of EOF or '\n' in case of empty line
30 | line = stream.readLine();
31 | // EOF
32 | if(!line.length)
33 | break;
34 | // make sure this isn't an empty line
35 | if(line.length > 1) {
36 | var message = JSON.parse(line);
37 | console.log(message.text);
38 | }
39 | }
40 |
--------------------------------------------------------------------------------
/test/fs-base/relative.js:
--------------------------------------------------------------------------------
1 | var assert = require('../../lib/assert');
2 | var fs = require('../../lib/fs-base');
3 | var separator = fs.separator;
4 |
5 | var tests = [
6 | ['', '', ''], ['.', '', ''], ['', '.', ''], ['.', '.', ''],
7 | ['', '..', '../'], ['', '../', '../'], ['a', 'b', 'b'],
8 | ['../a', '../b', 'b'], ['../a/b', '../a/c', 'c'], ['a/b', '..', '../../'],
9 | ['a/b', 'c', '../c'], ['a/b', 'c/d', '../c/d']
10 | ];
11 |
12 | tests.forEach(function(args) {
13 | var source = args[0], target = args[1], expected = args[2];
14 | var name = '"' + source + '" -> "' + target + '" = "' + expected + '"';
15 | exports['test ' + name] = function() {
16 | var actual = fs.relative(source, target);
17 | // expect returned paths to use system-dependent file separator
18 | assert.strictEqual(expected.replace(/\//g, separator), actual);
19 | };
20 | });
21 |
22 | tests.forEach(function(args) {
23 | var source = args[0], target = args[1], expected = args[2];
24 | var name = '"' + source + '" -> "' + target + '" = "' + expected + '"';
25 | exports['testPath ' + name] = function() {
26 | var actual = fs.path(source).relative(target);
27 | // expect returned paths to use system-dependent file separator
28 | assert.strictEqual(expected.replace(/\//g, separator), actual.toString());
29 | };
30 | });
31 |
32 | if (require.main === module) {
33 | require("../../lib/test").run(exports);
34 | }
--------------------------------------------------------------------------------
/benchmarks/run:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | # based on http://github.com/senchalabs/connect/tree/master/benchmarks/
3 |
4 | ABFLAGS=${ABFLAGS-"-n 50000 -c 50"}
5 | ADDR=${ADDR-http://0.0.0.0:8080/}
6 | AB=${AB-ab}
7 |
8 | #
9 | # Log
10 | #
11 | #
12 | #
13 |
14 | log(){
15 | echo "... $@"
16 | }
17 |
18 | #
19 | # Benchmark the given and [path].
20 | #
21 | # [path]
22 | #
23 |
24 | bm(){
25 | local dir=$1;
26 | for platform in common-node node ringo
27 | do
28 | local flags=""
29 | if [ $platform = "ringo" ]; then
30 | # disable module reloading on ringo
31 | flags="-p"
32 | fi
33 | $platform $flags $dir/$platform.js &
34 | local pid=$!
35 | sleep 2
36 | local dirname=results/$dir
37 | mkdir -p $dirname
38 | # jvm needs warmup time to reach final speed. If you run smaller
39 | # batches you'll need more runs for warmup.
40 | for runs in {1..2}
41 | do
42 | $AB $ABFLAGS -g $dirname/$platform.dat $ADDR/$path > $dirname/$platform.out
43 | sleep 1
44 | done
45 | log $(cat $dirname/$platform.out | grep Requests)
46 | kill $pid
47 | sleep 2
48 | done
49 | }
50 |
51 | # Make ./results
52 | mkdir -p results
53 |
54 | # Store flags
55 | echo "$ABFLAGS" > results/flags
56 |
57 | # Run benchmarks
58 | log $AB $ABFLAGS $ADDR
59 | bm buffer-alloc
60 | bm file-read
61 | bm file-stream
62 | bm hello-world
63 | bm no-alloc
64 | bm set-timeout
65 | bm string-alloc
--------------------------------------------------------------------------------
/test/fs-base/path.js:
--------------------------------------------------------------------------------
1 | var assert = require("../../lib/assert");
2 | var test = require('../../lib/test');
3 | var fs = require("../../lib/fs-base");
4 | var ByteString = require('../../lib/binary').ByteString;
5 |
6 | function getContents(file) {
7 | return require("fs").readFileSync(file, "utf8");
8 | }
9 |
10 | exports.testCopy = test.fs(2, function(file1, file2) {
11 | fs.path(file1).write(new ByteString('abcd'));
12 | fs.path(file1).copy(file2);
13 | var resource = getContents(file2);
14 |
15 | assert.strictEqual(resource, 'abcd');
16 | });
17 |
18 | exports.testOpen = function() {
19 | var resource = getContents('./lib/assert.js');
20 | var io = fs.path('./lib/assert.js').open();
21 |
22 | assert.strictEqual(io.read().length, resource.length);
23 | };
24 |
25 | exports.testOpenRaw = function() {
26 | var resource = getContents('./lib/assert.js');
27 | var io = fs.path('./lib/assert.js').openRaw();
28 |
29 | assert.strictEqual(io.read().decodeToString().length, resource.length);
30 | };
31 |
32 | exports.testRead = function() {
33 | var resource = getContents('./lib/assert.js');
34 | var file = fs.path('./lib/assert.js').read();
35 |
36 | assert.strictEqual(file.length, resource.length);
37 | };
38 |
39 | exports.testWrite = test.fs(1, function(file) {
40 | fs.path(file).write(new ByteString('test'));
41 | var resource = getContents(file);
42 |
43 | assert.strictEqual('test', resource);
44 | });
45 |
46 | if (require.main === module) {
47 | require("../../lib/test").run(exports);
48 | }
--------------------------------------------------------------------------------
/lib/global.js:
--------------------------------------------------------------------------------
1 | /**
2 | * @fileoverview Provides global functions
3 | * import, include, export and spawn for RingoJS compatibility.
4 | */
5 |
6 | /**
7 | * Load a module and include all its properties in the calling scope.
8 | *
9 | * @param {String} moduleName the module name such as 'core.object'
10 | */
11 | global.include = exports.include = function(moduleName) {
12 | var module = this.require(moduleName);
13 | for( var key in module) {
14 | this[key] = module[key];
15 | }
16 | };
17 |
18 | /**
19 | * Define the properties to be exported.
20 | *
21 | * @param name one or more names of exported properties
22 | */
23 | global.export = exports.export = function() {
24 | var module = this;
25 | var exports = this.exports;
26 | if(!exports || typeof exports != "object") {
27 | // this should never happen
28 | exports = {};
29 | Object.defineProperty(module, "exports", {
30 | value: exports
31 | });
32 | }
33 | Array.forEach(arguments, function(name) {
34 | Object.defineProperty(exports, name, {
35 | get: function() {
36 | return module[name];
37 | },
38 | enumerable: true
39 | });
40 | });
41 | };
42 |
43 | // load system module
44 | var system = global.system = require('./system');
45 |
46 | /**
47 | * spawn() from the system module. Spawns a new thread.
48 | *
49 | * @param {Function} run entry point of the new thread.
50 | */
51 | global.spawn = exports.spawn = system.spawn;
52 |
53 | // make our fiber instance available to other packages
54 | global.Fiber = require("fibers");
55 |
56 | // TODO add getResource
57 |
--------------------------------------------------------------------------------
/test/fs-base/resolve.js:
--------------------------------------------------------------------------------
1 | var assert = require('../../lib/assert');
2 | var fs = require('../../lib/fs-base');
3 | var separator = fs.separator, roots = [separator];
4 |
5 | var tests = [
6 | [['/'], '/'], [['/a'], '/a'], [['/a/'], '/a/'],
7 | [['/a', '/b'], '/b'], [['/a', '/b/'], '/b/'], [['/', 'a'], '/a'],
8 | [['/', 'a/'], '/a/'], [['/a', 'a'], '/a'], [['/a', 'a/'], '/a/'],
9 | [['/a/', 'a'], '/a/a'], [['/a/', 'a/'], '/a/a/'], [['..'], '../'],
10 | [['..', 'a'], '../a'], [['..', 'a/'], '../a/'], [['.'], ''],
11 | [['.', 'a'], 'a'], [['.', 'a/'], 'a/'], [['a', '.'], ''],
12 | [['a', '.', 'a'], 'a'], [['a', '.', 'a/'], 'a/'], [['a', '..'], '../'],
13 | [['a', '..', 'a'], '../a'], [['a', '..', 'a/'], '../a/'],
14 | [['a/', '..'], ''], [['a/', '..', 'a'], 'a'], [['a/', '..', 'a/'], 'a/'],
15 | [['a/b', ''], 'a/b']
16 | ];
17 |
18 | tests.forEach(function(args) {
19 | exports['test ' + JSON.stringify(args[0])] = function() {
20 | var result = fs.resolve.apply(null, args[0].map(localize));
21 | assert.strictEqual(localize(args[1]), result);
22 | };
23 | });
24 |
25 | tests.forEach(function(args) {
26 | exports['testPath ' + JSON.stringify(args[0])] = function() {
27 | args[0] = args[0].map(localize);
28 | var path = fs.path(args[0].shift());
29 | var result = path.resolve.apply(path, args[0]);
30 | assert.strictEqual(localize(args[1]), result.toString());
31 | };
32 | });
33 |
34 | function localize(path) {
35 | return path.replace(/^\//, roots[0]).replace(/\//g, separator);
36 | }
37 |
38 | if (require.main === module) {
39 | require("../../lib/test").run(exports);
40 | }
--------------------------------------------------------------------------------
/test/fs-base/main.js:
--------------------------------------------------------------------------------
1 | var assert = require("../../lib/assert");
2 | var test = require('../../lib/test');
3 | var fs = require("../../lib/fs-base");
4 | var ByteString = require('../../lib/binary').ByteString;
5 |
6 | function getContents(file) {
7 | return require("fs").readFileSync(file, "utf8");
8 | }
9 |
10 | exports.testCopy = test.fs(2, function(file1, file2) {
11 | fs.write(file1, new ByteString('abcd'));
12 | fs.copy(file1, file2);
13 | var resource = getContents(file2);
14 |
15 | assert.strictEqual(resource, 'abcd');
16 | });
17 |
18 | exports.testOpen = function() {
19 | var resource = getContents('./lib/assert.js');
20 | var io = fs.open('./lib/assert.js');
21 |
22 | assert.strictEqual(io.read().length, resource.length);
23 | };
24 |
25 | exports.testOpenRaw = function() {
26 | var resource = getContents('./lib/assert.js');
27 | var io = fs.openRaw('./lib/assert.js');
28 |
29 | assert.strictEqual(io.read().decodeToString().length, resource.length);
30 | };
31 |
32 | exports.testRead = function() {
33 | var resource = getContents('./lib/assert.js');
34 | var file = fs.read('./lib/assert.js');
35 |
36 | assert.strictEqual(file.length, resource.length);
37 | };
38 |
39 | exports.testWrite = test.fs(1, function(file) {
40 | fs.write(file, new ByteString('test'));
41 | var resource = getContents(file);
42 | assert.strictEqual('test', resource);
43 |
44 | fs.write(file, 'test');
45 | var resource = getContents(file);
46 | assert.strictEqual('test', resource);
47 |
48 | fs.write(file, '');
49 | fs.write(file, new ByteString('test'), {append:true});
50 | fs.write(file, 'test', {append:true});
51 | var resource = getContents(file);
52 | assert.strictEqual('testtest', resource);
53 | });
54 |
55 | if (require.main === module) {
56 | require("../../lib/test").run(exports);
57 | }
--------------------------------------------------------------------------------
/doc/static/jsdoc.css:
--------------------------------------------------------------------------------
1 | pre.code {
2 | background-color: #abc;
3 | border-width: 1px;
4 | border-color: #9ab;
5 | border-style: solid;
6 | padding: 0.8em;
7 | line-height: 145%;
8 | }
9 |
10 | table td {
11 | vertical-align: top;
12 | padding: 0 10px;
13 | }
14 |
15 | h4 {
16 | margin: 5px 0;
17 | color: green;
18 | font-weight: bold;
19 | }
20 |
21 | .dimmed {
22 | color: #333;
23 | font-weight: 500;
24 | }
25 |
26 | .paramname {
27 | font-weight:bold;
28 | }
29 |
30 | .extrainfo {
31 | padding:0 12px;
32 | }
33 |
34 | .leftnav, .repositorylist, .propertyoverview {
35 | list-style-type: none;
36 | padding: 2px;
37 | }
38 |
39 | .docitem {
40 | }
41 |
42 | .docitem .itemtitle {
43 | font-size:large;
44 | text-decoration:none;
45 | }
46 |
47 | .light {
48 | font-weight: normal;
49 | }
50 |
51 | .docitem.highlight {
52 | border-left: 4px solid green;
53 | padding: 0 0 0 6px;
54 | }
55 |
56 | ul.modulelist {
57 | list-style-type:none;
58 | margin: 0;
59 | padding-left: 10px;
60 | }
61 |
62 | .repositoryname {
63 | font-weight:bold;
64 | }
65 |
66 | .moduleheader {
67 | padding: 8px;
68 | }
69 |
70 | h2, h3 {
71 | margin-bottom: 5px;
72 | }
73 |
74 | h3 {
75 | font-size: small;
76 | }
77 |
78 | ul {
79 | margin: 5px;
80 | }
81 |
82 | hr {
83 | border: 0;
84 | color: #999;
85 | background-color: #999;
86 | height: 1px;
87 | }
88 |
89 | .classoverview {
90 | /* background-color: #f0ffc0; #f7ffe5; */
91 | padding: 5px 10px;
92 | margin: 15px 0;
93 | }
94 |
95 | .modulename {
96 | /* background-color: #f1ffcc; */
97 | }
98 |
99 | .showmore {
100 | color: blue;
101 | cursor: pointer;
102 | }
103 |
--------------------------------------------------------------------------------
/tools/jsdoc/jsdoc.css:
--------------------------------------------------------------------------------
1 | pre.code {
2 | background-color: #abc;
3 | border-width: 1px;
4 | border-color: #9ab;
5 | border-style: solid;
6 | padding: 0.8em;
7 | line-height: 145%;
8 | }
9 |
10 | table td {
11 | vertical-align: top;
12 | padding: 0 10px;
13 | }
14 |
15 | h4 {
16 | margin: 5px 0;
17 | color: green;
18 | font-weight: bold;
19 | }
20 |
21 | .dimmed {
22 | color: #333;
23 | font-weight: 500;
24 | }
25 |
26 | .paramname {
27 | font-weight:bold;
28 | }
29 |
30 | .extrainfo {
31 | padding:0 12px;
32 | }
33 |
34 | .leftnav, .repositorylist, .propertyoverview {
35 | list-style-type: none;
36 | padding: 2px;
37 | }
38 |
39 | .docitem {
40 | }
41 |
42 | .docitem .itemtitle {
43 | font-size:large;
44 | text-decoration:none;
45 | }
46 |
47 | .light {
48 | font-weight: normal;
49 | }
50 |
51 | .docitem.highlight {
52 | border-left: 4px solid green;
53 | padding: 0 0 0 6px;
54 | }
55 |
56 | ul.modulelist {
57 | list-style-type:none;
58 | margin: 0;
59 | padding-left: 10px;
60 | }
61 |
62 | .repositoryname {
63 | font-weight:bold;
64 | }
65 |
66 | .moduleheader {
67 | padding: 8px;
68 | }
69 |
70 | h2, h3 {
71 | margin-bottom: 5px;
72 | }
73 |
74 | h3 {
75 | font-size: small;
76 | }
77 |
78 | ul {
79 | margin: 5px;
80 | }
81 |
82 | hr {
83 | border: 0;
84 | color: #999;
85 | background-color: #999;
86 | height: 1px;
87 | }
88 |
89 | .classoverview {
90 | /* background-color: #f0ffc0; #f7ffe5; */
91 | padding: 5px 10px;
92 | margin: 15px 0;
93 | }
94 |
95 | .modulename {
96 | /* background-color: #f1ffcc; */
97 | }
98 |
99 | .showmore {
100 | color: blue;
101 | cursor: pointer;
102 | }
103 |
--------------------------------------------------------------------------------
/doc/static/jsdoc.js:
--------------------------------------------------------------------------------
1 | function jsdocSetup() {
2 |
3 | // filter given ul $list by text query
4 | var filterList = function(query, $list) {
5 | if (!query) {
6 | $('li', $list).show();
7 | return false;
8 | }
9 | var found = false;
10 | $('li', $list).each(function() {
11 | var $item = $(this);
12 | if ($item.html().toLowerCase().indexOf(query) < 0) {
13 | $item.hide();
14 | } else {
15 | $item.show();
16 | found = true;
17 | }
18 | });
19 | return found;
20 | };
21 |
22 | // search module list
23 | function doFilter() {
24 | var query = $.trim($(this).val().toLowerCase());
25 | /* if (sessionStorage) {
26 | sessionStorage.jsdocQuery = query;
27 | } */
28 | filterList(query, $('.jsdoc-leftnav'));
29 | }
30 | $("#jsdoc-leftnavsearch").change(doFilter).keyup(doFilter).click(doFilter).focus();
31 |
32 | // hide all but first paragraph from module fileoverview
33 | var $showMoreLink = $('.jsdoc-showmore');
34 | $(".jsdoc-fileoverview").each(function(idx, overview) {
35 | var $overview = $(overview);
36 | var $allButFirstElement = $overview.children().not(":first-child");
37 | if ($allButFirstElement.length) {
38 | $allButFirstElement.hide();
39 | $overview.append($showMoreLink.clone());
40 | }
41 | return;
42 | });
43 | $(".jsdoc-showmore").click(function() {
44 | $(this).hide().siblings().show();
45 | });
46 |
47 | // load query string from storage if any
48 | /* var query = sessionStorage && sessionStorage.jsdocQuery;
49 | if (query) {
50 | $("#jsdoc-leftnavsearch").val(query).trigger('keyup');
51 | } */
52 | }
53 |
--------------------------------------------------------------------------------
/benchmarks/graph:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 | # based on http://github.com/senchalabs/connect/tree/master/benchmarks/
3 |
4 | COL=${COL-9}
5 | ABFLAGS=$(cat results/flags)
6 |
7 | # Log
8 | #
9 | #
10 | #
11 |
12 | log(){
13 | echo "... $@"
14 | }
15 |
16 | #
17 | # Output gnuplot script for line graph.
18 | #
19 | # <node> <connect>
20 | #
21 |
22 | function line() {
23 | cat <<-EOF
24 | set terminal png # enhanced size 600 380 fname "Sans" fsize 11
25 | set output "results/graphs/$1.png"
26 | set title "$2 ($ABFLAGS)"
27 | # set size 0.97,0.97
28 | set grid y
29 | set key left top
30 | set xlabel "requests"
31 | set ylabel "response time (ms)"
32 | plot "$3" using $COL smooth sbezier with lines title "common", \\
33 | "$4" using $COL smooth sbezier with lines title "connect", \\
34 | "$5" using $COL smooth sbezier with lines title "ringo"
35 | EOF
36 | }
37 |
38 | #
39 | # Output gnuplot script for bar graph.
40 | #
41 | # <title> <node> <connect>
42 | #
43 |
44 | function bar() {
45 | cat <<-EOF
46 | set terminal png
47 | set output "results/graphs/$1.rps.png"
48 | set title "$1 $ABFLAGS"
49 | set size 0.7,0.5
50 | set grid y
51 | set key left top
52 | set ylabel "requests per second"
53 | plot "$1.rps.dat" using 2: xtic(1) with histogram title ""
54 | EOF
55 | }
56 |
57 | #
58 | # Graph the output of the given <dir>.
59 | #
60 | # <dir>
61 | #
62 |
63 | function graph(){
64 | log graphing $1
65 | local dir=results/$1
66 | line $1 "$2" \
67 | $dir/common-node.dat \
68 | $dir/node.dat \
69 | $dir/ringo.dat \
70 | > results/$1.p
71 | gnuplot results/$1.p
72 | }
73 |
74 | # Make ./results/graphs
75 | mkdir -p results/graphs
76 |
77 | graph buffer-alloc "buffer alloc"
78 | graph file-read "file read"
79 | graph file-stream "file stream"
80 | graph hello-world "hello world"
81 | graph no-alloc "no alloc"
82 | graph set-timeout "set timeout"
83 | graph static-file "static file"
84 | graph string-alloc "string alloc"
--------------------------------------------------------------------------------
/doc/all/index.html:
--------------------------------------------------------------------------------
1 | <!DOCTYPE html >
2 |
3 | <html lang="de" dir="ltr">
4 | <head>
5 | <title>all - Common Node
6 |
7 |
8 |
9 |
10 |
11 |
12 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
Module all
24 |
25 |
26 |
27 |
28 |
29 |
30 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
64 |