238 lines
6.8 KiB
Plaintext
238 lines
6.8 KiB
Plaintext
|
const defaultQuotedOptions = {
|
|||
|
|
escape: 92,
|
|||
|
|
throws: false
|
|||
|
|
};
|
|||
|
|
/**
|
|||
|
|
* Check if given code is a number
|
|||
|
|
*/
|
|||
|
|
function isNumber(code) {
|
|||
|
|
return code > 47 && code < 58;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character code is alpha code (letter through A to Z)
|
|||
|
|
*/
|
|||
|
|
function isAlpha(code, from, to) {
|
|||
|
|
from = from || 65; // A
|
|||
|
|
to = to || 90; // Z
|
|||
|
|
code &= ~32; // quick hack to convert any char code to uppercase char code
|
|||
|
|
return code >= from && code <= to;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character code is alpha-numeric (letter through A to Z or number)
|
|||
|
|
*/
|
|||
|
|
function isAlphaNumeric(code) {
|
|||
|
|
return isNumber(code) || isAlpha(code);
|
|||
|
|
}
|
|||
|
|
function isAlphaNumericWord(code) {
|
|||
|
|
return isNumber(code) || isAlphaWord(code);
|
|||
|
|
}
|
|||
|
|
function isAlphaWord(code) {
|
|||
|
|
return code === 95 /* _ */ || isAlpha(code);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check for Umlauts i.e. ä, Ä, ö, Ö, ü and Ü
|
|||
|
|
*/
|
|||
|
|
function isUmlaut(code) {
|
|||
|
|
return code === 196
|
|||
|
|
|| code == 214
|
|||
|
|
|| code === 220
|
|||
|
|
|| code === 228
|
|||
|
|
|| code === 246
|
|||
|
|
|| code === 252;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character code is a white-space character: a space character
|
|||
|
|
* or line breaks
|
|||
|
|
*/
|
|||
|
|
function isWhiteSpace(code) {
|
|||
|
|
return code === 32 /* space */
|
|||
|
|
|| code === 9 /* tab */
|
|||
|
|
|| code === 160; /* non-breaking space */
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character code is a space character
|
|||
|
|
*/
|
|||
|
|
function isSpace(code) {
|
|||
|
|
return isWhiteSpace(code)
|
|||
|
|
|| code === 10 /* LF */
|
|||
|
|
|| code === 13; /* CR */
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Consumes 'single' or "double"-quoted string from given string, if possible
|
|||
|
|
* @return `true` if quoted string was consumed. The contents of quoted string
|
|||
|
|
* will be available as `stream.current()`
|
|||
|
|
*/
|
|||
|
|
function eatQuoted(stream, options) {
|
|||
|
|
options = Object.assign(Object.assign({}, defaultQuotedOptions), options);
|
|||
|
|
const start = stream.pos;
|
|||
|
|
const quote = stream.peek();
|
|||
|
|
if (stream.eat(isQuote)) {
|
|||
|
|
while (!stream.eof()) {
|
|||
|
|
switch (stream.next()) {
|
|||
|
|
case quote:
|
|||
|
|
stream.start = start;
|
|||
|
|
return true;
|
|||
|
|
case options.escape:
|
|||
|
|
stream.next();
|
|||
|
|
break;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// If we’re here then stream wasn’t properly consumed.
|
|||
|
|
// Revert stream and decide what to do
|
|||
|
|
stream.pos = start;
|
|||
|
|
if (options.throws) {
|
|||
|
|
throw stream.error('Unable to consume quoted string');
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Check if given character code is a quote character
|
|||
|
|
*/
|
|||
|
|
function isQuote(code) {
|
|||
|
|
return code === 39 /* ' */ || code === 34 /* " */;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Eats paired characters substring, for example `(foo)` or `[bar]`
|
|||
|
|
* @param open Character code of pair opening
|
|||
|
|
* @param close Character code of pair closing
|
|||
|
|
* @return Returns `true` if character pair was successfully consumed, it’s
|
|||
|
|
* content will be available as `stream.current()`
|
|||
|
|
*/
|
|||
|
|
function eatPair(stream, open, close, options) {
|
|||
|
|
options = Object.assign(Object.assign({}, defaultQuotedOptions), options);
|
|||
|
|
const start = stream.pos;
|
|||
|
|
if (stream.eat(open)) {
|
|||
|
|
let stack = 1;
|
|||
|
|
let ch;
|
|||
|
|
while (!stream.eof()) {
|
|||
|
|
if (eatQuoted(stream, options)) {
|
|||
|
|
continue;
|
|||
|
|
}
|
|||
|
|
ch = stream.next();
|
|||
|
|
if (ch === open) {
|
|||
|
|
stack++;
|
|||
|
|
}
|
|||
|
|
else if (ch === close) {
|
|||
|
|
stack--;
|
|||
|
|
if (!stack) {
|
|||
|
|
stream.start = start;
|
|||
|
|
return true;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
else if (ch === options.escape) {
|
|||
|
|
stream.next();
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
// If we’re here then paired character can’t be consumed
|
|||
|
|
stream.pos = start;
|
|||
|
|
if (options.throws) {
|
|||
|
|
throw stream.error(`Unable to find matching pair for ${String.fromCharCode(open)}`);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
return false;
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
/**
|
|||
|
|
* A streaming, character code-based string reader
|
|||
|
|
*/
|
|||
|
|
class Scanner {
|
|||
|
|
constructor(str, start, end) {
|
|||
|
|
if (end == null && typeof str === 'string') {
|
|||
|
|
end = str.length;
|
|||
|
|
}
|
|||
|
|
this.string = str;
|
|||
|
|
this.pos = this.start = start || 0;
|
|||
|
|
this.end = end || 0;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Returns true only if the stream is at the end of the file.
|
|||
|
|
*/
|
|||
|
|
eof() {
|
|||
|
|
return this.pos >= this.end;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Creates a new stream instance which is limited to given `start` and `end`
|
|||
|
|
* range. E.g. its `eof()` method will look at `end` property, not actual
|
|||
|
|
* stream end
|
|||
|
|
*/
|
|||
|
|
limit(start, end) {
|
|||
|
|
return new Scanner(this.string, start, end);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Returns the next character code in the stream without advancing it.
|
|||
|
|
* Will return NaN at the end of the file.
|
|||
|
|
*/
|
|||
|
|
peek() {
|
|||
|
|
return this.string.charCodeAt(this.pos);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Returns the next character in the stream and advances it.
|
|||
|
|
* Also returns <code>undefined</code> when no more characters are available.
|
|||
|
|
*/
|
|||
|
|
next() {
|
|||
|
|
if (this.pos < this.string.length) {
|
|||
|
|
return this.string.charCodeAt(this.pos++);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* `match` can be a character code or a function that takes a character code
|
|||
|
|
* and returns a boolean. If the next character in the stream 'matches'
|
|||
|
|
* the given argument, it is consumed and returned.
|
|||
|
|
* Otherwise, `false` is returned.
|
|||
|
|
*/
|
|||
|
|
eat(match) {
|
|||
|
|
const ch = this.peek();
|
|||
|
|
const ok = typeof match === 'function' ? match(ch) : ch === match;
|
|||
|
|
if (ok) {
|
|||
|
|
this.next();
|
|||
|
|
}
|
|||
|
|
return ok;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Repeatedly calls <code>eat</code> with the given argument, until it
|
|||
|
|
* fails. Returns <code>true</code> if any characters were eaten.
|
|||
|
|
*/
|
|||
|
|
eatWhile(match) {
|
|||
|
|
const start = this.pos;
|
|||
|
|
while (!this.eof() && this.eat(match)) { /* */ }
|
|||
|
|
return this.pos !== start;
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Backs up the stream n characters. Backing it up further than the
|
|||
|
|
* start of the current token will cause things to break, so be careful.
|
|||
|
|
*/
|
|||
|
|
backUp(n) {
|
|||
|
|
this.pos -= (n || 1);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Get the string between the start of the current token and the
|
|||
|
|
* current stream position.
|
|||
|
|
*/
|
|||
|
|
current() {
|
|||
|
|
return this.substring(this.start, this.pos);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Returns substring for given range
|
|||
|
|
*/
|
|||
|
|
substring(start, end) {
|
|||
|
|
return this.string.slice(start, end);
|
|||
|
|
}
|
|||
|
|
/**
|
|||
|
|
* Creates error object with current stream state
|
|||
|
|
*/
|
|||
|
|
error(message, pos = this.pos) {
|
|||
|
|
return new ScannerError(`${message} at ${pos + 1}`, pos, this.string);
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
class ScannerError extends Error {
|
|||
|
|
constructor(message, pos, str) {
|
|||
|
|
super(message);
|
|||
|
|
this.pos = pos;
|
|||
|
|
this.string = str;
|
|||
|
|
}
|
|||
|
|
}
|
|||
|
|
|
|||
|
|
export { ScannerError, Scanner as default, eatPair, eatQuoted, isAlpha, isAlphaNumeric, isAlphaNumericWord, isAlphaWord, isNumber, isQuote, isSpace, isUmlaut, isWhiteSpace };
|
|||
|
|
//# sourceMappingURL=scanner.js.map
|