neo-blessed/lib/tput.js

2928 lines
65 KiB
JavaScript
Raw Normal View History

2013-02-08 13:43:45 +00:00
/**
2013-07-24 19:40:05 +00:00
* tput.js - parse and compile terminfo caps to javascript.
2013-02-08 13:43:45 +00:00
* Copyright (c) 2013, Christopher Jeffrey (MIT License)
* https://github.com/chjj/blessed
*/
// Resources:
// $ man term
// $ man terminfo
// http://invisible-island.net/ncurses/man/term.5.html
// https://en.wikipedia.org/wiki/Terminfo
2013-04-28 22:39:46 +00:00
// Todo:
// - xterm's XT (set-title capability?) value should
// be true (at least tmux thinks it should).
// It's not parsed as true. Investigate.
// - Possibly switch to other method of finding the
// extended data string table: i += h.symOffsetCount * 2;
2013-02-08 13:43:45 +00:00
/**
* Modules
*/
var assert = require('assert')
2013-02-22 11:20:50 +00:00
, path = require('path')
2013-02-08 13:43:45 +00:00
, fs = require('fs');
/**
* Tput
*/
2013-02-24 13:53:18 +00:00
function Tput(options) {
2013-02-15 17:42:52 +00:00
if (!(this instanceof Tput)) {
2013-02-24 13:53:18 +00:00
return new Tput(options);
2013-02-15 17:42:52 +00:00
}
2013-07-18 22:56:05 +00:00
options = options || {};
2013-02-24 13:53:18 +00:00
if (typeof options === 'string') {
options = { term: options };
}
this.options = options;
2013-07-14 14:32:50 +00:00
this.terminal = options.term
|| options.terminal
|| process.env.TERM
|| (process.platform === 'win32' ? 'windows-ansi' : 'xterm');
2013-02-27 22:57:11 +00:00
2013-02-24 13:53:18 +00:00
this.debug = options.debug;
this.padding = options.padding;
2013-02-24 21:07:54 +00:00
this.extended = options.extended;
2013-02-25 12:26:21 +00:00
this.printf = options.printf;
2013-02-28 00:25:59 +00:00
this.termcap = options.termcap;
2013-02-20 00:35:26 +00:00
this.terminfoPrefix = options.terminfoPrefix;
this.terminfoFile = options.terminfoFile;
this.termcapFile = options.termcapFile;
if (options.term || options.terminal) {
this.setup();
}
};
Tput.prototype.setup = function() {
2013-02-27 22:57:11 +00:00
try {
2013-02-28 00:25:59 +00:00
if (this.termcap) {
try {
this.injectTermcap();
} catch (e) {
if (this.debug) throw e;
this._useInternalCap(this.terminal);
}
2013-02-27 22:57:11 +00:00
} else {
try {
this.injectTerminfo();
} catch (e) {
if (this.debug) throw e;
this._useInternalInfo(this.terminal);
}
2013-02-27 22:57:11 +00:00
}
} catch (e) {
2013-03-05 23:38:41 +00:00
// If there was an error, fallback
// to an internally stored terminfo/cap.
if (this.debug) throw e;
this._useXtermInfo();
2013-02-27 22:57:11 +00:00
}
};
2013-02-08 13:43:45 +00:00
2013-07-18 22:56:05 +00:00
Tput.prototype.term = function(is) {
return this.terminal.indexOf(is) === 0;
};
2013-07-23 05:22:49 +00:00
Tput.prototype._debug = function() {
if (!this.debug) return;
return console.log.apply(console, arguments);
};
2013-03-05 23:38:41 +00:00
/**
* Fallback
*/
Tput.prototype._useVt102Cap = function() {
return this.injectTermcap('vt102');
2013-03-05 23:38:41 +00:00
};
Tput.prototype._useXtermCap = function() {
return this.injectTermcap(__dirname + '/../usr/xterm.termcap');
2013-03-05 23:38:41 +00:00
};
Tput.prototype._useXtermInfo = function() {
return this.injectTerminfo(__dirname + '/../usr/xterm');
2013-03-05 23:38:41 +00:00
};
Tput.prototype._useInternalInfo = function(name) {
name = path.basename(name);
return this.injectTerminfo(__dirname + '/../usr/' + name);
};
Tput.prototype._useInternalCap = function(name) {
name = path.basename(name);
return this.injectTermcap(__dirname + '/../usr/' + name + '.termcap');
};
2013-02-28 00:25:59 +00:00
/**
* Terminfo
*/
2013-02-08 13:43:45 +00:00
Tput.ipaths = [
process.env.TERMINFO || '',
(process.env.TERMINFO_DIRS || '').split(':'),
(process.env.HOME || '') + '/.terminfo',
'/usr/share/terminfo',
'/usr/share/lib/terminfo',
'/usr/lib/terminfo',
'/usr/local/share/terminfo',
'/usr/local/share/lib/terminfo',
'/usr/local/lib/terminfo',
'/usr/local/ncurses/lib/terminfo'
];
Tput.prototype.readTerminfo = function(term) {
var term = term || this.terminal
, data
, file
, info;
2013-08-03 01:59:49 +00:00
file = path.normalize(this._prefix(term));
data = fs.readFileSync(file);
info = this.parseTerminfo(data, file);
2013-02-28 00:34:41 +00:00
if (this.debug) {
this._terminfo = info;
}
return info;
2013-02-08 13:43:45 +00:00
};
Tput._prefix =
Tput.prototype._prefix = function(term) {
// If we have a terminfoFile, or our
// term looks like a filename, use it.
if (term) {
if (~term.indexOf(path.sep)) {
return term;
}
if (this.terminfoFile) {
return this.terminfoFile;
}
}
var paths = Tput.ipaths.slice()
2013-08-29 22:41:19 +00:00
, file;
if (this.terminfoPrefix) {
paths.unshift(this.terminfoPrefix);
}
// Try exact matches.
2013-08-29 22:41:19 +00:00
file = this._tprefix(paths, term);
if (file) return file;
// Try similar matches.
2013-08-29 22:41:19 +00:00
file = this._tprefix(paths, term, true);
if (file) return file;
// Not found.
throw new Error('Terminfo directory not found.');
};
Tput._tprefix =
Tput.prototype._tprefix = function(prefix, term, soft) {
if (!prefix) return;
var file
, dir
2013-08-12 04:13:28 +00:00
, ch
, i
, sdiff
, sfile
, list;
2013-08-12 04:13:28 +00:00
if (Array.isArray(prefix)) {
for (i = 0; i < prefix.length; i++) {
2013-08-29 22:41:19 +00:00
file = this._tprefix(prefix[i], term, soft);
2013-08-12 04:13:28 +00:00
if (file) return file;
}
return;
}
var find = function(word) {
var file, ch;
file = path.resolve(prefix, word[0]);
try {
fs.statSync(file);
return file;
} catch (e) {
;
}
ch = word[0].charCodeAt(0).toString(16);
if (ch.length < 2) ch = '0' + ch;
file = path.resolve(prefix, ch);
try {
fs.statSync(file);
return file;
} catch (e) {
;
}
};
if (!term) {
// Make sure the directory's sub-directories
// are all one-letter, or hex digits.
// return find('x') ? prefix : null;
try {
dir = fs.readdirSync(prefix).filter(function(file) {
return file.length !== 1 && !/^[0-9a-fA-F]{2}$/.test(file);
});
if (!dir.length) {
return prefix;
}
} catch (e) {
;
}
return;
}
term = path.basename(term);
dir = find(term);
if (!dir) return;
if (soft) {
try {
list = fs.readdirSync(dir);
} catch (e) {
return;
}
list.forEach(function(file) {
if (file.indexOf(term) === 0) {
var diff = file.length - term.length;
if (!sfile || diff < sdiff) {
sdiff = diff;
sfile = file;
}
}
});
return sfile && (soft || sdiff === 0)
? path.resolve(dir, sfile)
: null;
}
file = path.resolve(dir, term);
try {
fs.statSync(file);
return file;
} catch (e) {
;
}
};
2013-02-22 11:20:50 +00:00
/**
* Terminfo Parser
* All shorts are little-endian
*/
Tput.prototype.parseTerminfo = function(data, file) {
2013-02-08 13:43:45 +00:00
var info = {}
, extended
2013-02-08 13:43:45 +00:00
, l = data.length
2013-02-24 13:39:29 +00:00
, i = 0
, v
, o;
2013-02-08 13:43:45 +00:00
var h = info.header = {
dataSize: data.length,
headerSize: 12,
magicNumber: (data[1] << 8) | data[0],
namesSize: (data[3] << 8) | data[2],
boolCount: (data[5] << 8) | data[4],
numCount: (data[7] << 8) | data[6],
strCount: (data[9] << 8) | data[8],
strTableSize: (data[11] << 8) | data[10]
};
h.total = h.headerSize
+ h.namesSize
+ h.boolCount
+ h.numCount * 2
+ h.strCount * 2
+ h.strTableSize;
2013-02-27 18:17:15 +00:00
i += h.headerSize;
2013-02-08 13:43:45 +00:00
// Names Section
var names = data.toString('ascii', i, i + h.namesSize - 1)
, parts = names.split('|')
, name = parts[0]
2013-02-23 22:01:50 +00:00
, desc = parts.pop();
2013-02-08 13:43:45 +00:00
info.name = name;
2013-02-23 22:01:50 +00:00
info.names = parts;
2013-02-08 13:43:45 +00:00
info.desc = desc;
info.dir = path.resolve(file, '..', '..');
info.file = file;
2013-02-08 13:43:45 +00:00
i += h.namesSize - 1;
// Names is nul-terminated.
assert.equal(data[i], 0);
i++;
// Booleans Section
// One byte for each flag
// Same order as <term.h>
info.bools = {};
l = i + h.boolCount;
2013-02-24 13:39:29 +00:00
o = 0;
2013-02-08 13:43:45 +00:00
for (; i < l; i++) {
2013-02-25 06:40:46 +00:00
v = Tput.bools[o++];
2013-03-04 19:00:14 +00:00
info.bools[v] = data[i] === 1;
2013-02-08 13:43:45 +00:00
}
// Null byte in between to make sure numbers begin on an even byte.
if (i % 2) {
assert.equal(data[i], 0);
i++;
}
// Numbers Section
info.numbers = {};
l = i + h.numCount * 2;
2013-02-24 13:39:29 +00:00
o = 0;
2013-02-08 13:43:45 +00:00
for (; i < l; i += 2) {
2013-02-25 06:40:46 +00:00
v = Tput.numbers[o++];
2013-02-08 13:43:45 +00:00
if (data[i + 1] === 0377 && data[i] === 0377) {
2013-02-24 13:39:29 +00:00
info.numbers[v] = -1;
2013-02-08 13:43:45 +00:00
} else {
2013-02-24 13:39:29 +00:00
info.numbers[v] = (data[i + 1] << 8) | data[i];
2013-02-08 13:43:45 +00:00
}
}
// Strings Section
info.strings = {};
l = i + h.strCount * 2;
2013-02-24 13:39:29 +00:00
o = 0;
2013-02-08 13:43:45 +00:00
for (; i < l; i += 2) {
2013-02-25 06:40:46 +00:00
v = Tput.strings[o++];
2013-02-08 13:43:45 +00:00
if (data[i + 1] === 0377 && data[i] === 0377) {
2013-02-24 13:39:29 +00:00
info.strings[v] = -1;
2013-02-08 13:43:45 +00:00
} else {
2013-02-24 13:39:29 +00:00
info.strings[v] = (data[i + 1] << 8) | data[i];
2013-02-08 13:43:45 +00:00
}
}
// String Table
Object.keys(info.strings).forEach(function(key) {
if (info.strings[key] === -1) {
delete info.strings[key];
return;
}
// Workaround: fix an odd bug in the screen-256color terminfo where it tries
// to set -1, but it appears to have {0xfe, 0xff} instead of {0xff, 0xff}.
// TODO: Possibly handle errors gracefully below, as well as in the
// extended info. Also possibly do: `if (info.strings[key] >= data.length)`.
if (info.strings[key] === 65534) {
delete info.strings[key];
return;
}
2013-02-08 13:43:45 +00:00
var s = i + info.strings[key]
, j = s;
while (data[j]) j++;
assert(j < data.length);
2013-02-08 13:43:45 +00:00
info.strings[key] = data.toString('ascii', s, j);
});
2013-02-15 17:42:52 +00:00
// Extended Header
if (this.extended !== false) {
i--;
2013-02-24 22:31:33 +00:00
i += h.strTableSize;
if (i % 2) {
assert.equal(data[i], 0);
i++;
}
2013-02-15 17:42:52 +00:00
l = data.length;
2013-02-26 01:10:19 +00:00
if (i < l - 1) {
try {
extended = this.parseExtended(data.slice(i));
} catch (e) {
if (this.debug) {
throw e;
}
return info;
}
2013-03-06 10:44:48 +00:00
info.header.extended = extended.header;
2013-02-25 00:47:37 +00:00
['bools', 'numbers', 'strings'].forEach(function(key) {
merge(info[key], extended[key]);
2013-02-15 17:42:52 +00:00
});
}
2013-02-08 13:43:45 +00:00
}
return info;
};
2013-02-25 00:47:37 +00:00
/**
* Extended Parsing
*/
// Some data to help understand:
2013-02-24 22:31:33 +00:00
// For xterm, non-extended header:
// { dataSize: 3270,
// headerSize: 12,
// magicNumber: 282,
// namesSize: 48,
// boolCount: 38,
// numCount: 15,
// strCount: 413,
// strTableSize: 1388,
// total: 2342 }
// For xterm, header:
// Offset: 2342
// { header:
// { dataSize: 928,
// headerSize: 10,
// boolCount: 2,
// numCount: 1,
// strCount: 57,
// strTableSize: 117,
// lastStrTableOffset: 680,
// total: 245 },
// For xterm, layout:
// { header: '0 - 10', // length: 10
// bools: '10 - 12', // length: 2
// numbers: '12 - 14', // length: 2
2013-02-25 00:19:04 +00:00
// strings: '14 - 128', // length: 114 (57 short)
// symoffsets: '128 - 248', // length: 120 (60 short)
// stringtable: '248 - 612', // length: 364
// sym: '612 - 928' } // length: 316
2013-02-24 22:31:33 +00:00
//
// How lastStrTableOffset works:
2013-07-18 19:52:56 +00:00
// data.length - h.lastStrTableOffset === 248
// (sym-offset end, string-table start)
// 364 + 316 === 680 (lastStrTableOffset)
// How strTableSize works:
// h.strCount + [symOffsetCount] === h.strTableSize
// 57 + 60 === 117 (strTableSize)
// symOffsetCount doesn't actually exist in the header. it's just implied.
// Getting the number of sym offsets:
// h.symOffsetCount = h.strTableSize - h.strCount;
// h.symOffsetSize = (h.strTableSize - h.strCount) * 2;
2013-02-24 22:31:33 +00:00
2013-02-25 00:47:37 +00:00
Tput.prototype.parseExtended = function(data) {
2013-02-08 13:43:45 +00:00
var info = {}
, l = data.length
2013-02-25 00:47:37 +00:00
, i = 0;
2013-02-08 13:43:45 +00:00
2013-02-24 21:07:54 +00:00
var h = info.header = {
dataSize: data.length,
headerSize: 10,
boolCount: (data[i + 1] << 8) | data[i + 0],
numCount: (data[i + 3] << 8) | data[i + 2],
strCount: (data[i + 5] << 8) | data[i + 4],
strTableSize: (data[i + 7] << 8) | data[i + 6],
lastStrTableOffset: (data[i + 9] << 8) | data[i + 8]
};
// h.symOffsetCount = h.strTableSize - h.strCount;
2013-02-24 21:07:54 +00:00
h.total = h.headerSize
+ h.boolCount
+ h.numCount * 2
+ h.strCount * 2
+ h.strTableSize;
2013-02-27 18:17:15 +00:00
i += h.headerSize;
2013-02-24 21:07:54 +00:00
// Booleans Section
// One byte for each flag
2013-02-24 22:43:26 +00:00
var _bools = [];
2013-02-24 21:07:54 +00:00
l = i + h.boolCount;
for (; i < l; i++) {
2013-03-04 19:00:14 +00:00
_bools.push(data[i] === 1);
2013-02-24 21:07:54 +00:00
}
// Null byte in between to make sure numbers begin on an even byte.
if (i % 2) {
assert.equal(data[i], 0);
i++;
}
// Numbers Section
2013-02-24 22:43:26 +00:00
var _numbers = [];
2013-02-24 21:07:54 +00:00
l = i + h.numCount * 2;
for (; i < l; i += 2) {
if (data[i + 1] === 0377 && data[i] === 0377) {
2013-02-24 22:43:26 +00:00
_numbers.push(-1);
2013-02-24 21:07:54 +00:00
} else {
2013-02-24 22:43:26 +00:00
_numbers.push((data[i + 1] << 8) | data[i]);
2013-02-24 21:07:54 +00:00
}
}
// Strings Section
2013-02-24 22:43:26 +00:00
var _strings = [];
2013-02-24 21:07:54 +00:00
l = i + h.strCount * 2;
for (; i < l; i += 2) {
if (data[i + 1] === 0377 && data[i] === 0377) {
2013-02-24 22:43:26 +00:00
_strings.push(-1);
2013-02-24 21:07:54 +00:00
} else {
2013-02-24 22:43:26 +00:00
_strings.push((data[i + 1] << 8) | data[i]);
2013-02-24 21:07:54 +00:00
}
}
2013-02-25 00:22:32 +00:00
// Pass over the sym offsets and get to the string table.
2013-02-25 00:19:04 +00:00
i = data.length - h.lastStrTableOffset;
2013-02-25 08:09:17 +00:00
// Might be better to do this instead if the file has trailing bytes:
// i += h.symOffsetCount * 2;
2013-02-25 00:19:04 +00:00
2013-02-24 22:43:26 +00:00
// String Table
2013-02-25 00:43:04 +00:00
var high = 0;
2013-02-24 22:43:26 +00:00
_strings.forEach(function(offset, k) {
2013-02-24 21:07:54 +00:00
if (offset === -1) {
2013-02-24 22:43:26 +00:00
_strings[k] = '';
2013-02-24 22:31:33 +00:00
return;
2013-02-24 21:07:54 +00:00
}
var s = i + offset
, j = s;
while (data[j]) j++;
assert(j < data.length);
2013-02-24 21:07:54 +00:00
2013-02-25 00:43:04 +00:00
// Find out where the string table ends by
// getting the highest string length.
if (high < j - i) {
high = j - i;
}
2013-02-24 22:43:26 +00:00
_strings[k] = data.toString('ascii', s, j);
2013-02-08 13:43:45 +00:00
});
2013-02-24 21:07:54 +00:00
// Symbol Table
2013-02-25 00:43:04 +00:00
// Add one to the highest string length because we didn't count \0.
i += high + 1;
2013-02-24 21:07:54 +00:00
l = data.length;
var sym = []
, j;
2013-02-24 21:07:54 +00:00
for (; i < l; i++) {
j = i;
while (data[j]) j++;
sym.push(data.toString('ascii', i, j));
i = j;
}
2013-02-24 22:43:26 +00:00
// Identify by name
2013-03-04 19:00:14 +00:00
j = 0;
2013-02-24 22:43:26 +00:00
info.bools = {};
_bools.forEach(function(bool) {
2013-03-04 19:00:14 +00:00
info.bools[sym[j++]] = bool;
2013-02-24 21:07:54 +00:00
});
2013-02-24 22:43:26 +00:00
info.numbers = {};
_numbers.forEach(function(number) {
2013-03-04 19:00:14 +00:00
info.numbers[sym[j++]] = number;
2013-02-24 21:07:54 +00:00
});
2013-02-24 22:43:26 +00:00
info.strings = {};
_strings.forEach(function(string) {
2013-03-04 19:00:14 +00:00
info.strings[sym[j++]] = string;
2013-02-24 21:07:54 +00:00
});
2013-02-24 22:43:26 +00:00
2013-03-04 19:00:14 +00:00
// Should be the very last bit of data.
assert.equal(i, data.length);
2013-02-08 13:43:45 +00:00
return info;
};
Tput.prototype.compileTerminfo = function(term) {
return this.compile(this.readTerminfo(term));
};
Tput.prototype.injectTerminfo = function(term) {
return this.inject(this.compileTerminfo(term));
2013-02-28 00:25:59 +00:00
};
2013-02-22 11:20:50 +00:00
/**
* Compiler - terminfo cap->javascript
*/
Tput.prototype.compile = function(info) {
2013-02-28 00:25:59 +00:00
var self = this;
2013-02-27 22:57:11 +00:00
if (!info) {
throw new Error('Terminal not found.');
}
this.detectFeatures(info);
2013-07-23 05:22:49 +00:00
this._debug(info);
2013-02-20 00:35:26 +00:00
2013-02-28 00:25:59 +00:00
info.all = {};
info.methods = {};
2013-02-08 13:43:45 +00:00
2013-02-28 00:25:59 +00:00
['bools', 'numbers', 'strings'].forEach(function(type) {
Object.keys(info[type]).forEach(function(key) {
info.all[key] = info[type][key];
2013-07-23 05:37:13 +00:00
info.methods[key] = self._compile(info, key, info.all[key]);
2013-02-28 00:25:59 +00:00
});
2013-02-19 19:21:28 +00:00
});
2013-02-24 14:02:07 +00:00
Tput.bools.forEach(function(key) {
2013-02-28 00:25:59 +00:00
if (info.methods[key] == null) info.methods[key] = false;
2013-02-24 14:02:07 +00:00
});
Tput.numbers.forEach(function(key) {
2013-02-28 00:25:59 +00:00
if (info.methods[key] == null) info.methods[key] = -1;
2013-02-24 14:02:07 +00:00
});
Tput.strings.forEach(function(key) {
2013-02-28 00:25:59 +00:00
if (!info.methods[key]) info.methods[key] = noop;
2013-02-16 21:11:05 +00:00
});
2013-02-20 00:35:26 +00:00
2013-02-28 00:25:59 +00:00
Object.keys(info.methods).forEach(function(key) {
2013-08-30 02:55:36 +00:00
if (!Tput.alias[key]) return;
Tput.alias[key].forEach(function(alias) {
2013-02-28 00:25:59 +00:00
info.methods[alias] = info.methods[key];
});
2013-08-30 02:55:36 +00:00
// Could just use:
// Object.keys(Tput.aliasMap).forEach(function(key) {
// info.methods[key] = info.methods[Tput.aliasMap[key]];
// });
2013-02-24 16:59:20 +00:00
});
2013-02-28 00:25:59 +00:00
return info;
};
Tput.prototype.inject = function(info) {
var self = this
, methods = info.methods || info;
Object.keys(methods).forEach(function(key) {
if (typeof methods[key] !== 'function') {
self[key] = methods[key];
2013-02-24 14:02:07 +00:00
return;
}
2013-02-20 13:47:11 +00:00
self[key] = function() {
var args = Array.prototype.slice.call(arguments);
2013-02-28 00:25:59 +00:00
return methods[key].call(self, args);
2013-02-20 13:47:11 +00:00
};
2013-02-20 00:35:26 +00:00
});
2013-06-25 11:34:10 +00:00
this.info = info;
this.all = info.all;
this.methods = info.methods;
this.bools = info.bools;
this.numbers = info.numbers;
this.strings = info.strings;
if (!~info.names.indexOf(this.terminal)) {
this.terminal = info.name;
}
this.features = info.features;
Object.keys(info.features).forEach(function(key) {
self[key] = info.features[key];
});
2013-02-16 21:11:05 +00:00
};
// See:
// ~/ncurses/ncurses/tinfo/lib_tparm.c
// ~/ncurses/ncurses/tinfo/comp_scan.c
2013-07-23 05:37:13 +00:00
Tput.prototype._compile = function(info, key, str) {
var self = this;
this._debug('Compiling %s: %s', key, JSON.stringify(str));
2013-07-23 05:22:49 +00:00
switch (typeof str) {
2013-02-08 13:43:45 +00:00
case 'boolean':
2013-07-23 05:22:49 +00:00
return str;
2013-02-08 13:43:45 +00:00
case 'number':
2013-07-23 05:22:49 +00:00
return str;
2013-02-08 13:43:45 +00:00
case 'string':
2013-02-16 21:11:05 +00:00
break;
default:
2013-02-26 01:10:19 +00:00
return noop;
2013-02-16 21:11:05 +00:00
}
2013-07-23 05:22:49 +00:00
if (!str) {
2013-02-25 06:40:46 +00:00
return noop;
}
2013-02-25 01:20:56 +00:00
// See:
// ~/ncurses/progs/tput.c - tput() - L149
// ~/ncurses/progs/tset.c - set_init() - L992
2013-07-23 05:22:49 +00:00
if (key === 'init_file' || key === 'reset_file') {
try {
// NOTE: Should we consider this code and parse it instead?
2013-07-23 05:22:49 +00:00
str = fs.readFileSync(str, 'utf8');
return function() { return str; };
} catch (e) {
return noop;
}
}
2013-07-23 05:22:49 +00:00
var tkey = info.name + '.' + key
, header = 'var v, dyn = {}, stat = {}, stack = [], out = [];'
, footer = ';return out.join("");'
2013-07-22 05:51:39 +00:00
, code = header
2013-07-23 05:22:49 +00:00
, val = str
2013-02-20 20:01:01 +00:00
, buff = ''
2013-07-23 05:37:13 +00:00
, cap
, ch
, fi
2013-07-14 08:14:48 +00:00
, then
2013-02-24 13:44:48 +00:00
, els
, end;
function read(regex, no) {
2013-02-17 22:40:45 +00:00
cap = regex.exec(val);
if (!cap) return;
val = val.substring(cap[0].length);
2013-07-23 05:37:13 +00:00
ch = cap[1];
if (!no) clear();
2013-02-27 23:17:26 +00:00
return cap;
}
2013-02-22 09:40:58 +00:00
function stmt(c) {
if (code[code.length-1] === ',') {
code = code.slice(0, -1);
}
code += c;
}
function expr(c) {
code += c + ',';
}
function echo(c) {
2013-07-22 05:51:39 +00:00
if (c === '""') return;
expr('out.push(' + c + ')');
2013-02-22 09:40:58 +00:00
}
function print(c) {
2013-07-23 05:22:49 +00:00
buff += c;
2013-02-20 20:01:01 +00:00
}
2013-07-23 05:37:13 +00:00
function clear() {
if (buff) {
echo(JSON.stringify(buff).replace(/\\u00([0-9a-fA-F]{2})/g, '\\x$1'));
buff = '';
}
2013-02-22 10:11:04 +00:00
}
2013-02-17 22:40:45 +00:00
while (val) {
// Ignore newlines
2013-07-23 05:22:49 +00:00
if (read(/^\n /, true)) {
continue;
}
2013-02-16 21:11:05 +00:00
// '^A' -> ^A
if (read(/^\^(.)/i, true)) {
if (!(ch >= ' ' && ch <= '~')) {
2013-07-23 05:22:49 +00:00
this._debug('%s: bad caret char.', tkey);
// NOTE: ncurses appears to simply
// continue in this situation, but
// I could be wrong.
print(cap[0]);
continue;
}
if (ch === '?') {
2013-07-23 05:22:49 +00:00
ch = '\x7f';
} else {
ch = ch.charCodeAt(0) & 31;
if (ch === 0) ch = 128;
2013-07-23 05:22:49 +00:00
ch = String.fromCharCode(ch);
2013-02-16 21:11:05 +00:00
}
2013-02-22 09:40:58 +00:00
print(ch);
2013-02-16 21:11:05 +00:00
continue;
}
// 3 octal digits -> character
if (read(/^\\([0-7]{3})/, true)) {
2013-07-23 05:22:49 +00:00
print(String.fromCharCode(parseInt(ch, 8)));
continue;
}
// '\e' -> ^[
2013-02-16 21:11:05 +00:00
// '\n' -> \n
// '\r' -> \r
// '\0' -> \200 (special case)
if (read(/^\\([eEnlrtbfs\^\\,:0]|.)/, true)) {
2013-02-16 21:11:05 +00:00
switch (ch) {
case 'e':
case 'E':
2013-07-23 05:22:49 +00:00
ch = '\x1b';
break;
2013-02-16 21:11:05 +00:00
case 'n':
2013-07-23 05:22:49 +00:00
ch = '\n';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case 'l':
2013-07-23 05:22:49 +00:00
ch = '\x85';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case 'r':
2013-07-23 05:22:49 +00:00
ch = '\r';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case 't':
2013-07-23 05:22:49 +00:00
ch = '\t';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case 'b':
2013-07-23 05:22:49 +00:00
ch = '\x08';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case 'f':
2013-07-23 05:22:49 +00:00
ch = '\x0c';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case 's':
2013-02-22 09:40:58 +00:00
ch = ' ';
2013-02-20 13:47:11 +00:00
break;
2013-02-24 14:19:38 +00:00
case '^':
ch = '^';
break;
2013-02-16 21:11:05 +00:00
case '\\':
2013-07-23 05:22:49 +00:00
ch = '\\';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case ',':
2013-02-22 09:40:58 +00:00
ch = ',';
2013-02-20 13:47:11 +00:00
break;
2013-02-24 14:19:38 +00:00
case ':':
ch = ':';
2013-02-20 13:47:11 +00:00
break;
2013-02-16 21:11:05 +00:00
case '0':
2013-07-23 05:22:49 +00:00
ch = '\200';
2013-02-20 13:47:11 +00:00
break;
case 'a':
2013-07-23 05:22:49 +00:00
ch = '\x07';
break;
2013-02-22 09:40:58 +00:00
default:
2013-07-23 05:22:49 +00:00
this._debug('%s: bad backslash char.', tkey);
ch = cap[0];
2013-02-22 09:40:58 +00:00
break;
2013-02-15 23:08:36 +00:00
}
2013-02-22 09:40:58 +00:00
print(ch);
2013-02-16 21:11:05 +00:00
continue;
}
2013-02-16 18:15:10 +00:00
2013-02-16 21:11:05 +00:00
// $<5> -> padding
2013-02-19 19:21:28 +00:00
// e.g. flash_screen: '\u001b[?5h$<100/>\u001b[?5l',
if (read(/^\$<(\d+)([*\/]{0,2})>/, true)) {
2013-02-24 02:38:24 +00:00
if (this.padding) print(cap[0]);
2013-02-16 21:11:05 +00:00
continue;
}
// %% outputs `%'
if (read(/^%%/, true)) {
2013-02-22 09:40:58 +00:00
print('%');
2013-02-16 21:11:05 +00:00
continue;
}
// %[[:]flags][width[.precision]][doxXs]
// as in printf, flags are [-+#] and space. Use a `:' to allow the
// next character to be a `-' flag, avoiding interpreting "%-" as an
// operator.
2013-02-28 01:39:08 +00:00
// %c print pop() like %c in printf
// Example from screen terminfo:
// S0: "\u001b(%p1%c"
// %d print pop()
// "Print (e.g., "%d") is a special case."
// %s print pop() like %s in printf
2013-07-22 05:51:39 +00:00
if (read(/^%((?::-|[+# ]){1,4})?(\d+(?:\.\d+)?)?([doxXsc])/)) {
if (this.printf || cap[1] || cap[2] || ~'oxX'.indexOf(cap[3])) {
2013-02-25 12:26:21 +00:00
echo('sprintf("'+ cap[0].replace(':-', '-') + '", stack.pop())');
2013-07-22 05:51:39 +00:00
} else if (cap[3] === 'c') {
2013-07-23 05:22:49 +00:00
echo('(v = stack.pop(), isFinite(v) '
+ '? String.fromCharCode(v || 0200) : "")');
2013-02-25 12:26:21 +00:00
} else {
echo('stack.pop()');
}
2013-02-16 21:11:05 +00:00
continue;
}
// %p[1-9]
// push i'th parameter
2013-02-18 20:43:53 +00:00
if (read(/^%p([1-9])/)) {
2013-07-23 05:37:13 +00:00
expr('(stack.push(v = params[' + (ch - 1) + ']), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %P[a-z]
// set dynamic variable [a-z] to pop()
2013-02-18 20:43:53 +00:00
if (read(/^%P([a-z])/)) {
2013-07-23 05:37:13 +00:00
expr('dyn.' + ch + ' = stack.pop()');
2013-02-16 21:11:05 +00:00
continue;
}
// %g[a-z]
// get dynamic variable [a-z] and push it
2013-02-18 20:43:53 +00:00
if (read(/^%g([a-z])/)) {
2013-07-23 05:37:13 +00:00
expr('(stack.push(dyn.' + ch + '), dyn.' + ch + ')');
2013-02-16 21:11:05 +00:00
continue;
}
// %P[A-Z]
// set static variable [a-z] to pop()
2013-02-18 20:43:53 +00:00
if (read(/^%P([A-Z])/)) {
2013-07-23 05:37:13 +00:00
expr('stat.' + ch + ' = stack.pop()');
2013-02-16 21:11:05 +00:00
continue;
}
// %g[A-Z]
// get static variable [a-z] and push it
// The terms "static" and "dynamic" are misleading. Historically,
// these are simply two different sets of variables, whose values are
// not reset between calls to tparm. However, that fact is not
// documented in other implementations. Relying on it will adversely
// impact portability to other implementations.
2013-02-18 20:43:53 +00:00
if (read(/^%g([A-Z])/)) {
2013-07-23 05:37:13 +00:00
expr('(stack.push(v = stat.' + ch + '), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %'c' char constant c
2013-07-23 05:22:49 +00:00
// NOTE: These are stored as c chars, exemplified by:
// cursor_address: "\u001b=%p1%' '%+%c%p2%' '%+%c"
if (read(/^%'(.)'/)) {
expr('(stack.push(v = ' + ch.charCodeAt(0) + '), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %{nn}
// integer constant nn
2013-02-18 20:43:53 +00:00
if (read(/^%\{(\d+)\}/)) {
2013-02-22 09:40:58 +00:00
expr('(stack.push(v = ' + ch + '), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %l push strlen(pop)
2013-02-18 20:43:53 +00:00
if (read(/^%l/)) {
2013-07-23 05:22:49 +00:00
expr('(stack.push(v = (stack.pop() || "").length || 0), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %+ %- %* %/ %m
// arithmetic (%m is mod): push(pop() op pop())
// %& %| %^
// bit operations (AND, OR and exclusive-OR): push(pop() op pop())
// %= %> %<
// logical operations: push(pop() op pop())
2013-02-18 20:43:53 +00:00
if (read(/^%([+\-*\/m&|\^=><])/)) {
2013-07-23 05:37:13 +00:00
if (ch === '=') ch = '===';
else if (ch === 'm') ch = '%';
2013-08-29 22:46:20 +00:00
expr('(v = stack.pop(),'
+ ' stack.push(v = (stack.pop() ' + ch + ' v) || 0),'
+ ' v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %A, %O
// logical AND and OR operations (for conditionals)
2013-02-18 20:43:53 +00:00
if (read(/^%([AO])/)) {
// Are we supposed to store the result on the stack?
expr('(stack.push(v = (stack.pop() '
2013-07-23 05:37:13 +00:00
+ (ch === 'A' ? '&&' : '||')
+ ' stack.pop())), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %! %~
// unary operations (logical and bit complement): push(op pop())
2013-02-18 20:43:53 +00:00
if (read(/^%([!~])/)) {
2013-07-23 05:37:13 +00:00
expr('(stack.push(v = ' + ch + 'stack.pop()), v)');
2013-02-16 21:11:05 +00:00
continue;
}
// %i add 1 to first two parameters (for ANSI terminals)
2013-02-18 20:43:53 +00:00
if (read(/^%i/)) {
// Are these supposed to go on the stack in certain situations?
// ncurses doesn't seem to put them on the stack, but xterm.user6
// seems to assume they're on the stack for some reason. Could
// just be a bad terminfo string.
2013-07-23 05:22:49 +00:00
// user6: "\u001b[%i%d;%dR" - possibly a termcap-style string.
// expr('(params[0] |= 0, params[1] |= 0, params[0]++, params[1]++)');
2013-02-22 09:40:58 +00:00
expr('(params[0]++, params[1]++)');
2013-02-16 21:11:05 +00:00
continue;
}
// %? expr %t thenpart %e elsepart %;
// This forms an if-then-else. The %e elsepart is optional. Usually
// the %? expr part pushes a value onto the stack, and %t pops it from
// the stack, testing if it is nonzero (true). If it is zero (false),
// control passes to the %e (else) part.
// It is possible to form else-if's a la Algol 68:
// %? c1 %t b1 %e c2 %t b2 %e c3 %t b3 %e c4 %t b4 %e %;
2013-02-16 21:11:05 +00:00
// where ci are conditions, bi are bodies.
2013-02-18 20:43:53 +00:00
if (read(/^%\?/)) {
end = -1;
2013-02-22 09:40:58 +00:00
stmt(';if (');
2013-02-16 21:11:05 +00:00
continue;
}
2013-02-18 20:43:53 +00:00
if (read(/^%t/)) {
end = -1;
// Technically this is supposed to pop everything off the stack that was
// pushed onto the stack after the if statement, see man terminfo.
// Right now, we don't pop anything off. This could cause compat issues.
// Perhaps implement a "pushed" counter from the time the if statement
// is added, to the time the then statement is added, and pop off
// the appropriate number of elements.
// while (pushed--) expr('stack.pop()');
2013-02-22 09:40:58 +00:00
stmt(') {');
2013-02-16 21:11:05 +00:00
continue;
}
2013-07-14 08:14:48 +00:00
// Terminfo does elseif's like
// this: %?[expr]%t...%e[expr]%t...%;
2013-02-18 20:43:53 +00:00
if (read(/^%e/)) {
2013-07-14 08:14:48 +00:00
fi = val.indexOf('%?');
2013-02-24 13:44:48 +00:00
then = val.indexOf('%t');
els = val.indexOf('%e');
end = val.indexOf('%;');
if (end === -1) end = Infinity;
2013-07-14 08:14:48 +00:00
if (then !== -1 && then < end
&& (fi === -1 || then < fi)
&& (els === -1 || then < els)) {
2013-02-22 09:40:58 +00:00
stmt('} else if (');
2013-02-17 19:25:58 +00:00
} else {
2013-02-22 09:40:58 +00:00
stmt('} else {');
2013-02-17 19:25:58 +00:00
}
2013-02-16 21:11:05 +00:00
continue;
}
2013-02-18 20:43:53 +00:00
if (read(/^%;/)) {
2013-07-23 05:22:49 +00:00
end = null;
2013-02-22 09:40:58 +00:00
stmt('}');
2013-02-16 21:11:05 +00:00
continue;
}
2013-02-16 23:54:20 +00:00
buff += val[0];
2013-02-16 21:11:05 +00:00
val = val.substring(1);
2013-02-08 13:43:45 +00:00
}
// Clear the buffer of any remaining text.
2013-02-18 17:00:44 +00:00
clear();
2013-02-17 19:25:58 +00:00
// Some terminfos (I'm looking at you, atari-color), don't end an if
// statement. It's assumed terminfo will automatically end it for
// them, because they are a bunch of lazy bastards.
if (end != null) {
stmt('}');
}
// Add the footer.
2013-07-22 05:51:39 +00:00
stmt(footer);
2013-02-08 13:43:45 +00:00
2013-07-22 05:51:39 +00:00
// Optimize and cleanup generated code.
v = code.slice(header.length, -footer.length);
if (!v.length) {
2013-02-25 01:20:56 +00:00
code = 'return "";';
} else if (v = /^out\.push\(("(?:[^"]|\\")+")\)$/.exec(v)) {
2013-07-22 05:51:39 +00:00
code = 'return ' + v[1] + ';';
} else {
// Turn `(stack.push(v = params[0]), v),out.push(stack.pop())`
// into `out.push(params[0])`.
2013-07-22 05:51:39 +00:00
code = code.replace(
/\(stack\.push\(v = params\[(\d+)\]\), v\),out\.push\(stack\.pop\(\)\)/g,
'out.push(params[$1])');
2013-07-22 05:51:39 +00:00
// Remove unnecessary variable initializations.
v = code.slice(header.length, -footer.length);
if (!~v.indexOf('v = ')) code = code.replace('v, ', '');
if (!~v.indexOf('dyn')) code = code.replace('dyn = {}, ', '');
if (!~v.indexOf('stat')) code = code.replace('stat = {}, ', '');
if (!~v.indexOf('stack')) code = code.replace('stack = [], ', '');
// Turn `var out = [];out.push("foo"),` into `var out = ["foo"];`.
code = code.replace(
/out = \[\];out\.push\(("(?:[^"]|\\")+")\),/,
'out = [$1];');
}
// Terminfos `wyse350-vb`, and `wy350-w`
// seem to have a few broken strings.
2013-07-23 05:22:49 +00:00
if (str === '\u001b%?') {
code = 'return "\\x1b";';
2013-02-21 09:08:17 +00:00
}
2013-02-20 00:35:26 +00:00
if (this.debug) {
2013-02-21 09:08:17 +00:00
v = code
.replace(/\x1b/g, '\\x1b')
.replace(/\r/g, '\\r')
.replace(/\n/g, '\\n');
process.stdout.write(v + '\n');
2013-02-20 00:35:26 +00:00
}
2013-02-16 23:54:20 +00:00
try {
if (this.options.stringify && code.indexOf('return ') === 0) {
2013-07-22 05:51:39 +00:00
return new Function('', code)();
}
return this.printf || ~code.indexOf('sprintf(')
2013-02-25 12:26:21 +00:00
? new Function('sprintf, params', code).bind(null, sprintf)
: new Function('params', code);
2013-02-16 23:54:20 +00:00
} catch (e) {
2013-07-14 08:14:48 +00:00
console.error('');
2013-07-23 05:22:49 +00:00
console.error('Error on %s:', tkey);
console.error(JSON.stringify(str));
2013-07-14 08:14:48 +00:00
console.error('');
console.error(code.replace(/(,|;)/g, '$1\n'));
2013-02-18 17:00:44 +00:00
e.stack = e.stack.replace(/\x1b/g, '\\x1b');
throw e;
2013-02-16 23:54:20 +00:00
}
2013-02-08 13:43:45 +00:00
};
// See: ~/ncurses/ncurses/tinfo/lib_tputs.c
Tput.prototype._print = function(code, print, done) {
2013-02-24 18:58:29 +00:00
var print = print || write
, done = done || noop
, xon = !this.bools.needs_xon_xoff || this.bools.xon_xoff;
2013-02-24 18:58:29 +00:00
2013-02-24 02:38:24 +00:00
if (!this.padding) {
print(code);
return done();
}
var parts = code.split(/(?=\$<[\d.]+[*\/]{0,2}>)/)
2013-02-24 02:38:24 +00:00
, i = 0;
(function next() {
if (i === parts.length) {
return done();
}
var part = parts[i++]
, padding = /^\$<([\d.]+)([*\/]{0,2})>/.exec(part)
, amount
, suffix
, affect;
2013-02-24 02:38:24 +00:00
if (!padding) {
print(part);
return next();
}
2013-02-24 14:13:25 +00:00
part = part.substring(padding[0].length);
amount = +padding[1];
suffix = padding[2];
// A `/' suffix indicates that the padding is mandatory and forces a
// delay of the given number of milliseconds even on devices for which xon
// is present to indicate flow control.
if (xon && !~suffix.indexOf('/')) {
print(part);
return next();
}
2013-02-24 02:38:24 +00:00
// A `*' indicates that the padding required is proportional to the number
// of lines affected by the operation, and the amount given is the
// per-affected-unit padding required. (In the case of insert character,
// the factor is still the number of lines affected.) Normally, padding is
// advisory if the device has the xon capability; it is used for cost
// computation but does not trigger delays.
if (~suffix.indexOf('*')) {
if (affect = /\x1b\[(\d+)[LM]/.exec(part)) {
amount *= +affect[1];
}
// The above is a huge workaround. In reality, we need to compile
// `_print` into the string functions and check the cap name and
// params.
// if (cap === 'insert_line' || cap === 'delete_line') {
// amount *= params[0];
// }
// if (cap === 'clear_screen') {
// amount *= process.stdout.rows;
// }
2013-02-24 02:38:24 +00:00
}
return setTimeout(function() {
print(part);
return next();
}, amount);
2013-02-24 02:38:24 +00:00
})();
};
2013-02-22 21:51:13 +00:00
/**
* Termcap
*/
Tput.cpaths = [
process.env.TERMCAP || '',
(process.env.TERMPATH || '').split(/[: ]/),
(process.env.HOME || '') + '/.termcap',
'/usr/share/misc/termcap',
'/etc/termcap'
];
Tput.prototype.readTermcap = function(term) {
var self = this
, term = term || this.terminal
2013-07-27 10:13:04 +00:00
, terms
, term_
, root
, paths
, i;
// Termcap has a bunch of terminals usually stored in one file/string,
// so we need to find the one containing our desired terminal.
if (~term.indexOf(path.sep) && (terms = this._tryCap(path.resolve(term)))) {
2013-07-27 10:13:04 +00:00
term_ = path.basename(term).split('.')[0];
if (terms[process.env.TERM]) {
term = process.env.TERM;
} else if (terms[term_]) {
term = term_;
} else {
term = Object.keys(terms)[0];
}
} else {
paths = Tput.cpaths.slice();
if (this.termcapFile) {
paths.unshift(this.termcapFile);
}
paths.push(Tput.termcap);
2013-08-29 22:41:19 +00:00
terms = this._tryCap(paths, term);
2013-07-27 10:13:04 +00:00
}
if (!terms) {
throw new Error('Cannot find termcap for: ' + term);
}
2013-07-27 10:13:04 +00:00
root = terms[term];
2013-02-28 00:34:41 +00:00
if (this.debug) {
this._termcap = terms;
}
(function tc(term) {
if (term && term.strings.tc) {
2013-03-05 02:03:00 +00:00
root.inherits = root.inherits || [];
root.inherits.push(term.strings.tc);
2013-07-23 05:22:49 +00:00
var names = terms[term.strings.tc]
? terms[term.strings.tc].names
: [term.strings.tc];
self._debug('%s inherits from %s.',
term.names.join('/'), names.join('/'));
var inherit = tc(terms[term.strings.tc]);
if (inherit) {
['bools', 'numbers', 'strings'].forEach(function(type) {
merge(term[type], inherit[type]);
});
}
}
return term;
2013-03-05 02:03:00 +00:00
})(root);
// Translate termcap names to terminfo-style names.
root = this.translateTermcap(root);
2013-03-05 02:03:00 +00:00
return root;
2013-02-22 21:51:13 +00:00
};
Tput.prototype._tryCap = function(file, term) {
if (!file) return;
var terms
, data
, i;
if (Array.isArray(file)) {
for (i = 0; i < file.length; i++) {
data = this._tryCap(file[i], term);
if (data) return data;
}
return;
}
// If the termcap string starts with `/`,
// ncurses considers it a filename.
data = file[0] === '/'
? tryRead(file)
: file;
if (!data) return;
terms = this.parseTermcap(data, file);
if (term && !terms[term]) {
return;
}
return terms;
};
2013-02-22 21:51:13 +00:00
/**
* Termcap Parser
* http://en.wikipedia.org/wiki/Termcap
2013-07-18 19:52:56 +00:00
* http://www.gnu.org/software
* /termutils/manual/termcap-1.3/html_mono/termcap.html
* http://www.gnu.org/software
* /termutils/manual/termcap-1.3/html_mono/termcap.html#SEC17
2013-02-22 21:51:13 +00:00
* http://tldp.org/HOWTO/Text-Terminal-HOWTO.html#toc16
* man termcap
*/
// Example:
// vt102|dec vt102:\
// :do=^J:co#80:li#24:cl=50\E[;H\E[2J:\
// :le=^H:bs:cm=5\E[%i%d;%dH:nd=2\E[C:up=2\E[A:\
// :ce=3\E[K:cd=50\E[J:so=2\E[7m:se=2\E[m:us=2\E[4m:ue=2\E[m:\
// :md=2\E[1m:mr=2\E[7m:mb=2\E[5m:me=2\E[m:is=\E[1;24r\E[24;1H:\
// :rs=\E>\E[?3l\E[?4l\E[?5l\E[?7h\E[?8h:ks=\E[?1h\E=:ke=\E[?1l\E>:\
// :ku=\EOA:kd=\EOB:kr=\EOC:kl=\EOD:kb=^H:\
// :ho=\E[H:k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:pt:sr=5\EM:vt#3:\
// :sc=\E7:rc=\E8:cs=\E[%i%d;%dr:vs=\E[?7l:ve=\E[?7h:\
// :mi:al=\E[L:dc=\E[P:dl=\E[M:ei=\E[4l:im=\E[4h:
Tput.prototype.parseTermcap = function(data, file) {
2013-02-22 21:51:13 +00:00
var terms = {}
, parts
2013-02-22 21:51:13 +00:00
, term
, entries
, fields
, field
, names
, i
, j
, k;
2013-02-22 21:51:13 +00:00
// remove escaped newlines
data = data.replace(/\\\n[ \t]*/g, '');
// remove comments
data = data.replace(/^#[^\n]+/gm, '');
// split entries
2013-02-24 13:40:42 +00:00
entries = data.trim().split(/\n+/);
2013-02-22 21:51:13 +00:00
for (i = 0; i < entries.length; i++) {
fields = entries[i].split(/:+/);
for (j = 0; j < fields.length; j++) {
field = fields[j].trim();
if (!field) continue;
if (j === 0) {
names = field.split('|');
term = {
2013-02-22 21:51:13 +00:00
name: names[0],
names: names,
desc: names.pop(),
2013-08-04 13:40:53 +00:00
file: ~file.indexOf(path.sep)
? path.resolve(file)
: file,
termcap: true
2013-02-22 21:51:13 +00:00
};
2013-02-27 18:17:15 +00:00
for (k = 0; k < names.length; k++) {
terms[names[k]] = term;
}
2013-02-22 21:51:13 +00:00
term.bools = {};
term.numbers = {};
term.strings = {};
2013-02-22 21:51:13 +00:00
continue;
}
if (~field.indexOf('=')) {
parts = field.split('=');
term.strings[parts[0]] = parts.slice(1).join('=');
} else if (~field.indexOf('#')) {
parts = field.split('#');
term.numbers[parts[0]] = +parts.slice(1).join('#');
} else {
term.bools[field] = true;
}
}
}
return terms;
};
/**
* Termcap Compiler
* man termcap
*/
2013-02-28 00:25:59 +00:00
Tput.prototype.translateTermcap = function(info) {
2013-02-27 22:57:11 +00:00
var self = this
, out = {};
if (!info) return;
2013-02-27 22:57:11 +00:00
2013-07-23 05:22:49 +00:00
this._debug(info);
2013-02-28 00:25:59 +00:00
['name', 'names', 'desc', 'file', 'termcap'].forEach(function(key) {
2013-02-27 23:17:26 +00:00
out[key] = info[key];
});
2013-02-27 22:57:11 +00:00
// Separate aliases for termcap
2013-08-30 02:55:36 +00:00
var map = (function() {
var out = {};
2013-02-28 07:33:04 +00:00
2013-08-30 02:55:36 +00:00
Object.keys(Tput.alias).forEach(function(key) {
var aliases = Tput.alias[key];
out[aliases.termcap] = key;
2013-02-27 22:57:11 +00:00
});
return out;
})();
2013-02-28 00:25:59 +00:00
// Translate termcap cap names to terminfo cap names.
// e.g. `up` -> `cursor_up`
2013-02-27 22:57:11 +00:00
['bools', 'numbers', 'strings'].forEach(function(key) {
out[key] = {};
Object.keys(info[key]).forEach(function(cap) {
if (key === 'strings') {
2013-07-23 05:22:49 +00:00
info.strings[cap] = self._captoinfo(cap, info.strings[cap], 1);
}
2013-08-30 02:55:36 +00:00
if (map[cap]) {
out[key][map[cap]] = info[key][cap];
2013-02-28 07:40:12 +00:00
} else {
// NOTE: Possibly include all termcap names
// in a separate alias.js file. Some are
// missing from the terminfo alias.js file
// which is why we have to do this:
// See: $ man termcap
out[key][cap] = info[key][cap];
2013-02-27 22:57:11 +00:00
}
});
});
return out;
};
Tput.prototype.compileTermcap = function(term) {
return this.compile(this.readTermcap(term));
};
Tput.prototype.injectTermcap = function(term) {
return this.inject(this.compileTermcap(term));
};
/**
* _nc_captoinfo - ported to javascript directly from ncurses.
* Copyright (c) 1998-2009,2010 Free Software Foundation, Inc.
* See: ~/ncurses/ncurses/tinfo/captoinfo.c
*
* Convert a termcap string to terminfo format.
* 'cap' is the relevant terminfo capability index.
* 's' is the string value of the capability.
* 'parameterized' tells what type of translations to do:
* % translations if 1
* pad translations if >=0
*/
2013-07-23 05:22:49 +00:00
Tput.prototype._captoinfo = function(cap, s, parameterized) {
var self = this;
var capstart;
if (parameterized == null) {
parameterized = 0;
2013-02-28 00:25:59 +00:00
}
var MAX_PUSHED = 16
, stack = [];
2013-02-28 00:25:59 +00:00
var stackptr = 0
, onstack = 0
, seenm = 0
, seenn = 0
, seenr = 0
, param = 1
, i = 0
, out = '';
function warn() {
2013-07-23 05:22:49 +00:00
var args = Array.prototype.slice.call(arguments);
args[0] = 'captoinfo: ' + (args[0] || '');
return self._debug.apply(self, args);
}
function isdigit(ch) {
return ch >= '0' && ch <= '9';
}
function isgraph(ch) {
return ch > ' ' && ch <= '~';
}
// convert a character to a terminfo push
function cvtchar(sp) {
var c = '\0'
, len;
var j = i;
switch (sp[j]) {
case '\\':
switch (sp[++j]) {
case '\'':
case '$':
case '\\':
case '%':
c = sp[j];
len = 2;
break;
case '\0':
c = '\\';
len = 1;
break;
case '0':
case '1':
case '2':
case '3':
len = 1;
while (isdigit(sp[j])) {
c = String.fromCharCode(8 * c.charCodeAt(0)
+ (sp[j++].charCodeAt(0) - '0'.charCodeAt(0)));
len++;
}
break;
default:
c = sp[j];
len = 2;
break;
}
break;
case '^':
c = String.fromCharCode(sp[++j].charCodeAt(0) & 0x1f);
len = 2;
break;
default:
c = sp[j];
len = 1;
}
if (isgraph(c) && c !== ',' && c !== '\'' && c !== '\\' && c !== ':') {
out += '%\'';
out += c;
out += '\'';
} else {
out += '%{';
if (c.charCodeAt(0) > 99) {
out += String.fromCharCode(
(c.charCodeAt(0) / 100 | 0) + '0'.charCodeAt(0));
}
if (c.charCodeAt(0) > 9) {
out += String.fromCharCode(
(c.charCodeAt(0) / 10 | 0) % 10 + '0'.charCodeAt(0));
}
out += String.fromCharCode(
c.charCodeAt(0) % 10 + '0'.charCodeAt(0));
out += '}';
}
return len;
}
// push n copies of param on the terminfo stack if not already there
function getparm(parm, n) {
if (seenr) {
if (parm === 1) {
parm = 2;
} else if (parm === 2) {
parm = 1;
}
}
if (onstack === parm) {
if (n > 1) {
warn('string may not be optimal');
out += '%Pa';
while (n--) {
out += '%ga';
}
}
return;
}
if (onstack !== 0) {
push();
}
onstack = parm;
while (n--) {
out += '%p';
out += String.fromCharCode('0'.charCodeAt(0) + parm);
}
if (seenn && parm < 3) {
out += '%{96}%^';
}
if (seenm && parm < 3) {
out += '%{127}%^';
}
}
// push onstack on to the stack
function push() {
if (stackptr >= MAX_PUSHED) {
warn('string too complex to convert');
} else {
stack[stackptr++] = onstack;
}
}
// pop the top of the stack into onstack
function pop() {
if (stackptr === 0) {
if (onstack === 0) {
warn('I\'m confused');
} else {
onstack = 0;
}
} else {
onstack = stack[--stackptr];
}
param++;
}
function see03() {
getparm(param, 1);
out += '%3d';
pop();
}
function invalid() {
out += '%';
i--;
warn('unknown %% code %s (%#x) in %s',
JSON.stringify(s[i]), s[i].charCodeAt(0), cap);
}
// skip the initial padding (if we haven't been told not to)
capstart = null;
if (s == null) s = '';
if (parameterized >= 0 && isdigit(s[i])) {
for (capstart = i;; i++) {
if (!(isdigit(s[i]) || s[i] === '*' || s[i] === '.')) {
break;
}
}
}
while (s[i]) {
switch (s[i]) {
case '%':
i++;
if (parameterized < 1) {
out += '%';
break;
}
switch (s[i++]) {
case '%':
out += '%';
break;
case 'r':
if (seenr++ === 1) {
warn('saw %%r twice in %s', cap);
}
break;
case 'm':
if (seenm++ === 1) {
warn('saw %%m twice in %s', cap);
}
break;
case 'n':
if (seenn++ === 1) {
warn('saw %%n twice in %s', cap);
}
break;
case 'i':
out += '%i';
break;
case '6':
case 'B':
getparm(param, 1);
out += '%{10}%/%{16}%*';
getparm(param, 1);
out += '%{10}%m%+';
break;
case '8':
case 'D':
getparm(param, 2);
out += '%{2}%*%-';
break;
case '>':
getparm(param, 2);
// %?%{x}%>%t%{y}%+%;
out += '%?';
i += cvtchar(s);
out += '%>%t';
i += cvtchar(s);
out += '%+%;';
break;
case 'a':
if ((s[i] === '=' || s[i] === '+' || s[i] === '-'
|| s[i] === '*' || s[i] === '/')
&& (s[i + 1] === 'p' || s[i + 1] === 'c')
2013-07-27 10:13:04 +00:00
&& s[i + 2] !== '\0' && s[i + 2]) {
var l;
l = 2;
if (s[i] !== '=') {
getparm(param, 1);
}
if (s[i + 1] === 'p') {
getparm(param + s[i + 2].charCodeAt(0) - '@'.charCodeAt(0), 1);
if (param !== onstack) {
pop();
param--;
}
l++;
} else {
i += 2, l += cvtchar(s), i -= 2;
}
switch (s[i]) {
case '+':
out += '%+';
break;
case '-':
out += '%-';
break;
case '*':
out += '%*';
break;
case '/':
out += '%/';
break;
case '=':
if (seenr) {
if (param === 1) {
onstack = 2;
} else if (param === 2) {
onstack = 1;
} else {
onstack = param;
}
} else {
onstack = param;
}
break;
}
i += l;
break;
}
getparm(param, 1);
i += cvtchar(s);
out += '%+';
break;
case '+':
getparm(param, 1);
i += cvtchar(s);
out += '%+%c';
pop();
break;
case 's':
// #ifdef WATERLOO
// i += cvtchar(s);
// getparm(param, 1);
// out += '%-';
// #else
getparm(param, 1);
out += '%s';
pop();
// #endif /* WATERLOO */
break;
case '-':
i += cvtchar(s);
getparm(param, 1);
out += '%-%c';
pop();
break;
case '.':
getparm(param, 1);
out += '%c';
pop();
break;
case '0': // not clear any of the historical termcaps did this
if (s[i] === '3') {
see03(); // goto
break;
} else if (s[i] !== '2') {
invalid(); // goto
break;
}
// FALLTHRU
case '2':
getparm(param, 1);
out += '%2d';
pop();
break;
case '3':
see03();
break;
case 'd':
getparm(param, 1);
out += '%d';
pop();
break;
case 'f':
param++;
break;
case 'b':
param--;
break;
case '\\':
out += '%\\';
break;
default:
invalid();
break;
}
break;
// #ifdef REVISIBILIZE
// case '\\':
// out += s[i++];
// out += s[i++];
// break;
// case '\n':
// out += '\\n';
// i++;
// break;
// case '\t':
// out += '\\t';
// i++;
// break;
// case '\r':
// out += '\\r';
// i++;
// break;
// case '\200':
// out += '\\0';
// i++;
// break;
// case '\f':
// out += '\\f';
// i++;
// break;
// case '\b':
// out += '\\b';
// i++;
// break;
// case ' ':
// out += '\\s';
// i++;
// break;
// case '^':
// out += '\\^';
// i++;
// break;
// case ':':
// out += '\\:';
// i++;
// break;
// case ',':
// out += '\\,';
// i++;
// break;
// default:
// if (s[i] === '\033') {
// out += '\\E';
// i++;
// } else if (s[i].charCodeAt(0) > 0 && s[i].charCodeAt(0) < 32) {
// out += '^';
// out += String.fromCharCode(s[i].charCodeAt(0) + '@'.charCodeAt(0));
// i++;
// } else if (s[i].charCodeAt(0) <= 0 || s[i].charCodeAt(0) >= 127) {
// out += '\\';
// out += String.fromCharCode(
// ((s[i].charCodeAt(0) & 0300) >> 6) + '0'.charCodeAt(0));
// out += String.fromCharCode(
// ((s[i].charCodeAt(0) & 0070) >> 3) + '0'.charCodeAt(0));
// out += String.fromCharCode(
// (s[i].charCodeAt(0) & 0007) + '0'.charCodeAt(0));
// i++;
// } else {
// out += s[i++];
// }
// break;
// #else
default:
out += s[i++];
break;
// #endif
}
}
// Now, if we stripped off some leading padding, add it at the end
// of the string as mandatory padding.
if (capstart != null) {
out += '$<';
for (i = capstart;; i++) {
if (isdigit(s[i]) || s[i] === '*' || s[i] === '.') {
out += s[i];
} else {
break;
}
}
out += '/>';
}
if (s !== out) {
warn('Translating %s from %s to %s.',
cap, JSON.stringify(s), JSON.stringify(out));
}
return out;
2013-07-23 05:22:49 +00:00
};
2013-02-27 22:57:11 +00:00
2013-07-14 08:14:48 +00:00
/**
* Compile All Terminfo
2013-07-14 08:14:48 +00:00
*/
2013-07-23 05:22:49 +00:00
Tput.prototype.getAll = function() {
var dir = this._prefix()
, list = asort(fs.readdirSync(dir))
, infos = [];
list.forEach(function(letter) {
var terms = asort(fs.readdirSync(path.resolve(dir, letter)));
infos.push.apply(infos, terms);
});
function asort(obj) {
return obj.sort(function(a, b) {
a = a.toLowerCase().charCodeAt(0);
b = b.toLowerCase().charCodeAt(0);
return a - b;
});
}
2013-07-23 05:22:49 +00:00
return infos;
};
2013-07-23 05:22:49 +00:00
Tput.prototype.compileAll = function(start) {
var self = this
, all = {};
this.getAll().forEach(function(name) {
if (start && name !== start) {
return;
} else {
start = null;
}
all[name] = self.compileTerminfo(name);
});
return all;
};
2013-07-14 08:14:48 +00:00
/**
* Detect Features / Quirks
*/
2013-07-14 08:14:48 +00:00
Tput.prototype.detectFeatures = function(info) {
var data = this.parseACS(info);
info.features = {
unicode: this.detectUnicode(info),
brokenACS: this.detectBrokenACS(info),
PCRomSet: this.detectPCRomSet(info),
magicCookie: this.detectMagicCookie(info),
padding: this.detectPadding(info),
setbuf: this.detectSetbuf(info),
acsc: data.acsc,
acscr: data.acscr
};
return info.features;
2013-07-14 08:14:48 +00:00
};
Tput.prototype.detectUnicode = function() {
var LANG = process.env.LANG
+ ':' + process.env.LANGUAGE
+ ':' + process.env.LC_ALL
+ ':' + process.env.LC_CTYPE;
return /utf-?8/i.test(LANG);
};
// For some reason TERM=linux has smacs/rmacs, but it maps to `^[[11m`
// and it does not switch to the DEC SCLD character set. What the hell?
// xterm: \x1b(0, screen: \x0e, linux: \x1b[11m (doesn't work)
// `man console_codes` says:
// 11 select null mapping, set display control flag, reset tog
// gle meta flag (ECMA-48 says "first alternate font").
// See ncurses:
// ~/ncurses/ncurses/base/lib_set_term.c
2013-07-14 08:14:48 +00:00
// ~/ncurses/ncurses/tinfo/lib_acs.c
// ~/ncurses/ncurses/tinfo/tinfo_driver.c
// ~/ncurses/ncurses/tinfo/lib_setup.c
Tput.prototype.detectBrokenACS = function(info) {
2013-07-14 08:14:48 +00:00
// ncurses-compatible env variable.
if (process.env.NCURSES_NO_UTF8_ACS != null) {
return true;
}
// If the terminal supports unicode, we don't need ACS.
if (info.numbers['U8'] >= 0) {
return !!info.numbers['U8'];
2013-07-14 08:14:48 +00:00
}
// The linux console is just broken for some reason.
// Apparently the Linux console does not support ACS,
// but it does support the PC ROM character set.
if (info.name === 'linux') {
2013-07-14 08:14:48 +00:00
return true;
}
// PC alternate charset
// if (acsc.indexOf('+\x10,\x11-\x18.\x190') === 0) {
if (this.detectPCRomSet(info)) {
return true;
}
2013-07-14 08:14:48 +00:00
// screen termcap is bugged?
if (info.name.indexOf('screen') == 0
2013-07-14 08:14:48 +00:00
&& process.env.TERMCAP
&& ~process.env.TERMCAP.indexOf('screen')
&& ~process.env.TERMCAP.indexOf('hhII00')) {
if (~info.strings.enter_alt_charset_mode.indexOf('\016')
|| ~info.strings.enter_alt_charset_mode.indexOf('\017')
|| ~info.strings.set_attributes.indexOf('\016')
|| ~info.strings.set_attributes.indexOf('\017')) {
2013-07-14 08:14:48 +00:00
return true;
}
}
return false;
};
// If enter_pc_charset is the same as enter_alt_charset,
// the terminal does not support SCLD as ACS.
2013-07-14 08:14:48 +00:00
// See: ~/ncurses/ncurses/tinfo/lib_acs.c
Tput.prototype.detectPCRomSet = function(info) {
var s = info.strings;
if (s.enter_pc_charset_mode && s.enter_alt_charset_mode
&& s.enter_pc_charset_mode === s.enter_alt_charset_mode
&& s.exit_pc_charset_mode === s.exit_alt_charset_mode) {
2013-07-14 08:14:48 +00:00
return true;
}
return false;
};
Tput.prototype.detectMagicCookie = function(info) {
2013-07-14 08:14:48 +00:00
return process.env.NCURSES_NO_MAGIC_COOKIE == null;
};
Tput.prototype.detectPadding = function(info) {
2013-07-14 08:14:48 +00:00
return process.env.NCURSES_NO_PADDING == null;
};
Tput.prototype.detectSetbuf = function(info) {
2013-07-14 08:14:48 +00:00
return process.env.NCURSES_NO_SETBUF == null;
};
Tput.prototype.parseACS = function(info) {
var data = {};
2013-07-14 08:14:48 +00:00
data.acsc = {};
data.acscr = {};
2013-07-14 08:14:48 +00:00
// Possibly just return an empty object, as done here, instead of
// specifically saying ACS is "broken" above. This would be more
// accurate to ncurses logic. But it doesn't really matter.
if (this.detectPCRomSet(info)) {
return data;
2013-07-14 08:14:48 +00:00
}
// See: ~/ncurses/ncurses/tinfo/lib_acs.c: L208
Object.keys(Tput.acsc).forEach(function(ch) {
var acs_chars = info.strings.acs_chars || ''
2013-07-14 08:14:48 +00:00
, i = acs_chars.indexOf(ch)
, next = acs_chars[i + 1];
if (!next || i === -1 || !Tput.acsc[next]) {
2013-07-14 08:14:48 +00:00
return;
}
data.acsc[ch] = Tput.acsc[next];
data.acscr[Tput.acsc[next]] = ch;
2013-07-14 08:14:48 +00:00
});
return data;
2013-07-14 08:14:48 +00:00
};
2013-02-22 11:20:50 +00:00
/**
* Helpers
*/
function noop() {
return '';
}
noop.unsupported = true;
2013-02-24 16:59:20 +00:00
function merge(a, b) {
Object.keys(b).forEach(function(key) {
a[key] = b[key];
});
return a;
}
2013-02-24 18:58:29 +00:00
function write(data) {
return process.stdout.write(data);
}
function tryRead(file) {
if (Array.isArray(file)) {
for (var i = 0; i < file.length; i++) {
var data = tryRead(file[i]);
if (data) return data;
}
return '';
}
if (!file) return '';
file = path.resolve.apply(path, arguments);
2013-02-27 23:17:26 +00:00
try {
return fs.readFileSync(file, 'utf8');
} catch (e) {
return '';
}
}
2013-02-24 17:51:14 +00:00
/**
* sprintf
* http://www.cplusplus.com/reference/cstdio/printf/
*/
function sprintf(src) {
var params = Array.prototype.slice.call(arguments, 1)
, rule = /%([\-+# ]{1,4})?(\d+(?:\.\d+)?)?([doxXsc])/g
, i = 0;
return src.replace(rule, function(_, flag, width, type) {
2013-02-25 12:07:15 +00:00
var flags = (flag || '').split('')
2013-07-23 05:22:49 +00:00
, param = params[i] != null ? params[i] : ''
2013-02-24 17:51:14 +00:00
, initial = param
, width = +width
, opt = {}
, pre = '';
2013-07-23 05:22:49 +00:00
i++;
2013-02-24 17:51:14 +00:00
switch (type) {
case 'd': // signed int
param = (+param).toString(10);
break;
case 'o': // unsigned octal
param = (+param).toString(8);
break;
case 'x': // unsigned hex int
param = (+param).toString(16);
break;
case 'X': // unsigned hex int uppercase
param = (+param).toString(16).toUppercase();
break;
case 's': // string
break;
case 'c': // char
param = isFinite(param)
2013-07-23 05:22:49 +00:00
? String.fromCharCode(param || 0200)
: '';
2013-02-24 17:51:14 +00:00
break;
}
flags.forEach(function(flag) {
switch (flag) {
// left-justify by width
case '-':
opt.left = true;
break;
// always precede numbers with their signs
case '+':
opt.signs = true;
break;
// used with o, x, X - value is preceded with 0, 0x, or 0X respectively.
// used with a, A, e, E, f, F, g, G - forces written output to contain
// a decimal point even if no more digits follow
case '#':
opt.hexpoint = true;
break;
// if no sign is going to be written, black space in front of the value
case ' ':
opt.space = true;
break;
}
});
if (opt.signs) {
if (+initial >= 0) {
pre += '+';
}
}
if (opt.space) {
if (!opt.signs && +initial >= 0) {
2013-02-25 12:06:34 +00:00
pre += ' ';
2013-02-24 17:51:14 +00:00
}
}
if (opt.hexpoint) {
switch (type) {
case 'o': // unsigned octal
pre += '0';
break;
case 'x': // unsigned hex int
pre += '0x';
break;
case 'X': // unsigned hex int uppercase
pre += '0X';
break;
}
}
if (opt.left) {
if (width > (pre.length + param.length)) {
width -= pre.length + param.length;
pre = Array(width + 1).join(' ') + pre;
}
}
return pre + param;
});
}
2013-02-22 11:20:50 +00:00
/**
2013-02-24 16:59:20 +00:00
* Aliases
2013-02-22 11:20:50 +00:00
*/
2013-08-30 02:55:36 +00:00
Tput._alias = require('./alias');
2013-02-24 16:59:20 +00:00
2013-08-30 02:55:36 +00:00
Tput.alias = {};
2013-08-30 02:55:36 +00:00
['bools', 'numbers', 'strings'].forEach(function(type) {
Object.keys(Tput._alias[type]).forEach(function(key) {
var aliases = Tput._alias[type][key];
Tput.alias[key] = [aliases[0]];
Tput.alias[key].terminfo = aliases[0];
Tput.alias[key].termcap = aliases[1];
});
});
2013-08-30 02:55:36 +00:00
// Bools
Tput.alias.no_esc_ctlc.push('beehive_glitch');
Tput.alias.dest_tabs_magic_smso.push('teleray_glitch');
2013-02-25 08:09:17 +00:00
2013-08-30 02:55:36 +00:00
// Numbers
Tput.alias.micro_col_size.push('micro_char_size');
2013-02-28 07:33:04 +00:00
2013-07-14 13:37:57 +00:00
/**
* Feature Checking
*/
Tput.aliasMap = {};
Object.keys(Tput.alias).forEach(function(key) {
Tput.aliasMap[key] = key;
2013-08-30 02:55:36 +00:00
Tput.alias[key].forEach(function(k) {
2013-07-14 13:37:57 +00:00
Tput.aliasMap[k] = key;
});
});
Tput.prototype.has = function(name) {
var name = Tput.aliasMap[name]
, val = this.all[name];
if (!name) return false;
if (typeof val === 'number') {
return val !== -1;
}
return !!val;
};
2013-02-27 22:57:11 +00:00
/**
2013-02-28 00:25:59 +00:00
* Fallback Termcap Entry
2013-02-27 22:57:11 +00:00
*/
2013-02-28 00:34:41 +00:00
Tput.termcap = ''
2013-07-18 19:52:56 +00:00
+ 'vt102|dec vt102:'
+ ':do=^J:co#80:li#24:cl=50\\E[;H\\E[2J:'
+ ':le=^H:bs:cm=5\\E[%i%d;%dH:nd=2\\E[C:up=2\\E[A:'
+ ':ce=3\\E[K:cd=50\\E[J:so=2\\E[7m:se=2\\E[m:us=2\\E[4m:ue=2\\E[m:'
+ ':md=2\\E[1m:mr=2\\E[7m:mb=2\\E[5m:me=2\\E[m:is=\\E[1;24r\\E[24;1H:'
+ ':rs=\\E>\\E[?3l\\E[?4l\\E[?5l\\E[?7h\\E[?8h:ks=\\E[?1h\\E=:ke=\\E[?1l\\E>:'
+ ':ku=\\EOA:kd=\\EOB:kr=\\EOC:kl=\\EOD:kb=^H:\\\n'
+ ':ho=\\E[H:k1=\\EOP:k2=\\EOQ:k3=\\EOR:k4=\\EOS:pt:sr=5\\EM:vt#3:'
+ ':sc=\\E7:rc=\\E8:cs=\\E[%i%d;%dr:vs=\\E[?7l:ve=\\E[?7h:'
+ ':mi:al=\\E[L:dc=\\E[P:dl=\\E[M:ei=\\E[4l:im=\\E[4h:';
2013-02-27 22:57:11 +00:00
2013-02-24 16:59:20 +00:00
/**
* Terminfo Data
*/
2013-02-22 11:20:50 +00:00
2013-02-08 13:43:45 +00:00
Tput.bools = [
'auto_left_margin',
'auto_right_margin',
'no_esc_ctlc',
'ceol_standout_glitch',
'eat_newline_glitch',
'erase_overstrike',
'generic_type',
'hard_copy',
'has_meta_key',
'has_status_line',
'insert_null_glitch',
'memory_above',
'memory_below',
'move_insert_mode',
'move_standout_mode',
'over_strike',
'status_line_esc_ok',
'dest_tabs_magic_smso',
'tilde_glitch',
'transparent_underline',
'xon_xoff',
'needs_xon_xoff',
'prtr_silent',
'hard_cursor',
'non_rev_rmcup',
'no_pad_char',
'non_dest_scroll_region',
'can_change',
'back_color_erase',
'hue_lightness_saturation',
'col_addr_glitch',
'cr_cancels_micro_mode',
'has_print_wheel',
'row_addr_glitch',
'semi_auto_right_margin',
'cpi_changes_res',
'lpi_changes_res',
// #ifdef __INTERNAL_CAPS_VISIBLE
'backspaces_with_bs',
'crt_no_scrolling',
'no_correctly_working_cr',
'gnu_has_meta_key',
'linefeed_is_newline',
'has_hardware_tabs',
'return_does_clr_eol'
];
Tput.numbers = [
'columns',
'init_tabs',
'lines',
'lines_of_memory',
'magic_cookie_glitch',
'padding_baud_rate',
'virtual_terminal',
'width_status_line',
'num_labels',
'label_height',
'label_width',
'max_attributes',
'maximum_windows',
'max_colors',
'max_pairs',
'no_color_video',
'buffer_capacity',
'dot_vert_spacing',
'dot_horz_spacing',
'max_micro_address',
'max_micro_jump',
'micro_col_size',
'micro_line_size',
'number_of_pins',
'output_res_char',
'output_res_line',
'output_res_horz_inch',
'output_res_vert_inch',
'print_rate',
'wide_char_size',
'buttons',
'bit_image_entwining',
'bit_image_type',
// #ifdef __INTERNAL_CAPS_VISIBLE
'magic_cookie_glitch_ul',
'carriage_return_delay',
'new_line_delay',
'backspace_delay',
'horizontal_tab_delay',
'number_of_function_keys'
];
Tput.strings = [
'back_tab',
'bell',
'carriage_return',
'change_scroll_region',
'clear_all_tabs',
'clear_screen',
'clr_eol',
'clr_eos',
'column_address',
'command_character',
'cursor_address',
'cursor_down',
'cursor_home',
'cursor_invisible',
'cursor_left',
'cursor_mem_address',
'cursor_normal',
'cursor_right',
'cursor_to_ll',
'cursor_up',
'cursor_visible',
'delete_character',
'delete_line',
'dis_status_line',
'down_half_line',
'enter_alt_charset_mode',
'enter_blink_mode',
'enter_bold_mode',
'enter_ca_mode',
'enter_delete_mode',
'enter_dim_mode',
'enter_insert_mode',
'enter_secure_mode',
'enter_protected_mode',
'enter_reverse_mode',
'enter_standout_mode',
'enter_underline_mode',
'erase_chars',
'exit_alt_charset_mode',
'exit_attribute_mode',
'exit_ca_mode',
'exit_delete_mode',
'exit_insert_mode',
'exit_standout_mode',
'exit_underline_mode',
'flash_screen',
'form_feed',
'from_status_line',
'init_1string',
'init_2string',
'init_3string',
'init_file',
'insert_character',
'insert_line',
'insert_padding',
'key_backspace',
'key_catab',
'key_clear',
'key_ctab',
'key_dc',
'key_dl',
'key_down',
'key_eic',
'key_eol',
'key_eos',
'key_f0',
'key_f1',
'key_f10',
'key_f2',
'key_f3',
'key_f4',
'key_f5',
'key_f6',
'key_f7',
'key_f8',
'key_f9',
'key_home',
'key_ic',
'key_il',
'key_left',
'key_ll',
'key_npage',
'key_ppage',
'key_right',
'key_sf',
'key_sr',
'key_stab',
'key_up',
'keypad_local',
'keypad_xmit',
'lab_f0',
'lab_f1',
'lab_f10',
'lab_f2',
'lab_f3',
'lab_f4',
'lab_f5',
'lab_f6',
'lab_f7',
'lab_f8',
'lab_f9',
'meta_off',
'meta_on',
'newline',
'pad_char',
'parm_dch',
'parm_delete_line',
'parm_down_cursor',
'parm_ich',
'parm_index',
'parm_insert_line',
'parm_left_cursor',
'parm_right_cursor',
'parm_rindex',
'parm_up_cursor',
'pkey_key',
'pkey_local',
'pkey_xmit',
'print_screen',
'prtr_off',
'prtr_on',
'repeat_char',
'reset_1string',
'reset_2string',
'reset_3string',
'reset_file',
'restore_cursor',
'row_address',
'save_cursor',
'scroll_forward',
'scroll_reverse',
'set_attributes',
'set_tab',
'set_window',
'tab',
'to_status_line',
'underline_char',
'up_half_line',
'init_prog',
'key_a1',
'key_a3',
'key_b2',
'key_c1',
'key_c3',
'prtr_non',
'char_padding',
'acs_chars',
'plab_norm',
'key_btab',
'enter_xon_mode',
'exit_xon_mode',
'enter_am_mode',
'exit_am_mode',
'xon_character',
'xoff_character',
'ena_acs',
'label_on',
'label_off',
'key_beg',
'key_cancel',
'key_close',
'key_command',
'key_copy',
'key_create',
'key_end',
'key_enter',
'key_exit',
'key_find',
'key_help',
'key_mark',
'key_message',
'key_move',
'key_next',
'key_open',
'key_options',
'key_previous',
'key_print',
'key_redo',
'key_reference',
'key_refresh',
'key_replace',
'key_restart',
'key_resume',
'key_save',
'key_suspend',
'key_undo',
'key_sbeg',
'key_scancel',
'key_scommand',
'key_scopy',
'key_screate',
'key_sdc',
'key_sdl',
'key_select',
'key_send',
'key_seol',
'key_sexit',
'key_sfind',
'key_shelp',
'key_shome',
'key_sic',
'key_sleft',
'key_smessage',
'key_smove',
'key_snext',
'key_soptions',
'key_sprevious',
'key_sprint',
'key_sredo',
'key_sreplace',
'key_sright',
'key_srsume',
'key_ssave',
'key_ssuspend',
'key_sundo',
'req_for_input',
'key_f11',
'key_f12',
'key_f13',
'key_f14',
'key_f15',
'key_f16',
'key_f17',
'key_f18',
'key_f19',
'key_f20',
'key_f21',
'key_f22',
'key_f23',
'key_f24',
'key_f25',
'key_f26',
'key_f27',
'key_f28',
'key_f29',
'key_f30',
'key_f31',
'key_f32',
'key_f33',
'key_f34',
'key_f35',
'key_f36',
'key_f37',
'key_f38',
'key_f39',
'key_f40',
'key_f41',
'key_f42',
'key_f43',
'key_f44',
'key_f45',
'key_f46',
'key_f47',
'key_f48',
'key_f49',
'key_f50',
'key_f51',
'key_f52',
'key_f53',
'key_f54',
'key_f55',
'key_f56',
'key_f57',
'key_f58',
'key_f59',
'key_f60',
'key_f61',
'key_f62',
'key_f63',
'clr_bol',
'clear_margins',
'set_left_margin',
'set_right_margin',
'label_format',
'set_clock',
'display_clock',
'remove_clock',
'create_window',
'goto_window',
'hangup',
'dial_phone',
'quick_dial',
'tone',
'pulse',
'flash_hook',
'fixed_pause',
'wait_tone',
'user0',
'user1',
'user2',
'user3',
'user4',
'user5',
'user6',
'user7',
'user8',
'user9',
'orig_pair',
'orig_colors',
'initialize_color',
'initialize_pair',
'set_color_pair',
'set_foreground',
'set_background',
'change_char_pitch',
'change_line_pitch',
'change_res_horz',
'change_res_vert',
'define_char',
'enter_doublewide_mode',
'enter_draft_quality',
'enter_italics_mode',
'enter_leftward_mode',
'enter_micro_mode',
'enter_near_letter_quality',
'enter_normal_quality',
'enter_shadow_mode',
'enter_subscript_mode',
'enter_superscript_mode',
'enter_upward_mode',
'exit_doublewide_mode',
'exit_italics_mode',
'exit_leftward_mode',
'exit_micro_mode',
'exit_shadow_mode',
'exit_subscript_mode',
'exit_superscript_mode',
'exit_upward_mode',
'micro_column_address',
'micro_down',
'micro_left',
'micro_right',
'micro_row_address',
'micro_up',
'order_of_pins',
'parm_down_micro',
'parm_left_micro',
'parm_right_micro',
'parm_up_micro',
'select_char_set',
'set_bottom_margin',
'set_bottom_margin_parm',
'set_left_margin_parm',
'set_right_margin_parm',
'set_top_margin',
'set_top_margin_parm',
'start_bit_image',
'start_char_set_def',
'stop_bit_image',
'stop_char_set_def',
'subscript_characters',
'superscript_characters',
'these_cause_cr',
'zero_motion',
'char_set_names',
'key_mouse',
'mouse_info',
'req_mouse_pos',
'get_mouse',
'set_a_foreground',
'set_a_background',
'pkey_plab',
'device_type',
'code_set_init',
'set0_des_seq',
'set1_des_seq',
'set2_des_seq',
'set3_des_seq',
'set_lr_margin',
'set_tb_margin',
'bit_image_repeat',
'bit_image_newline',
'bit_image_carriage_return',
'color_names',
'define_bit_image_region',
'end_bit_image_region',
'set_color_band',
'set_page_length',
'display_pc_char',
'enter_pc_charset_mode',
'exit_pc_charset_mode',
'enter_scancode_mode',
'exit_scancode_mode',
'pc_term_options',
'scancode_escape',
'alt_scancode_esc',
'enter_horizontal_hl_mode',
'enter_left_hl_mode',
'enter_low_hl_mode',
'enter_right_hl_mode',
'enter_top_hl_mode',
'enter_vertical_hl_mode',
'set_a_attributes',
'set_pglen_inch',
// #ifdef __INTERNAL_CAPS_VISIBLE
'termcap_init2',
'termcap_reset',
'linefeed_if_not_lf',
'backspace_if_not_bs',
'other_non_function_keys',
'arrow_key_map',
'acs_ulcorner',
'acs_llcorner',
'acs_urcorner',
'acs_lrcorner',
'acs_ltee',
'acs_rtee',
'acs_btee',
'acs_ttee',
'acs_hline',
'acs_vline',
'acs_plus',
'memory_lock',
'memory_unlock',
'box_chars_1'
];
2013-07-14 08:14:48 +00:00
// DEC Special Character and Line Drawing Set.
// Taken from tty.js.
2013-07-14 15:06:28 +00:00
Tput.acsc = { // (0
2013-07-14 08:14:48 +00:00
'`': '\u25c6', // '◆'
'a': '\u2592', // '▒'
'b': '\u0009', // '\t'
'c': '\u000c', // '\f'
'd': '\u000d', // '\r'
'e': '\u000a', // '\n'
'f': '\u00b0', // '°'
'g': '\u00b1', // '±'
'h': '\u2424', // '\u2424' (NL)
'i': '\u000b', // '\v'
'j': '\u2518', // '┘'
'k': '\u2510', // '┐'
'l': '\u250c', // '┌'
'm': '\u2514', // '└'
'n': '\u253c', // '┼'
'o': '\u23ba', // '⎺'
'p': '\u23bb', // '⎻'
'q': '\u2500', // '─'
'r': '\u23bc', // '⎼'
's': '\u23bd', // '⎽'
't': '\u251c', // '├'
'u': '\u2524', // '┤'
'v': '\u2534', // '┴'
'w': '\u252c', // '┬'
'x': '\u2502', // '│'
'y': '\u2264', // '≤'
'z': '\u2265', // '≥'
'{': '\u03c0', // 'π'
'|': '\u2260', // '≠'
'}': '\u00a3', // '£'
'~': '\u00b7' // '·'
};
// Convert ACS unicode characters to the
// most similar-looking ascii characters.
Tput.utoa = Tput.prototype.utoa = {
'\u25c6': '*', // '◆'
'\u2592': ' ', // '▒'
// '\u0009': '\t', // '\t'
// '\u000c': '\f', // '\f'
// '\u000d': '\r', // '\r'
// '\u000a': '\n', // '\n'
'\u00b0': '*', // '°'
'\u00b1': '+', // '±'
'\u2424': '\n', // '\u2424' (NL)
// '\u000b': '\v', // '\v'
'\u2518': '+', // '┘'
'\u2510': '+', // '┐'
'\u250c': '+', // '┌'
'\u2514': '+', // '└'
'\u253c': '+', // '┼'
'\u23ba': '-', // '⎺'
'\u23bb': '-', // '⎻'
'\u2500': '-', // '─'
'\u23bc': '-', // '⎼'
'\u23bd': '_', // '⎽'
'\u251c': '+', // '├'
'\u2524': '+', // '┤'
'\u2534': '+', // '┴'
'\u252c': '+', // '┬'
'\u2502': '|', // '│'
'\u2264': '<', // '≤'
'\u2265': '>', // '≥'
'\u03c0': '?', // 'π'
'\u2260': '=', // '≠'
'\u00a3': '?', // '£'
'\u00b7': '*' // '·'
};
2013-02-19 19:21:28 +00:00
/**
* Expose
*/
2013-02-24 17:51:14 +00:00
exports = Tput;
exports.sprintf = sprintf;
2013-07-24 19:40:05 +00:00
exports.merge = merge;
exports.tryRead = tryRead;
2013-02-24 17:51:14 +00:00
module.exports = exports;