Update code format and style
This is related to my last commit. I've updated all the JavaScript files to satisfy 'eslint-config-futagozaryuu', my eslint configuration. I'm sure I've probally missed something, but I've run all NPM scripts and Gulp tasks, fixed any bugs that cropped up, and updated some stuff (mainly related to generated messages), so as far as I can, tell this conversion is over (I know I've probally jixed it just by saying this ;P).master
Futago-za Ryuu
7 years ago
parent
3c6523ff83
commit
e6d018a88d
@ -1,89 +1,96 @@
|
||||
"use strict";
|
||||
|
||||
let babelify = require("babelify");
|
||||
let browserify = require("browserify");
|
||||
let buffer = require("vinyl-buffer");
|
||||
let del = require("del");
|
||||
let eslint = require("gulp-eslint");
|
||||
let gulp = require("gulp");
|
||||
let header = require("gulp-header");
|
||||
let mocha = require("gulp-mocha");
|
||||
let rename = require("gulp-rename");
|
||||
let runSequence = require("run-sequence");
|
||||
let source = require("vinyl-source-stream");
|
||||
let spawn = require("child_process").spawn;
|
||||
let uglify = require("gulp-uglify");
|
||||
|
||||
function execFile(args) {
|
||||
return spawn("node", args.split(" "), { stdio: "inherit" });
|
||||
const version = require( "./package" ).version;
|
||||
const spawn = require( "child_process" ).spawn;
|
||||
const gulp = require( "gulp" );
|
||||
const task = gulp.task.bind( gulp );
|
||||
const eslint = require( "gulp-eslint" );
|
||||
const mocha = require( "gulp-mocha" );
|
||||
const dedent = require( "dedent" );
|
||||
const browserify = require( "browserify" );
|
||||
const babelify = require( "babelify" );
|
||||
const source = require( "vinyl-source-stream" );
|
||||
const rename = require( "gulp-rename" );
|
||||
const buffer = require( "vinyl-buffer" );
|
||||
const uglify = require( "gulp-uglify" );
|
||||
const header = require( "gulp-header" );
|
||||
const del = require( "del" );
|
||||
const runSequence = require( "run-sequence" );
|
||||
|
||||
function node( args ) {
|
||||
|
||||
return spawn( "node", args.split( " " ), { stdio: "inherit" } );
|
||||
|
||||
}
|
||||
|
||||
// Run ESLint on all JavaScript files.
|
||||
gulp.task("lint", () =>
|
||||
gulp.src([
|
||||
"lib/**/*.js",
|
||||
"!lib/parser.js",
|
||||
"test/benchmark/**/*.js",
|
||||
"test/benchmark/run",
|
||||
"test/impact",
|
||||
"test/spec/**/*.js",
|
||||
"test/server/run",
|
||||
"bin/*.js",
|
||||
"gulpfile.js"
|
||||
])
|
||||
.pipe(eslint())
|
||||
.pipe(eslint.format())
|
||||
.pipe(eslint.failAfterError())
|
||||
task( "lint", () => gulp
|
||||
.src( [
|
||||
"**/.*rc.js",
|
||||
"lib/**/*.js",
|
||||
"!lib/parser.js",
|
||||
"test/benchmark/**/*.js",
|
||||
"test/benchmark/run",
|
||||
"test/impact",
|
||||
"test/spec/**/*.js",
|
||||
"test/server/run",
|
||||
"bin/*.js",
|
||||
"gulpfile.js"
|
||||
] )
|
||||
.pipe( eslint( { dotfiles: true } ) )
|
||||
.pipe( eslint.format() )
|
||||
.pipe( eslint.failAfterError() )
|
||||
);
|
||||
|
||||
// Run tests.
|
||||
gulp.task("test", () =>
|
||||
gulp.src("test/spec/**/*.spec.js", { read: false })
|
||||
.pipe(mocha())
|
||||
task( "test", () => gulp
|
||||
.src( "test/spec/**/*.spec.js", { read: false } )
|
||||
.pipe( mocha() )
|
||||
);
|
||||
|
||||
// Run benchmarks.
|
||||
gulp.task("benchmark", () => execFile("test/benchmark/run"));
|
||||
task( "benchmark", () => node( "test/benchmark/run" ) );
|
||||
|
||||
// Create the browser build.
|
||||
gulp.task("browser:build", () => {
|
||||
const HEADER = [
|
||||
"//",
|
||||
"// PEG.js v" + require("./package").version,
|
||||
"// https://pegjs.org/",
|
||||
"//",
|
||||
"// Copyright (c) 2010-2016 David Majda",
|
||||
"// Copyright (c) 2017+ Futago-za Ryuu",
|
||||
"//",
|
||||
"// Licensed under the MIT License.",
|
||||
"//",
|
||||
""
|
||||
]
|
||||
.map(line => `${line}\n`)
|
||||
.join("");
|
||||
|
||||
return browserify("lib/peg.js", { standalone: "peg" })
|
||||
.transform(babelify, { presets: "es2015", compact: false })
|
||||
.bundle()
|
||||
.pipe(source("peg.js"))
|
||||
.pipe(header(HEADER))
|
||||
.pipe(gulp.dest("browser"))
|
||||
.pipe(rename({ suffix: ".min" }))
|
||||
.pipe(buffer())
|
||||
.pipe(uglify())
|
||||
.pipe(header(HEADER))
|
||||
.pipe(gulp.dest("browser"));
|
||||
});
|
||||
task( "browser:build", () => {
|
||||
|
||||
const HEADER = dedent`
|
||||
|
||||
/**
|
||||
* PEG.js v${ version }
|
||||
* https://pegjs.org/
|
||||
*
|
||||
* Copyright (c) 2010-2016 David Majda
|
||||
* Copyright (c) 2017+ Futago-za Ryuu
|
||||
*
|
||||
* Released under the MIT License.
|
||||
*/\n\n
|
||||
|
||||
`;
|
||||
|
||||
return browserify( "lib/peg.js", { standalone: "peg" } )
|
||||
.transform( babelify, { presets: "es2015", compact: false } )
|
||||
.bundle()
|
||||
.pipe( source( "peg.js" ) )
|
||||
.pipe( header( HEADER ) )
|
||||
.pipe( gulp.dest( "browser" ) )
|
||||
.pipe( rename( { suffix: ".min" } ) )
|
||||
.pipe( buffer() )
|
||||
.pipe( uglify() )
|
||||
.pipe( header( HEADER ) )
|
||||
.pipe( gulp.dest( "browser" ) );
|
||||
|
||||
} );
|
||||
|
||||
// Delete the browser build.
|
||||
gulp.task("browser:clean", () => del("browser"));
|
||||
task( "browser:clean", () => del( "browser" ) );
|
||||
|
||||
// Generate the grammar parser.
|
||||
gulp.task("parser", () =>
|
||||
execFile("bin/peg src/parser.pegjs -o lib/parser.js")
|
||||
task( "parser", () =>
|
||||
node( "bin/peg src/parser.pegjs -o lib/parser.js" )
|
||||
);
|
||||
|
||||
// Default task.
|
||||
gulp.task("default", cb =>
|
||||
runSequence("lint", "test", cb)
|
||||
task( "default", cb =>
|
||||
runSequence( "benchmark", "test", cb )
|
||||
);
|
||||
|
||||
@ -1,76 +1,102 @@
|
||||
"use strict";
|
||||
|
||||
let visitor = require("./visitor");
|
||||
const visitor = require( "./visitor" );
|
||||
|
||||
// AST utilities.
|
||||
let asts = {
|
||||
findRule(ast, name) {
|
||||
for (let i = 0; i < ast.rules.length; i++) {
|
||||
if (ast.rules[i].name === name) {
|
||||
return ast.rules[i];
|
||||
}
|
||||
}
|
||||
const asts = {
|
||||
findRule( ast, name ) {
|
||||
|
||||
return undefined;
|
||||
},
|
||||
for ( let i = 0; i < ast.rules.length; i++ ) {
|
||||
|
||||
indexOfRule(ast, name) {
|
||||
for (let i = 0; i < ast.rules.length; i++) {
|
||||
if (ast.rules[i].name === name) {
|
||||
return i;
|
||||
}
|
||||
}
|
||||
if ( ast.rules[ i ].name === name ) return ast.rules[ i ];
|
||||
|
||||
return -1;
|
||||
},
|
||||
}
|
||||
|
||||
alwaysConsumesOnSuccess(ast, node) {
|
||||
function consumesTrue() { return true; }
|
||||
function consumesFalse() { return false; }
|
||||
return void 0;
|
||||
|
||||
function consumesExpression(node) {
|
||||
return consumes(node.expression);
|
||||
}
|
||||
},
|
||||
|
||||
indexOfRule( ast, name ) {
|
||||
|
||||
for ( let i = 0; i < ast.rules.length; i++ ) {
|
||||
|
||||
if ( ast.rules[ i ].name === name ) return i;
|
||||
|
||||
}
|
||||
|
||||
return -1;
|
||||
|
||||
},
|
||||
|
||||
alwaysConsumesOnSuccess( ast, node ) {
|
||||
|
||||
let consumes;
|
||||
|
||||
function consumesTrue() {
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
function consumesFalse() {
|
||||
|
||||
return false;
|
||||
|
||||
}
|
||||
|
||||
function consumesExpression( node ) {
|
||||
|
||||
return consumes( node.expression );
|
||||
|
||||
}
|
||||
|
||||
let consumes = visitor.build({
|
||||
rule: consumesExpression,
|
||||
named: consumesExpression,
|
||||
|
||||
choice(node) {
|
||||
return node.alternatives.every(consumes);
|
||||
},
|
||||
|
||||
action: consumesExpression,
|
||||
|
||||
sequence(node) {
|
||||
return node.elements.some(consumes);
|
||||
},
|
||||
|
||||
labeled: consumesExpression,
|
||||
text: consumesExpression,
|
||||
simple_and: consumesFalse,
|
||||
simple_not: consumesFalse,
|
||||
optional: consumesFalse,
|
||||
zero_or_more: consumesFalse,
|
||||
one_or_more: consumesExpression,
|
||||
group: consumesExpression,
|
||||
semantic_and: consumesFalse,
|
||||
semantic_not: consumesFalse,
|
||||
|
||||
rule_ref(node) {
|
||||
return consumes(asts.findRule(ast, node.name));
|
||||
},
|
||||
|
||||
literal(node) {
|
||||
return node.value !== "";
|
||||
},
|
||||
|
||||
class: consumesTrue,
|
||||
any: consumesTrue
|
||||
});
|
||||
|
||||
return consumes(node);
|
||||
}
|
||||
consumes = visitor.build( {
|
||||
rule: consumesExpression,
|
||||
named: consumesExpression,
|
||||
|
||||
choice( node ) {
|
||||
|
||||
return node.alternatives.every( consumes );
|
||||
|
||||
},
|
||||
|
||||
action: consumesExpression,
|
||||
|
||||
sequence( node ) {
|
||||
|
||||
return node.elements.some( consumes );
|
||||
|
||||
},
|
||||
|
||||
labeled: consumesExpression,
|
||||
text: consumesExpression,
|
||||
simple_and: consumesFalse,
|
||||
simple_not: consumesFalse,
|
||||
optional: consumesFalse,
|
||||
zero_or_more: consumesFalse,
|
||||
one_or_more: consumesExpression,
|
||||
group: consumesExpression,
|
||||
semantic_and: consumesFalse,
|
||||
semantic_not: consumesFalse,
|
||||
|
||||
rule_ref( node ) {
|
||||
|
||||
return consumes( asts.findRule( ast, node.name ) );
|
||||
|
||||
},
|
||||
|
||||
literal( node ) {
|
||||
|
||||
return node.value !== "";
|
||||
|
||||
},
|
||||
|
||||
class: consumesTrue,
|
||||
any: consumesTrue
|
||||
} );
|
||||
|
||||
return consumes( node );
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = asts;
|
||||
|
||||
@ -1,91 +1,109 @@
|
||||
"use strict";
|
||||
|
||||
let generateBytecode = require("./passes/generate-bytecode");
|
||||
let generateJS = require("./passes/generate-js");
|
||||
let removeProxyRules = require("./passes/remove-proxy-rules");
|
||||
let reportDuplicateLabels = require("./passes/report-duplicate-labels");
|
||||
let reportDuplicateRules = require("./passes/report-duplicate-rules");
|
||||
let reportInfiniteRecursion = require("./passes/report-infinite-recursion");
|
||||
let reportInfiniteRepetition = require("./passes/report-infinite-repetition");
|
||||
let reportUndefinedRules = require("./passes/report-undefined-rules");
|
||||
let visitor = require("./visitor");
|
||||
|
||||
function processOptions(options, defaults) {
|
||||
let processedOptions = {};
|
||||
|
||||
Object.keys(options).forEach(name => {
|
||||
processedOptions[name] = options[name];
|
||||
});
|
||||
|
||||
Object.keys(defaults).forEach(name => {
|
||||
if (!Object.prototype.hasOwnProperty.call(processedOptions, name)) {
|
||||
processedOptions[name] = defaults[name];
|
||||
}
|
||||
});
|
||||
const generateBytecode = require( "./passes/generate-bytecode" );
|
||||
const generateJS = require( "./passes/generate-js" );
|
||||
const removeProxyRules = require( "./passes/remove-proxy-rules" );
|
||||
const reportDuplicateLabels = require( "./passes/report-duplicate-labels" );
|
||||
const reportDuplicateRules = require( "./passes/report-duplicate-rules" );
|
||||
const reportInfiniteRecursion = require( "./passes/report-infinite-recursion" );
|
||||
const reportInfiniteRepetition = require( "./passes/report-infinite-repetition" );
|
||||
const reportUndefinedRules = require( "./passes/report-undefined-rules" );
|
||||
const visitor = require( "./visitor" );
|
||||
|
||||
function processOptions( options, defaults ) {
|
||||
|
||||
const processedOptions = {};
|
||||
|
||||
Object.keys( options ).forEach( name => {
|
||||
|
||||
processedOptions[ name ] = options[ name ];
|
||||
|
||||
} );
|
||||
|
||||
Object.keys( defaults ).forEach( name => {
|
||||
|
||||
if ( ! Object.prototype.hasOwnProperty.call( processedOptions, name ) ) {
|
||||
|
||||
processedOptions[ name ] = defaults[ name ];
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
return processedOptions;
|
||||
|
||||
return processedOptions;
|
||||
}
|
||||
|
||||
let compiler = {
|
||||
// AST node visitor builder. Useful mainly for plugins which manipulate the
|
||||
// AST.
|
||||
visitor: visitor,
|
||||
|
||||
// Compiler passes.
|
||||
//
|
||||
// Each pass is a function that is passed the AST. It can perform checks on it
|
||||
// or modify it as needed. If the pass encounters a semantic error, it throws
|
||||
// |peg.GrammarError|.
|
||||
passes: {
|
||||
check: {
|
||||
reportUndefinedRules: reportUndefinedRules,
|
||||
reportDuplicateRules: reportDuplicateRules,
|
||||
reportDuplicateLabels: reportDuplicateLabels,
|
||||
reportInfiniteRecursion: reportInfiniteRecursion,
|
||||
reportInfiniteRepetition: reportInfiniteRepetition
|
||||
},
|
||||
transform: {
|
||||
removeProxyRules: removeProxyRules
|
||||
const compiler = {
|
||||
// AST node visitor builder. Useful mainly for plugins which manipulate the
|
||||
// AST.
|
||||
visitor: visitor,
|
||||
|
||||
// Compiler passes.
|
||||
//
|
||||
// Each pass is a function that is passed the AST. It can perform checks on it
|
||||
// or modify it as needed. If the pass encounters a semantic error, it throws
|
||||
// |peg.GrammarError|.
|
||||
passes: {
|
||||
check: {
|
||||
reportUndefinedRules: reportUndefinedRules,
|
||||
reportDuplicateRules: reportDuplicateRules,
|
||||
reportDuplicateLabels: reportDuplicateLabels,
|
||||
reportInfiniteRecursion: reportInfiniteRecursion,
|
||||
reportInfiniteRepetition: reportInfiniteRepetition
|
||||
},
|
||||
transform: {
|
||||
removeProxyRules: removeProxyRules
|
||||
},
|
||||
generate: {
|
||||
generateBytecode: generateBytecode,
|
||||
generateJS: generateJS
|
||||
}
|
||||
},
|
||||
generate: {
|
||||
generateBytecode: generateBytecode,
|
||||
generateJS: generateJS
|
||||
}
|
||||
},
|
||||
|
||||
// Generates a parser from a specified grammar AST. Throws |peg.GrammarError|
|
||||
// if the AST contains a semantic error. Note that not all errors are detected
|
||||
// during the generation and some may protrude to the generated parser and
|
||||
// cause its malfunction.
|
||||
compile(ast, passes, options) {
|
||||
options = options !== undefined ? options : {};
|
||||
|
||||
options = processOptions(options, {
|
||||
allowedStartRules: [ast.rules[0].name],
|
||||
cache: false,
|
||||
dependencies: {},
|
||||
exportVar: null,
|
||||
format: "bare",
|
||||
optimize: "speed",
|
||||
output: "parser",
|
||||
trace: false
|
||||
});
|
||||
|
||||
Object.keys(passes).forEach(stage => {
|
||||
passes[stage].forEach(p => { p(ast, options); });
|
||||
});
|
||||
|
||||
switch (options.output) {
|
||||
case "parser":
|
||||
return eval(ast.code);
|
||||
|
||||
case "source":
|
||||
return ast.code;
|
||||
|
||||
default:
|
||||
throw new Error("Invalid output format: " + options.output + ".");
|
||||
|
||||
// Generates a parser from a specified grammar AST. Throws |peg.GrammarError|
|
||||
// if the AST contains a semantic error. Note that not all errors are detected
|
||||
// during the generation and some may protrude to the generated parser and
|
||||
// cause its malfunction.
|
||||
compile( ast, passes, options ) {
|
||||
|
||||
options = typeof options !== "undefined" ? options : {};
|
||||
|
||||
options = processOptions( options, {
|
||||
allowedStartRules: [ ast.rules[ 0 ].name ],
|
||||
cache: false,
|
||||
dependencies: {},
|
||||
exportVar: null,
|
||||
format: "bare",
|
||||
optimize: "speed",
|
||||
output: "parser",
|
||||
trace: false
|
||||
} );
|
||||
|
||||
Object.keys( passes ).forEach( stage => {
|
||||
|
||||
passes[ stage ].forEach( pass => {
|
||||
|
||||
pass( ast, options );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
switch ( options.output ) {
|
||||
|
||||
case "parser":
|
||||
return eval( ast.code );
|
||||
|
||||
case "source":
|
||||
return ast.code;
|
||||
|
||||
default:
|
||||
throw new Error( `Invalid output format: ${ options.output }.` );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = compiler;
|
||||
|
||||
@ -1,54 +1,62 @@
|
||||
"use strict";
|
||||
|
||||
function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); }
|
||||
function hex( ch ) {
|
||||
|
||||
return ch.charCodeAt( 0 ).toString( 16 ).toUpperCase();
|
||||
|
||||
}
|
||||
|
||||
// JavaScript code generation helpers.
|
||||
let js = {
|
||||
stringEscape(s) {
|
||||
// ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a string
|
||||
// literal except for the closing quote character, backslash, carriage
|
||||
// return, line separator, paragraph separator, and line feed. Any character
|
||||
// may appear in the form of an escape sequence.
|
||||
//
|
||||
// For portability, we also escape all control and non-ASCII characters.
|
||||
return s
|
||||
.replace(/\\/g, "\\\\") // backslash
|
||||
.replace(/"/g, "\\\"") // closing double quote
|
||||
.replace(/\0/g, "\\0") // null
|
||||
.replace(/\x08/g, "\\b") // backspace
|
||||
.replace(/\t/g, "\\t") // horizontal tab
|
||||
.replace(/\n/g, "\\n") // line feed
|
||||
.replace(/\v/g, "\\v") // vertical tab
|
||||
.replace(/\f/g, "\\f") // form feed
|
||||
.replace(/\r/g, "\\r") // carriage return
|
||||
.replace(/[\x00-\x0F]/g, ch => "\\x0" + hex(ch))
|
||||
.replace(/[\x10-\x1F\x7F-\xFF]/g, ch => "\\x" + hex(ch))
|
||||
.replace(/[\u0100-\u0FFF]/g, ch => "\\u0" + hex(ch))
|
||||
.replace(/[\u1000-\uFFFF]/g, ch => "\\u" + hex(ch));
|
||||
},
|
||||
|
||||
regexpClassEscape(s) {
|
||||
// Based on ECMA-262, 5th ed., 7.8.5 & 15.10.1.
|
||||
//
|
||||
// For portability, we also escape all control and non-ASCII characters.
|
||||
return s
|
||||
.replace(/\\/g, "\\\\") // backslash
|
||||
.replace(/\//g, "\\/") // closing slash
|
||||
.replace(/]/g, "\\]") // closing bracket
|
||||
.replace(/\^/g, "\\^") // caret
|
||||
.replace(/-/g, "\\-") // dash
|
||||
.replace(/\0/g, "\\0") // null
|
||||
.replace(/\x08/g, "\\b") // backspace
|
||||
.replace(/\t/g, "\\t") // horizontal tab
|
||||
.replace(/\n/g, "\\n") // line feed
|
||||
.replace(/\v/g, "\\v") // vertical tab
|
||||
.replace(/\f/g, "\\f") // form feed
|
||||
.replace(/\r/g, "\\r") // carriage return
|
||||
.replace(/[\x00-\x0F]/g, ch => "\\x0" + hex(ch))
|
||||
.replace(/[\x10-\x1F\x7F-\xFF]/g, ch => "\\x" + hex(ch))
|
||||
.replace(/[\u0100-\u0FFF]/g, ch => "\\u0" + hex(ch))
|
||||
.replace(/[\u1000-\uFFFF]/g, ch => "\\u" + hex(ch));
|
||||
}
|
||||
const js = {
|
||||
stringEscape( s ) {
|
||||
|
||||
// ECMA-262, 5th ed., 7.8.4: All characters may appear literally in a string
|
||||
// literal except for the closing quote character, backslash, carriage
|
||||
// return, line separator, paragraph separator, and line feed. Any character
|
||||
// may appear in the form of an escape sequence.
|
||||
//
|
||||
// For portability, we also escape all control and non-ASCII characters.
|
||||
return s
|
||||
.replace( /\\/g, "\\\\" ) // backslash
|
||||
.replace( /"/g, "\\\"" ) // closing double quote
|
||||
.replace( /\0/g, "\\0" ) // null
|
||||
.replace( /\x08/g, "\\b" ) // backspace
|
||||
.replace( /\t/g, "\\t" ) // horizontal tab
|
||||
.replace( /\n/g, "\\n" ) // line feed
|
||||
.replace( /\v/g, "\\v" ) // vertical tab
|
||||
.replace( /\f/g, "\\f" ) // form feed
|
||||
.replace( /\r/g, "\\r" ) // carriage return
|
||||
.replace( /[\x00-\x0F]/g, ch => "\\x0" + hex( ch ) )
|
||||
.replace( /[\x10-\x1F\x7F-\xFF]/g, ch => "\\x" + hex( ch ) )
|
||||
.replace( /[\u0100-\u0FFF]/g, ch => "\\u0" + hex( ch ) )
|
||||
.replace( /[\u1000-\uFFFF]/g, ch => "\\u" + hex( ch ) );
|
||||
|
||||
},
|
||||
|
||||
regexpClassEscape( s ) {
|
||||
|
||||
// Based on ECMA-262, 5th ed., 7.8.5 & 15.10.1.
|
||||
//
|
||||
// For portability, we also escape all control and non-ASCII characters.
|
||||
return s
|
||||
.replace( /\\/g, "\\\\" ) // backslash
|
||||
.replace( /\//g, "\\/" ) // closing slash
|
||||
.replace( /]/g, "\\]" ) // closing bracket
|
||||
.replace( /\^/g, "\\^" ) // caret
|
||||
.replace( /-/g, "\\-" ) // dash
|
||||
.replace( /\0/g, "\\0" ) // null
|
||||
.replace( /\x08/g, "\\b" ) // backspace
|
||||
.replace( /\t/g, "\\t" ) // horizontal tab
|
||||
.replace( /\n/g, "\\n" ) // line feed
|
||||
.replace( /\v/g, "\\v" ) // vertical tab
|
||||
.replace( /\f/g, "\\f" ) // form feed
|
||||
.replace( /\r/g, "\\r" ) // carriage return
|
||||
.replace( /[\x00-\x0F]/g, ch => "\\x0" + hex( ch ) )
|
||||
.replace( /[\x10-\x1F\x7F-\xFF]/g, ch => "\\x" + hex( ch ) )
|
||||
.replace( /[\u0100-\u0FFF]/g, ch => "\\u0" + hex( ch ) )
|
||||
.replace( /[\u1000-\uFFFF]/g, ch => "\\u" + hex( ch ) );
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = js;
|
||||
|
||||
@ -1,54 +1,56 @@
|
||||
"use strict";
|
||||
|
||||
// Bytecode instruction opcodes.
|
||||
let opcodes = {
|
||||
// Stack Manipulation
|
||||
|
||||
PUSH: 0, // PUSH c
|
||||
PUSH_UNDEFINED: 1, // PUSH_UNDEFINED
|
||||
PUSH_NULL: 2, // PUSH_NULL
|
||||
PUSH_FAILED: 3, // PUSH_FAILED
|
||||
PUSH_EMPTY_ARRAY: 4, // PUSH_EMPTY_ARRAY
|
||||
PUSH_CURR_POS: 5, // PUSH_CURR_POS
|
||||
POP: 6, // POP
|
||||
POP_CURR_POS: 7, // POP_CURR_POS
|
||||
POP_N: 8, // POP_N n
|
||||
NIP: 9, // NIP
|
||||
APPEND: 10, // APPEND
|
||||
WRAP: 11, // WRAP n
|
||||
TEXT: 12, // TEXT
|
||||
|
||||
// Conditions and Loops
|
||||
|
||||
IF: 13, // IF t, f
|
||||
IF_ERROR: 14, // IF_ERROR t, f
|
||||
IF_NOT_ERROR: 15, // IF_NOT_ERROR t, f
|
||||
WHILE_NOT_ERROR: 16, // WHILE_NOT_ERROR b
|
||||
|
||||
// Matching
|
||||
|
||||
MATCH_ANY: 17, // MATCH_ANY a, f, ...
|
||||
MATCH_STRING: 18, // MATCH_STRING s, a, f, ...
|
||||
MATCH_STRING_IC: 19, // MATCH_STRING_IC s, a, f, ...
|
||||
MATCH_REGEXP: 20, // MATCH_REGEXP r, a, f, ...
|
||||
ACCEPT_N: 21, // ACCEPT_N n
|
||||
ACCEPT_STRING: 22, // ACCEPT_STRING s
|
||||
FAIL: 23, // FAIL e
|
||||
|
||||
// Calls
|
||||
|
||||
LOAD_SAVED_POS: 24, // LOAD_SAVED_POS p
|
||||
UPDATE_SAVED_POS: 25, // UPDATE_SAVED_POS
|
||||
CALL: 26, // CALL f, n, pc, p1, p2, ..., pN
|
||||
|
||||
// Rules
|
||||
|
||||
RULE: 27, // RULE r
|
||||
|
||||
// Failure Reporting
|
||||
|
||||
SILENT_FAILS_ON: 28, // SILENT_FAILS_ON
|
||||
SILENT_FAILS_OFF: 29 // SILENT_FAILS_OFF
|
||||
const opcodes = {
|
||||
|
||||
// Stack Manipulation
|
||||
|
||||
PUSH: 0, // PUSH c
|
||||
PUSH_UNDEFINED: 1, // PUSH_UNDEFINED
|
||||
PUSH_NULL: 2, // PUSH_NULL
|
||||
PUSH_FAILED: 3, // PUSH_FAILED
|
||||
PUSH_EMPTY_ARRAY: 4, // PUSH_EMPTY_ARRAY
|
||||
PUSH_CURR_POS: 5, // PUSH_CURR_POS
|
||||
POP: 6, // POP
|
||||
POP_CURR_POS: 7, // POP_CURR_POS
|
||||
POP_N: 8, // POP_N n
|
||||
NIP: 9, // NIP
|
||||
APPEND: 10, // APPEND
|
||||
WRAP: 11, // WRAP n
|
||||
TEXT: 12, // TEXT
|
||||
|
||||
// Conditions and Loops
|
||||
|
||||
IF: 13, // IF t, f
|
||||
IF_ERROR: 14, // IF_ERROR t, f
|
||||
IF_NOT_ERROR: 15, // IF_NOT_ERROR t, f
|
||||
WHILE_NOT_ERROR: 16, // WHILE_NOT_ERROR b
|
||||
|
||||
// Matching
|
||||
|
||||
MATCH_ANY: 17, // MATCH_ANY a, f, ...
|
||||
MATCH_STRING: 18, // MATCH_STRING s, a, f, ...
|
||||
MATCH_STRING_IC: 19, // MATCH_STRING_IC s, a, f, ...
|
||||
MATCH_REGEXP: 20, // MATCH_REGEXP r, a, f, ...
|
||||
ACCEPT_N: 21, // ACCEPT_N n
|
||||
ACCEPT_STRING: 22, // ACCEPT_STRING s
|
||||
FAIL: 23, // FAIL e
|
||||
|
||||
// Calls
|
||||
|
||||
LOAD_SAVED_POS: 24, // LOAD_SAVED_POS p
|
||||
UPDATE_SAVED_POS: 25, // UPDATE_SAVED_POS
|
||||
CALL: 26, // CALL f, n, pc, p1, p2, ..., pN
|
||||
|
||||
// Rules
|
||||
|
||||
RULE: 27, // RULE r
|
||||
|
||||
// Failure Reporting
|
||||
|
||||
SILENT_FAILS_ON: 28, // SILENT_FAILS_ON
|
||||
SILENT_FAILS_OFF: 29 // SILENT_FAILS_OFF
|
||||
|
||||
};
|
||||
|
||||
module.exports = opcodes;
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,39 +1,59 @@
|
||||
"use strict";
|
||||
|
||||
let visitor = require("../visitor");
|
||||
const visitor = require( "../visitor" );
|
||||
|
||||
// Removes proxy rules -- that is, rules that only delegate to other rule.
|
||||
function removeProxyRules(ast, options) {
|
||||
function isProxyRule(node) {
|
||||
return node.type === "rule" && node.expression.type === "rule_ref";
|
||||
}
|
||||
|
||||
function replaceRuleRefs(ast, from, to) {
|
||||
let replace = visitor.build({
|
||||
rule_ref(node) {
|
||||
if (node.name === from) {
|
||||
node.name = to;
|
||||
}
|
||||
}
|
||||
});
|
||||
function removeProxyRules( ast, options ) {
|
||||
|
||||
replace(ast);
|
||||
}
|
||||
function isProxyRule( node ) {
|
||||
|
||||
let indices = [];
|
||||
return node.type === "rule" && node.expression.type === "rule_ref";
|
||||
|
||||
ast.rules.forEach((rule, i) => {
|
||||
if (isProxyRule(rule)) {
|
||||
replaceRuleRefs(ast, rule.name, rule.expression.name);
|
||||
if (options.allowedStartRules.indexOf(rule.name) === -1) {
|
||||
indices.push(i);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
indices.reverse();
|
||||
function replaceRuleRefs( ast, from, to ) {
|
||||
|
||||
const replace = visitor.build( {
|
||||
rule_ref( node ) {
|
||||
|
||||
if ( node.name === from ) {
|
||||
|
||||
node.name = to;
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
} );
|
||||
|
||||
replace( ast );
|
||||
|
||||
}
|
||||
|
||||
const indices = [];
|
||||
|
||||
ast.rules.forEach( ( rule, i ) => {
|
||||
|
||||
if ( isProxyRule( rule ) ) {
|
||||
|
||||
replaceRuleRefs( ast, rule.name, rule.expression.name );
|
||||
if ( options.allowedStartRules.indexOf( rule.name ) === -1 ) {
|
||||
|
||||
indices.push( i );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
indices.reverse();
|
||||
|
||||
indices.forEach( i => {
|
||||
|
||||
ast.rules.splice( i, 1 );
|
||||
|
||||
} );
|
||||
|
||||
indices.forEach(i => { ast.rules.splice(i, 1); });
|
||||
}
|
||||
|
||||
module.exports = removeProxyRules;
|
||||
|
||||
@ -1,62 +1,83 @@
|
||||
"use strict";
|
||||
|
||||
let GrammarError = require("../../grammar-error");
|
||||
let visitor = require("../visitor");
|
||||
const GrammarError = require( "../../grammar-error" );
|
||||
const visitor = require( "../visitor" );
|
||||
|
||||
// Checks that each label is defined only once within each scope.
|
||||
function reportDuplicateLabels(ast) {
|
||||
function cloneEnv(env) {
|
||||
let clone = {};
|
||||
|
||||
Object.keys(env).forEach(name => {
|
||||
clone[name] = env[name];
|
||||
});
|
||||
|
||||
return clone;
|
||||
}
|
||||
|
||||
function checkExpressionWithClonedEnv(node, env) {
|
||||
check(node.expression, cloneEnv(env));
|
||||
}
|
||||
|
||||
let check = visitor.build({
|
||||
rule(node) {
|
||||
check(node.expression, { });
|
||||
},
|
||||
|
||||
choice(node, env) {
|
||||
node.alternatives.forEach(alternative => {
|
||||
check(alternative, cloneEnv(env));
|
||||
});
|
||||
},
|
||||
|
||||
action: checkExpressionWithClonedEnv,
|
||||
|
||||
labeled(node, env) {
|
||||
if (Object.prototype.hasOwnProperty.call(env, node.label)) {
|
||||
throw new GrammarError(
|
||||
"Label \"" + node.label + "\" is already defined "
|
||||
+ "at line " + env[node.label].start.line + ", "
|
||||
+ "column " + env[node.label].start.column + ".",
|
||||
node.location
|
||||
);
|
||||
}
|
||||
|
||||
check(node.expression, env);
|
||||
|
||||
env[node.label] = node.location;
|
||||
},
|
||||
|
||||
text: checkExpressionWithClonedEnv,
|
||||
simple_and: checkExpressionWithClonedEnv,
|
||||
simple_not: checkExpressionWithClonedEnv,
|
||||
optional: checkExpressionWithClonedEnv,
|
||||
zero_or_more: checkExpressionWithClonedEnv,
|
||||
one_or_more: checkExpressionWithClonedEnv,
|
||||
group: checkExpressionWithClonedEnv
|
||||
});
|
||||
|
||||
check(ast);
|
||||
function reportDuplicateLabels( ast ) {
|
||||
|
||||
let check;
|
||||
|
||||
function cloneEnv( env ) {
|
||||
|
||||
const clone = {};
|
||||
|
||||
Object.keys( env ).forEach( name => {
|
||||
|
||||
clone[ name ] = env[ name ];
|
||||
|
||||
} );
|
||||
|
||||
return clone;
|
||||
|
||||
}
|
||||
|
||||
function checkExpressionWithClonedEnv( node, env ) {
|
||||
|
||||
check( node.expression, cloneEnv( env ) );
|
||||
|
||||
}
|
||||
|
||||
check = visitor.build( {
|
||||
rule( node ) {
|
||||
|
||||
check( node.expression, {} );
|
||||
|
||||
},
|
||||
|
||||
choice( node, env ) {
|
||||
|
||||
node.alternatives.forEach( alternative => {
|
||||
|
||||
check( alternative, cloneEnv( env ) );
|
||||
|
||||
} );
|
||||
|
||||
},
|
||||
|
||||
action: checkExpressionWithClonedEnv,
|
||||
|
||||
labeled( node, env ) {
|
||||
|
||||
const label = node.label;
|
||||
|
||||
if ( Object.prototype.hasOwnProperty.call( env, label ) ) {
|
||||
|
||||
const start = env[ label ].start;
|
||||
|
||||
throw new GrammarError(
|
||||
`Label "${ label }" is already defined at line ${ start.line }, column ${ start.column }.`,
|
||||
node.location
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
check( node.expression, env );
|
||||
env[ label ] = node.location;
|
||||
|
||||
},
|
||||
|
||||
text: checkExpressionWithClonedEnv,
|
||||
simple_and: checkExpressionWithClonedEnv,
|
||||
simple_not: checkExpressionWithClonedEnv,
|
||||
optional: checkExpressionWithClonedEnv,
|
||||
zero_or_more: checkExpressionWithClonedEnv,
|
||||
one_or_more: checkExpressionWithClonedEnv,
|
||||
group: checkExpressionWithClonedEnv
|
||||
} );
|
||||
|
||||
check( ast );
|
||||
|
||||
}
|
||||
|
||||
module.exports = reportDuplicateLabels;
|
||||
|
||||
@ -1,28 +1,36 @@
|
||||
"use strict";
|
||||
|
||||
let GrammarError = require("../../grammar-error");
|
||||
let visitor = require("../visitor");
|
||||
const GrammarError = require( "../../grammar-error" );
|
||||
const visitor = require( "../visitor" );
|
||||
|
||||
// Checks that each rule is defined only once.
|
||||
function reportDuplicateRules(ast) {
|
||||
let rules = {};
|
||||
|
||||
let check = visitor.build({
|
||||
rule(node) {
|
||||
if (Object.prototype.hasOwnProperty.call(rules, node.name)) {
|
||||
throw new GrammarError(
|
||||
"Rule \"" + node.name + "\" is already defined "
|
||||
+ "at line " + rules[node.name].start.line + ", "
|
||||
+ "column " + rules[node.name].start.column + ".",
|
||||
node.location
|
||||
);
|
||||
}
|
||||
|
||||
rules[node.name] = node.location;
|
||||
}
|
||||
});
|
||||
|
||||
check(ast);
|
||||
function reportDuplicateRules( ast ) {
|
||||
|
||||
const rules = {};
|
||||
|
||||
const check = visitor.build( {
|
||||
rule( node ) {
|
||||
|
||||
const name = node.name;
|
||||
|
||||
if ( Object.prototype.hasOwnProperty.call( rules, name ) ) {
|
||||
|
||||
const start = rules[ name ].start;
|
||||
|
||||
throw new GrammarError(
|
||||
`Rule "${ name }" is already defined at line ${ start.line }, column ${ start.column }.`,
|
||||
node.location
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
rules[ node.name ] = node.location;
|
||||
|
||||
}
|
||||
} );
|
||||
|
||||
check( ast );
|
||||
|
||||
}
|
||||
|
||||
module.exports = reportDuplicateRules;
|
||||
|
||||
@ -1,33 +1,43 @@
|
||||
"use strict";
|
||||
|
||||
let GrammarError = require("../../grammar-error");
|
||||
let asts = require("../asts");
|
||||
let visitor = require("../visitor");
|
||||
const GrammarError = require( "../../grammar-error" );
|
||||
const asts = require( "../asts" );
|
||||
const visitor = require( "../visitor" );
|
||||
|
||||
// Reports expressions that don't consume any input inside |*| or |+| in the
|
||||
// grammar, which prevents infinite loops in the generated parser.
|
||||
function reportInfiniteRepetition(ast) {
|
||||
let check = visitor.build({
|
||||
zero_or_more(node) {
|
||||
if (!asts.alwaysConsumesOnSuccess(ast, node.expression)) {
|
||||
throw new GrammarError(
|
||||
"Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
node.location
|
||||
);
|
||||
}
|
||||
},
|
||||
|
||||
one_or_more(node) {
|
||||
if (!asts.alwaysConsumesOnSuccess(ast, node.expression)) {
|
||||
throw new GrammarError(
|
||||
"Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
node.location
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
|
||||
check(ast);
|
||||
function reportInfiniteRepetition( ast ) {
|
||||
|
||||
const check = visitor.build( {
|
||||
zero_or_more( node ) {
|
||||
|
||||
if ( ! asts.alwaysConsumesOnSuccess( ast, node.expression ) ) {
|
||||
|
||||
throw new GrammarError(
|
||||
"Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
node.location
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
},
|
||||
|
||||
one_or_more( node ) {
|
||||
|
||||
if ( ! asts.alwaysConsumesOnSuccess( ast, node.expression ) ) {
|
||||
|
||||
throw new GrammarError(
|
||||
"Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
node.location
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
} );
|
||||
|
||||
check( ast );
|
||||
|
||||
}
|
||||
|
||||
module.exports = reportInfiniteRepetition;
|
||||
|
||||
@ -1,32 +1,43 @@
|
||||
"use strict";
|
||||
|
||||
let GrammarError = require("../../grammar-error");
|
||||
let asts = require("../asts");
|
||||
let visitor = require("../visitor");
|
||||
const GrammarError = require( "../../grammar-error" );
|
||||
const asts = require( "../asts" );
|
||||
const visitor = require( "../visitor" );
|
||||
|
||||
// Checks that all referenced rules exist.
|
||||
function reportUndefinedRules(ast, options) {
|
||||
let check = visitor.build({
|
||||
rule_ref(node) {
|
||||
if (!asts.findRule(ast, node.name)) {
|
||||
throw new GrammarError(
|
||||
"Rule \"" + node.name + "\" is not defined.",
|
||||
node.location
|
||||
);
|
||||
}
|
||||
function reportUndefinedRules( ast, options ) {
|
||||
|
||||
const check = visitor.build( {
|
||||
rule_ref( node ) {
|
||||
|
||||
if ( ! asts.findRule( ast, node.name ) ) {
|
||||
|
||||
throw new GrammarError(
|
||||
`Rule "${ node.name }" is not defined.`,
|
||||
node.location
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
} );
|
||||
|
||||
check( ast );
|
||||
|
||||
if ( options.allowedStartRules ) {
|
||||
|
||||
options.allowedStartRules.forEach( rule => {
|
||||
|
||||
if ( ! asts.findRule( ast, rule ) ) {
|
||||
|
||||
throw new GrammarError( `Start rule "${ rule }" is not defined.` );
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
}
|
||||
});
|
||||
|
||||
check(ast);
|
||||
|
||||
if (options.allowedStartRules) {
|
||||
options.allowedStartRules.forEach(rule => {
|
||||
if (!asts.findRule(ast, rule)) {
|
||||
throw new GrammarError(
|
||||
"Start rule \"" + rule + "\" is not defined.");
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
module.exports = reportUndefinedRules;
|
||||
|
||||
@ -1,75 +1,97 @@
|
||||
"use strict";
|
||||
|
||||
// Simple AST node visitor builder.
|
||||
let visitor = {
|
||||
build(functions) {
|
||||
function visit(node) {
|
||||
return functions[node.type].apply(null, arguments);
|
||||
}
|
||||
const visitor = {
|
||||
build( functions ) {
|
||||
|
||||
function visitNop() {
|
||||
// Do nothing.
|
||||
}
|
||||
function visit( node ) {
|
||||
|
||||
function visitExpression(node) {
|
||||
let extraArgs = Array.prototype.slice.call(arguments, 1);
|
||||
return functions[ node.type ].apply( null, arguments );
|
||||
|
||||
visit.apply(null, [node.expression].concat(extraArgs));
|
||||
}
|
||||
}
|
||||
|
||||
function visitChildren(property) {
|
||||
return function(node) {
|
||||
let extraArgs = Array.prototype.slice.call(arguments, 1);
|
||||
function visitNop() {
|
||||
// Do nothing.
|
||||
}
|
||||
|
||||
node[property].forEach(child => {
|
||||
visit.apply(null, [child].concat(extraArgs));
|
||||
});
|
||||
};
|
||||
}
|
||||
function visitExpression( node ) {
|
||||
|
||||
const extraArgs = Array.prototype.slice.call( arguments, 1 );
|
||||
|
||||
const DEFAULT_FUNCTIONS = {
|
||||
grammar(node) {
|
||||
let extraArgs = Array.prototype.slice.call(arguments, 1);
|
||||
visit( ...[ node.expression ].concat( extraArgs ) );
|
||||
|
||||
if (node.initializer) {
|
||||
visit.apply(null, [node.initializer].concat(extraArgs));
|
||||
}
|
||||
|
||||
node.rules.forEach(rule => {
|
||||
visit.apply(null, [rule].concat(extraArgs));
|
||||
});
|
||||
},
|
||||
|
||||
initializer: visitNop,
|
||||
rule: visitExpression,
|
||||
named: visitExpression,
|
||||
choice: visitChildren("alternatives"),
|
||||
action: visitExpression,
|
||||
sequence: visitChildren("elements"),
|
||||
labeled: visitExpression,
|
||||
text: visitExpression,
|
||||
simple_and: visitExpression,
|
||||
simple_not: visitExpression,
|
||||
optional: visitExpression,
|
||||
zero_or_more: visitExpression,
|
||||
one_or_more: visitExpression,
|
||||
group: visitExpression,
|
||||
semantic_and: visitNop,
|
||||
semantic_not: visitNop,
|
||||
rule_ref: visitNop,
|
||||
literal: visitNop,
|
||||
class: visitNop,
|
||||
any: visitNop
|
||||
};
|
||||
|
||||
Object.keys(DEFAULT_FUNCTIONS).forEach(type => {
|
||||
if (!Object.prototype.hasOwnProperty.call(functions, type)) {
|
||||
functions[type] = DEFAULT_FUNCTIONS[type];
|
||||
}
|
||||
});
|
||||
|
||||
return visit;
|
||||
}
|
||||
function visitChildren( property ) {
|
||||
|
||||
return function visitProperty( node ) {
|
||||
|
||||
const extraArgs = Array.prototype.slice.call( arguments, 1 );
|
||||
|
||||
node[ property ].forEach( child => {
|
||||
|
||||
visit( ...[ child ].concat( extraArgs ) );
|
||||
|
||||
} );
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
const DEFAULT_FUNCTIONS = {
|
||||
grammar( node ) {
|
||||
|
||||
const extraArgs = Array.prototype.slice.call( arguments, 1 );
|
||||
|
||||
if ( node.initializer ) {
|
||||
|
||||
visit( ...[ node.initializer ].concat( extraArgs ) );
|
||||
|
||||
}
|
||||
|
||||
node.rules.forEach( rule => {
|
||||
|
||||
visit( ...[ rule ].concat( extraArgs ) );
|
||||
|
||||
} );
|
||||
|
||||
},
|
||||
|
||||
initializer: visitNop,
|
||||
rule: visitExpression,
|
||||
named: visitExpression,
|
||||
choice: visitChildren( "alternatives" ),
|
||||
action: visitExpression,
|
||||
sequence: visitChildren( "elements" ),
|
||||
labeled: visitExpression,
|
||||
text: visitExpression,
|
||||
simple_and: visitExpression,
|
||||
simple_not: visitExpression,
|
||||
optional: visitExpression,
|
||||
zero_or_more: visitExpression,
|
||||
one_or_more: visitExpression,
|
||||
group: visitExpression,
|
||||
semantic_and: visitNop,
|
||||
semantic_not: visitNop,
|
||||
rule_ref: visitNop,
|
||||
literal: visitNop,
|
||||
class: visitNop,
|
||||
any: visitNop
|
||||
};
|
||||
|
||||
Object.keys( DEFAULT_FUNCTIONS ).forEach( type => {
|
||||
|
||||
if ( ! Object.prototype.hasOwnProperty.call( functions, type ) ) {
|
||||
|
||||
functions[ type ] = DEFAULT_FUNCTIONS[ type ];
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
return visit;
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = visitor;
|
||||
|
||||
@ -1,54 +1,64 @@
|
||||
"use strict";
|
||||
|
||||
let GrammarError = require("./grammar-error");
|
||||
let compiler = require("./compiler");
|
||||
let parser = require("./parser");
|
||||
|
||||
let peg = {
|
||||
// PEG.js version (uses semantic versioning).
|
||||
VERSION: "0.10.0",
|
||||
|
||||
GrammarError: GrammarError,
|
||||
parser: parser,
|
||||
compiler: compiler,
|
||||
|
||||
// Generates a parser from a specified grammar and returns it.
|
||||
//
|
||||
// The grammar must be a string in the format described by the metagramar in
|
||||
// the parser.pegjs file.
|
||||
//
|
||||
// Throws |peg.parser.SyntaxError| if the grammar contains a syntax error or
|
||||
// |peg.GrammarError| if it contains a semantic error. Note that not all
|
||||
// errors are detected during the generation and some may protrude to the
|
||||
// generated parser and cause its malfunction.
|
||||
generate(grammar, options) {
|
||||
options = options !== undefined ? options : {};
|
||||
|
||||
function convertPasses(passes) {
|
||||
let converted = {};
|
||||
|
||||
Object.keys(passes).forEach(stage => {
|
||||
converted[stage] = Object.keys(passes[stage])
|
||||
.map(name => passes[stage][name]);
|
||||
});
|
||||
|
||||
return converted;
|
||||
}
|
||||
const GrammarError = require( "./grammar-error" );
|
||||
const compiler = require( "./compiler" );
|
||||
const parser = require( "./parser" );
|
||||
|
||||
const peg = {
|
||||
// PEG.js version (uses semantic versioning).
|
||||
VERSION: "0.10.0",
|
||||
|
||||
GrammarError: GrammarError,
|
||||
parser: parser,
|
||||
compiler: compiler,
|
||||
|
||||
// Generates a parser from a specified grammar and returns it.
|
||||
//
|
||||
// The grammar must be a string in the format described by the metagramar in
|
||||
// the parser.pegjs file.
|
||||
//
|
||||
// Throws |peg.parser.SyntaxError| if the grammar contains a syntax error or
|
||||
// |peg.GrammarError| if it contains a semantic error. Note that not all
|
||||
// errors are detected during the generation and some may protrude to the
|
||||
// generated parser and cause its malfunction.
|
||||
generate( grammar, options ) {
|
||||
|
||||
options = typeof options !== "undefined" ? options : {};
|
||||
|
||||
function convertPasses( passes ) {
|
||||
|
||||
const converted = {};
|
||||
|
||||
Object.keys( passes ).forEach( stage => {
|
||||
|
||||
let plugins = "plugins" in options ? options.plugins : [];
|
||||
let config = {
|
||||
parser: peg.parser,
|
||||
passes: convertPasses(peg.compiler.passes)
|
||||
};
|
||||
converted[ stage ] = Object.keys( passes[ stage ] )
|
||||
.map( name => passes[ stage ][ name ] );
|
||||
|
||||
plugins.forEach(p => { p.use(config, options); });
|
||||
} );
|
||||
|
||||
return peg.compiler.compile(
|
||||
config.parser.parse(grammar),
|
||||
config.passes,
|
||||
options
|
||||
);
|
||||
}
|
||||
return converted;
|
||||
|
||||
}
|
||||
|
||||
const plugins = "plugins" in options ? options.plugins : [];
|
||||
const config = {
|
||||
parser: peg.parser,
|
||||
passes: convertPasses( peg.compiler.passes )
|
||||
};
|
||||
|
||||
plugins.forEach( p => {
|
||||
|
||||
p.use( config, options );
|
||||
|
||||
} );
|
||||
|
||||
return peg.compiler.compile(
|
||||
config.parser.parse( grammar ),
|
||||
config.passes,
|
||||
options
|
||||
);
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = peg;
|
||||
|
||||
@ -1,42 +1,42 @@
|
||||
"use strict";
|
||||
|
||||
let benchmarks = [
|
||||
{
|
||||
id: "json",
|
||||
title: "JSON",
|
||||
tests: [
|
||||
{ file: "example1.json", title: "Example 1" },
|
||||
{ file: "example2.json", title: "Example 2" },
|
||||
{ file: "example3.json", title: "Example 3" },
|
||||
{ file: "example4.json", title: "Example 4" },
|
||||
{ file: "example5.json", title: "Example 5" }
|
||||
]
|
||||
},
|
||||
{
|
||||
id: "css",
|
||||
title: "CSS",
|
||||
tests: [
|
||||
{ file: "blueprint/src/reset.css", title: "Blueprint - reset.css (source)" },
|
||||
{ file: "blueprint/src/typography.css", title: "Blueprint - typography.css (source)" },
|
||||
{ file: "blueprint/src/forms.css", title: "Blueprint - forms.css (source)" },
|
||||
{ file: "blueprint/src/grid.css", title: "Blueprint - grid.css (source)" },
|
||||
{ file: "blueprint/src/print.css", title: "Blueprint - print.css (source)" },
|
||||
// Contains syntax errors.
|
||||
// { file: "blueprint/src/ie.css", title: "Blueprint - ie.css (source)" },
|
||||
{ file: "blueprint/min/screen.css", title: "Blueprint - screen.css (minified)" },
|
||||
{ file: "blueprint/min/print.css", title: "Blueprint - print.css (minified)" },
|
||||
// Contains syntax errors.
|
||||
// { file: "blueprint/min/ie.css", title: "Blueprint - ie.css (minified)" },
|
||||
{ file: "960.gs/src/reset.css", title: "960.gs - reset.css (source)" },
|
||||
{ file: "960.gs/src/text.css", title: "960.gs - text.css (source)" },
|
||||
{ file: "960.gs/src/960.css", title: "960.gs - 960.css (source)" },
|
||||
{ file: "960.gs/src/960_24_col.css", title: "960.gs - 960_24_col.css (source)" },
|
||||
{ file: "960.gs/min/reset.css", title: "960.gs - reset.css (minified)" },
|
||||
{ file: "960.gs/min/text.css", title: "960.gs - text.css (minified)" },
|
||||
{ file: "960.gs/min/960.css", title: "960.gs - 960.css (minified)" },
|
||||
{ file: "960.gs/min/960_24_col.css", title: "960.gs - 960_24_col.css (minified)" }
|
||||
]
|
||||
}
|
||||
const benchmarks = [
|
||||
{
|
||||
id: "json",
|
||||
title: "JSON",
|
||||
tests: [
|
||||
{ file: "example1.json", title: "Example 1" },
|
||||
{ file: "example2.json", title: "Example 2" },
|
||||
{ file: "example3.json", title: "Example 3" },
|
||||
{ file: "example4.json", title: "Example 4" },
|
||||
{ file: "example5.json", title: "Example 5" }
|
||||
]
|
||||
},
|
||||
{
|
||||
id: "css",
|
||||
title: "CSS",
|
||||
tests: [
|
||||
{ file: "blueprint/src/reset.css", title: "Blueprint - reset.css (source)" },
|
||||
{ file: "blueprint/src/typography.css", title: "Blueprint - typography.css (source)" },
|
||||
{ file: "blueprint/src/forms.css", title: "Blueprint - forms.css (source)" },
|
||||
{ file: "blueprint/src/grid.css", title: "Blueprint - grid.css (source)" },
|
||||
{ file: "blueprint/src/print.css", title: "Blueprint - print.css (source)" },
|
||||
// Contains syntax errors.
|
||||
// { file: "blueprint/src/ie.css", title: "Blueprint - ie.css (source)" },
|
||||
{ file: "blueprint/min/screen.css", title: "Blueprint - screen.css (minified)" },
|
||||
{ file: "blueprint/min/print.css", title: "Blueprint - print.css (minified)" },
|
||||
// Contains syntax errors.
|
||||
// { file: "blueprint/min/ie.css", title: "Blueprint - ie.css (minified)" },
|
||||
{ file: "960.gs/src/reset.css", title: "960.gs - reset.css (source)" },
|
||||
{ file: "960.gs/src/text.css", title: "960.gs - text.css (source)" },
|
||||
{ file: "960.gs/src/960.css", title: "960.gs - 960.css (source)" },
|
||||
{ file: "960.gs/src/960_24_col.css", title: "960.gs - 960_24_col.css (source)" },
|
||||
{ file: "960.gs/min/reset.css", title: "960.gs - reset.css (minified)" },
|
||||
{ file: "960.gs/min/text.css", title: "960.gs - text.css (minified)" },
|
||||
{ file: "960.gs/min/960.css", title: "960.gs - 960.css (minified)" },
|
||||
{ file: "960.gs/min/960_24_col.css", title: "960.gs - 960_24_col.css (minified)" }
|
||||
]
|
||||
}
|
||||
];
|
||||
|
||||
module.exports = benchmarks;
|
||||
|
||||
@ -1,118 +1,150 @@
|
||||
"use strict";
|
||||
|
||||
/* global setTimeout */
|
||||
const peg = require( "../../lib/peg" );
|
||||
|
||||
let peg = require("../../lib/peg");
|
||||
const Runner = {
|
||||
run( benchmarks, runCount, options, callbacks ) {
|
||||
|
||||
let Runner = {
|
||||
run(benchmarks, runCount, options, callbacks) {
|
||||
// Queue
|
||||
// Queue
|
||||
|
||||
let Q = {
|
||||
functions: [],
|
||||
const Q = {
|
||||
functions: [],
|
||||
|
||||
add(f) {
|
||||
this.functions.push(f);
|
||||
},
|
||||
add( f ) {
|
||||
|
||||
run() {
|
||||
if (this.functions.length > 0) {
|
||||
this.functions.shift()();
|
||||
this.functions.push( f );
|
||||
|
||||
},
|
||||
|
||||
run() {
|
||||
|
||||
if ( this.functions.length > 0 ) {
|
||||
|
||||
this.functions.shift()();
|
||||
|
||||
// We can't use |arguments.callee| here because |this| would get
|
||||
// messed-up in that case.
|
||||
setTimeout( () => {
|
||||
|
||||
Q.run();
|
||||
|
||||
}, 0 );
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
// The benchmark itself is factored out into several functions (some of them
|
||||
// generated), which are enqueued and run one by one using |setTimeout|. We
|
||||
// do this for two reasons:
|
||||
//
|
||||
// 1. To avoid bowser mechanism for interrupting long-running scripts to
|
||||
// kick-in (or at least to not kick-in that often).
|
||||
//
|
||||
// 2. To ensure progressive rendering of results in the browser (some
|
||||
// browsers do not render at all when running JavaScript code).
|
||||
//
|
||||
// The enqueued functions share state, which is all stored in the properties
|
||||
// of the |state| object.
|
||||
|
||||
const state = {};
|
||||
|
||||
function initialize() {
|
||||
|
||||
callbacks.start();
|
||||
|
||||
state.totalInputSize = 0;
|
||||
state.totalParseTime = 0;
|
||||
|
||||
// We can't use |arguments.callee| here because |this| would get
|
||||
// messed-up in that case.
|
||||
setTimeout(() => { Q.run(); }, 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// The benchmark itself is factored out into several functions (some of them
|
||||
// generated), which are enqueued and run one by one using |setTimeout|. We
|
||||
// do this for two reasons:
|
||||
//
|
||||
// 1. To avoid bowser mechanism for interrupting long-running scripts to
|
||||
// kick-in (or at least to not kick-in that often).
|
||||
//
|
||||
// 2. To ensure progressive rendering of results in the browser (some
|
||||
// browsers do not render at all when running JavaScript code).
|
||||
//
|
||||
// The enqueued functions share state, which is all stored in the properties
|
||||
// of the |state| object.
|
||||
|
||||
let state = {};
|
||||
|
||||
function initialize() {
|
||||
callbacks.start();
|
||||
|
||||
state.totalInputSize = 0;
|
||||
state.totalParseTime = 0;
|
||||
}
|
||||
|
||||
function benchmarkInitializer(benchmark) {
|
||||
return function() {
|
||||
callbacks.benchmarkStart(benchmark);
|
||||
|
||||
state.parser = peg.generate(
|
||||
callbacks.readFile("../../examples/" + benchmark.id + ".pegjs"),
|
||||
options
|
||||
);
|
||||
state.benchmarkInputSize = 0;
|
||||
state.benchmarkParseTime = 0;
|
||||
};
|
||||
}
|
||||
function benchmarkInitializer( benchmark ) {
|
||||
|
||||
return function () {
|
||||
|
||||
callbacks.benchmarkStart( benchmark );
|
||||
|
||||
function testRunner(benchmark, test) {
|
||||
return function() {
|
||||
callbacks.testStart(benchmark, test);
|
||||
state.parser = peg.generate(
|
||||
callbacks.readFile( "../../examples/" + benchmark.id + ".pegjs" ),
|
||||
options
|
||||
);
|
||||
state.benchmarkInputSize = 0;
|
||||
state.benchmarkParseTime = 0;
|
||||
|
||||
let input = callbacks.readFile(benchmark.id + "/" + test.file);
|
||||
};
|
||||
|
||||
let parseTime = 0;
|
||||
for (let i = 0; i < runCount; i++) {
|
||||
let t = (new Date()).getTime();
|
||||
state.parser.parse(input);
|
||||
parseTime += (new Date()).getTime() - t;
|
||||
}
|
||||
let averageParseTime = parseTime / runCount;
|
||||
|
||||
callbacks.testFinish(benchmark, test, input.length, averageParseTime);
|
||||
function testRunner( benchmark, test ) {
|
||||
|
||||
state.benchmarkInputSize += input.length;
|
||||
state.benchmarkParseTime += averageParseTime;
|
||||
};
|
||||
}
|
||||
return function () {
|
||||
|
||||
function benchmarkFinalizer(benchmark) {
|
||||
return function() {
|
||||
callbacks.benchmarkFinish(
|
||||
benchmark,
|
||||
state.benchmarkInputSize,
|
||||
state.benchmarkParseTime
|
||||
);
|
||||
|
||||
state.totalInputSize += state.benchmarkInputSize;
|
||||
state.totalParseTime += state.benchmarkParseTime;
|
||||
};
|
||||
}
|
||||
callbacks.testStart( benchmark, test );
|
||||
|
||||
function finalize() {
|
||||
callbacks.finish(state.totalInputSize, state.totalParseTime);
|
||||
}
|
||||
const input = callbacks.readFile( benchmark.id + "/" + test.file );
|
||||
|
||||
let parseTime = 0;
|
||||
for ( let i = 0; i < runCount; i++ ) {
|
||||
|
||||
const t = ( new Date() ).getTime();
|
||||
state.parser.parse( input );
|
||||
parseTime += ( new Date() ).getTime() - t;
|
||||
|
||||
// Main
|
||||
}
|
||||
const averageParseTime = parseTime / runCount;
|
||||
|
||||
Q.add(initialize);
|
||||
benchmarks.forEach(benchmark => {
|
||||
Q.add(benchmarkInitializer(benchmark));
|
||||
benchmark.tests.forEach(test => {
|
||||
Q.add(testRunner(benchmark, test));
|
||||
});
|
||||
Q.add(benchmarkFinalizer(benchmark));
|
||||
});
|
||||
Q.add(finalize);
|
||||
callbacks.testFinish( benchmark, test, input.length, averageParseTime );
|
||||
|
||||
Q.run();
|
||||
}
|
||||
state.benchmarkInputSize += input.length;
|
||||
state.benchmarkParseTime += averageParseTime;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
function benchmarkFinalizer( benchmark ) {
|
||||
|
||||
return function () {
|
||||
|
||||
callbacks.benchmarkFinish(
|
||||
benchmark,
|
||||
state.benchmarkInputSize,
|
||||
state.benchmarkParseTime
|
||||
);
|
||||
|
||||
state.totalInputSize += state.benchmarkInputSize;
|
||||
state.totalParseTime += state.benchmarkParseTime;
|
||||
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
function finalize() {
|
||||
|
||||
callbacks.finish( state.totalInputSize, state.totalParseTime );
|
||||
|
||||
}
|
||||
|
||||
// Main
|
||||
|
||||
Q.add( initialize );
|
||||
benchmarks.forEach( benchmark => {
|
||||
|
||||
Q.add( benchmarkInitializer( benchmark ) );
|
||||
benchmark.tests.forEach( test => {
|
||||
|
||||
Q.add( testRunner( benchmark, test ) );
|
||||
|
||||
} );
|
||||
Q.add( benchmarkFinalizer( benchmark ) );
|
||||
|
||||
} );
|
||||
Q.add( finalize );
|
||||
|
||||
Q.run();
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = Runner;
|
||||
|
||||
@ -1,150 +1,179 @@
|
||||
#!/usr/bin/env node
|
||||
|
||||
/* eslint camelcase:0, max-len:0, one-var:0 */
|
||||
|
||||
//
|
||||
// Measures impact of a Git commit (or multiple commits) on generated parsers
|
||||
// speed and size. Makes sense to use only on PEG.js git repository checkout.
|
||||
//
|
||||
|
||||
/* eslint prefer-const: 0 */
|
||||
|
||||
"use strict";
|
||||
|
||||
let child_process = require("child_process");
|
||||
let fs = require("fs");
|
||||
let os = require("os");
|
||||
let path = require("path");
|
||||
let glob = require("glob");
|
||||
const child_process = require( "child_process" );
|
||||
const fs = require( "fs" );
|
||||
const os = require( "os" );
|
||||
const path = require( "path" );
|
||||
const dedent = require( "dedent" );
|
||||
const glob = require( "glob" );
|
||||
|
||||
// Current Working Directory
|
||||
|
||||
let cwd = path.join(__dirname, "..");
|
||||
|
||||
if (process.cwd() !== cwd) {
|
||||
process.chdir(cwd);
|
||||
}
|
||||
const cwd = path.join( __dirname, ".." );
|
||||
if ( process.cwd() !== cwd ) process.chdir( cwd );
|
||||
|
||||
// Execution Files
|
||||
|
||||
let PEGJS_BIN = "bin/peg.js";
|
||||
let BENCHMARK_BIN = "test/benchmark/run";
|
||||
|
||||
if (!fs.existsSync(PEGJS_BIN)) {
|
||||
PEGJS_BIN = "bin/pegjs";
|
||||
if ( ! fs.existsSync( PEGJS_BIN ) ) {
|
||||
|
||||
PEGJS_BIN = "bin/pegjs";
|
||||
|
||||
}
|
||||
|
||||
if (!fs.existsSync(BENCHMARK_BIN)) {
|
||||
BENCHMARK_BIN = "benchmark/run";
|
||||
if ( ! fs.existsSync( BENCHMARK_BIN ) ) {
|
||||
|
||||
BENCHMARK_BIN = "benchmark/run";
|
||||
|
||||
}
|
||||
|
||||
// Utils
|
||||
|
||||
let print = console.log;
|
||||
function echo( message ) {
|
||||
|
||||
process.stdout.write( message );
|
||||
|
||||
function echo(message) {
|
||||
process.stdout.write(message);
|
||||
}
|
||||
|
||||
function exec(command) {
|
||||
return child_process.execSync(command, { encoding: "utf8" });
|
||||
function exec( command ) {
|
||||
|
||||
return child_process.execSync( command, { encoding: "utf8" } );
|
||||
|
||||
}
|
||||
|
||||
function prepare(commit) {
|
||||
exec(`git checkout --quiet "${commit}"`);
|
||||
function prepare( commit ) {
|
||||
|
||||
exec( `git checkout --quiet "${ commit }"` );
|
||||
|
||||
}
|
||||
|
||||
function runBenchmark() {
|
||||
return parseFloat(
|
||||
exec("node " + BENCHMARK_BIN)
|
||||
// Split by table seprator, reverse and return the total bytes per second
|
||||
.split("│")
|
||||
.reverse()[1]
|
||||
// Trim the whitespaces and remove ` kB/s` from the end
|
||||
.trim()
|
||||
.slice(0, -5)
|
||||
);
|
||||
|
||||
return parseFloat(
|
||||
exec( "node " + BENCHMARK_BIN )
|
||||
|
||||
// Split by table seprator, reverse and return the total bytes per second
|
||||
.split( "│" )
|
||||
.reverse()[ 1 ]
|
||||
|
||||
// Trim the whitespaces and remove ` kB/s` from the end
|
||||
.trim()
|
||||
.slice( 0, -5 )
|
||||
);
|
||||
|
||||
}
|
||||
|
||||
function measureSpeed() {
|
||||
return (runBenchmark() + runBenchmark() + runBenchmark() + runBenchmark() + runBenchmark() / 5).toFixed(2);
|
||||
|
||||
return ( runBenchmark() + runBenchmark() + runBenchmark() + runBenchmark() + runBenchmark() / 5 ).toFixed( 2 );
|
||||
|
||||
}
|
||||
|
||||
function measureSize() {
|
||||
let size = 0;
|
||||
|
||||
glob.sync("examples/*.pegjs")
|
||||
.forEach(example => {
|
||||
exec(`node ${PEGJS_BIN} ${example}`);
|
||||
example = example.slice(0, -5) + "js";
|
||||
size += fs.statSync(example).size;
|
||||
fs.unlinkSync(example);
|
||||
});
|
||||
let size = 0;
|
||||
|
||||
glob.sync( "examples/*.pegjs" )
|
||||
.forEach( example => {
|
||||
|
||||
exec( `node ${ PEGJS_BIN } ${ example }` );
|
||||
example = example.slice( 0, -5 ) + "js";
|
||||
size += fs.statSync( example ).size;
|
||||
fs.unlinkSync( example );
|
||||
|
||||
} );
|
||||
|
||||
return size;
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
function difference($1, $2) {
|
||||
return (($2 / $1 - 1) * 100).toFixed(4);
|
||||
function difference( $1, $2 ) {
|
||||
|
||||
return ( ( $2 / $1 - 1 ) * 100 ).toFixed( 4 );
|
||||
|
||||
}
|
||||
|
||||
// Prepare
|
||||
|
||||
let argv = process.argv.slice(2);
|
||||
const argv = process.argv.slice( 2 );
|
||||
let commit_before, commit_after;
|
||||
|
||||
if (argv.length === 1) {
|
||||
commit_before = argv[0] + "~1";
|
||||
commit_after = argv[0];
|
||||
} else if (argv.length === 2) {
|
||||
commit_before = argv[0];
|
||||
commit_after = argv[1];
|
||||
if ( argv.length === 1 ) {
|
||||
|
||||
commit_before = argv[ 0 ] + "~1";
|
||||
commit_after = argv[ 0 ];
|
||||
|
||||
} else if ( argv.length === 2 ) {
|
||||
|
||||
commit_before = argv[ 0 ];
|
||||
commit_after = argv[ 1 ];
|
||||
|
||||
} else {
|
||||
print("Usage:");
|
||||
print("");
|
||||
print(" test/impact <commit>");
|
||||
print(" test/impact <commit_before> <commit_after>");
|
||||
print("");
|
||||
print("Measures impact of a Git commit (or multiple commits) on generated parsers'");
|
||||
print("speed and size. Makes sense to use only on PEG.js Git repository checkout.");
|
||||
print("");
|
||||
process.exit(1);
|
||||
|
||||
console.log( dedent`
|
||||
|
||||
Usage:
|
||||
|
||||
test/impact <commit>
|
||||
test/impact <commit_before> <commit_after>
|
||||
|
||||
Measures impact of a Git commit (or multiple commits) on generated parser's
|
||||
speed and size. Makes sense to use only on PEG.js Git repository checkout.
|
||||
|
||||
` );
|
||||
process.exit( 1 );
|
||||
|
||||
}
|
||||
|
||||
// Measure
|
||||
|
||||
let branch = exec("git rev-parse --abbrev-ref HEAD");
|
||||
const branch = exec( "git rev-parse --abbrev-ref HEAD" );
|
||||
let speed1, size1, speed2, size2;
|
||||
|
||||
echo(`Measuring commit ${commit_before}...`);
|
||||
prepare(commit_before);
|
||||
echo( `Measuring commit ${ commit_before }...` );
|
||||
prepare( commit_before );
|
||||
speed1 = measureSpeed();
|
||||
size1 = measureSize();
|
||||
echo(" OK" + os.EOL);
|
||||
echo( " OK" + os.EOL );
|
||||
|
||||
echo(`Measuring commit ${commit_after}...`);
|
||||
prepare(commit_after);
|
||||
echo( `Measuring commit ${ commit_after }...` );
|
||||
prepare( commit_after );
|
||||
speed2 = measureSpeed();
|
||||
size2 = measureSize();
|
||||
echo(" OK" + os.EOL);
|
||||
echo( " OK" + os.EOL );
|
||||
|
||||
// Finish
|
||||
|
||||
prepare(branch);
|
||||
prepare( branch );
|
||||
|
||||
console.log( dedent`
|
||||
|
||||
test/impact ${ commit_before } ${ commit_after }
|
||||
|
||||
print(`
|
||||
test/impact ${commit_before} ${commit_after}
|
||||
Speed impact
|
||||
------------
|
||||
Before: ${ speed1 } kB/s
|
||||
After: ${ speed2 } kB/s
|
||||
Difference: ${ difference( parseFloat( speed1 ), parseFloat( speed2 ) ) }%
|
||||
|
||||
Speed impact
|
||||
------------
|
||||
Before: ${speed1} kB/s
|
||||
After: ${speed2} kB/s
|
||||
Difference: ${difference(parseFloat(speed1), parseFloat(speed2))}%
|
||||
Size impact
|
||||
-----------
|
||||
Before: ${ size1 } b
|
||||
After: ${ size2 } b
|
||||
Difference: ${ difference( size1, size2 ) }%
|
||||
|
||||
Size impact
|
||||
-----------
|
||||
Before: ${size1} b
|
||||
After: ${size2} b
|
||||
Difference: ${difference(size1, size2)}%
|
||||
- Measured by /test/impact with Node.js ${ process.version }
|
||||
- Your system: ${ os.type() } ${ os.release() } ${ os.arch() }.
|
||||
|
||||
- Measured by /test/impact with Node.js ${process.version}
|
||||
- Your system: ${os.type()} ${os.release()} ${os.arch()}.
|
||||
`);
|
||||
` );
|
||||
|
||||
@ -1,168 +1,216 @@
|
||||
"use strict";
|
||||
|
||||
/* global console */
|
||||
|
||||
let chai = require("chai");
|
||||
let peg = require("../../../lib/peg");
|
||||
let sinon = require("sinon");
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("generated parser API", function() {
|
||||
describe("parse", function() {
|
||||
it("parses input", function() {
|
||||
let parser = peg.generate("start = 'a'");
|
||||
|
||||
expect(parser.parse("a")).to.equal("a");
|
||||
});
|
||||
|
||||
it("throws an exception on syntax error", function() {
|
||||
let parser = peg.generate("start = 'a'");
|
||||
|
||||
expect(() => { parser.parse("b"); }).to.throw();
|
||||
});
|
||||
|
||||
describe("start rule", function() {
|
||||
let parser = peg.generate([
|
||||
"a = 'x' { return 'a'; }",
|
||||
"b = 'x' { return 'b'; }",
|
||||
"c = 'x' { return 'c'; }"
|
||||
].join("\n"), { allowedStartRules: ["b", "c"] });
|
||||
|
||||
describe("when |startRule| is not set", function() {
|
||||
it("starts parsing from the first allowed rule", function() {
|
||||
expect(parser.parse("x")).to.equal("b");
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |startRule| is set to an allowed rule", function() {
|
||||
it("starts parsing from specified rule", function() {
|
||||
expect(parser.parse("x", { startRule: "b" })).to.equal("b");
|
||||
expect(parser.parse("x", { startRule: "c" })).to.equal("c");
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |startRule| is set to a disallowed start rule", function() {
|
||||
it("throws an exception", function() {
|
||||
expect(() => { parser.parse("x", { startRule: "a" }); }).to.throw();
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("tracing", function() {
|
||||
let parser = peg.generate([
|
||||
"start = a / b",
|
||||
"a = 'a'",
|
||||
"b = 'b'"
|
||||
].join("\n"), { trace: true });
|
||||
|
||||
describe("default tracer", function() {
|
||||
it("traces using console.log (if console is defined)", function() {
|
||||
let messages = [
|
||||
"1:1-1:1 rule.enter start",
|
||||
"1:1-1:1 rule.enter a",
|
||||
"1:1-1:1 rule.fail a",
|
||||
"1:1-1:1 rule.enter b",
|
||||
"1:1-1:2 rule.match b",
|
||||
"1:1-1:2 rule.match start"
|
||||
];
|
||||
|
||||
if (typeof console === "object") {
|
||||
sinon.stub(console, "log");
|
||||
}
|
||||
|
||||
try {
|
||||
parser.parse("b");
|
||||
|
||||
if (typeof console === "object") {
|
||||
expect(console.log.callCount).to.equal(messages.length);
|
||||
messages.forEach((message, index) => {
|
||||
let call = console.log.getCall(index);
|
||||
expect(call.calledWithExactly(message)).to.equal(true);
|
||||
});
|
||||
}
|
||||
} finally {
|
||||
if (typeof console === "object") {
|
||||
console.log.restore();
|
||||
}
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("custom tracers", function() {
|
||||
describe("trace", function() {
|
||||
it("receives tracing events", function() {
|
||||
let events = [
|
||||
{
|
||||
type: "rule.enter",
|
||||
rule: "start",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.enter",
|
||||
rule: "a",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.fail",
|
||||
rule: "a",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.enter",
|
||||
rule: "b",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.match",
|
||||
rule: "b",
|
||||
result: "b",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 1, line: 1, column: 2 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.match",
|
||||
rule: "start",
|
||||
result: "b",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 1, line: 1, column: 2 }
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
let tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse("b", { tracer: tracer });
|
||||
|
||||
expect(tracer.trace.callCount).to.equal(events.length);
|
||||
events.forEach((event, index) => {
|
||||
let call = tracer.trace.getCall(index);
|
||||
expect(call.calledWithExactly(event)).to.equal(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
it("accepts custom options", function() {
|
||||
let parser = peg.generate("start = 'a'");
|
||||
|
||||
parser.parse("a", { foo: 42 });
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const peg = require( "../../../lib/peg" );
|
||||
const sinon = require( "sinon" );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "generated parser API", function () {
|
||||
|
||||
describe( "parse", function () {
|
||||
|
||||
it( "parses input", function () {
|
||||
|
||||
const parser = peg.generate( "start = 'a'" );
|
||||
expect( parser.parse( "a" ) ).to.equal( "a" );
|
||||
|
||||
} );
|
||||
|
||||
it( "throws an exception on syntax error", function () {
|
||||
|
||||
const parser = peg.generate( "start = 'a'" );
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "b" );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
describe( "start rule", function () {
|
||||
|
||||
const parser = peg.generate( `
|
||||
|
||||
a = 'x' { return 'a'; }
|
||||
b = 'x' { return 'b'; }
|
||||
c = 'x' { return 'c'; }
|
||||
|
||||
`, { allowedStartRules: [ "b", "c" ] } );
|
||||
|
||||
describe( "when |startRule| is not set", function () {
|
||||
|
||||
it( "starts parsing from the first allowed rule", function () {
|
||||
|
||||
expect( parser.parse( "x" ) ).to.equal( "b" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |startRule| is set to an allowed rule", function () {
|
||||
|
||||
it( "starts parsing from specified rule", function () {
|
||||
|
||||
expect( parser.parse( "x", { startRule: "b" } ) ).to.equal( "b" );
|
||||
expect( parser.parse( "x", { startRule: "c" } ) ).to.equal( "c" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |startRule| is set to a disallowed start rule", function () {
|
||||
|
||||
it( "throws an exception", function () {
|
||||
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "a" } );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "tracing", function () {
|
||||
|
||||
const parser = peg.generate( `
|
||||
|
||||
start = a / b
|
||||
a = 'a'
|
||||
b = 'b'
|
||||
|
||||
`, { trace: true } );
|
||||
|
||||
describe( "default tracer", function () {
|
||||
|
||||
it( "traces using console.log (if console is defined)", function () {
|
||||
|
||||
const messages = [
|
||||
"1:1-1:1 rule.enter start",
|
||||
"1:1-1:1 rule.enter a",
|
||||
"1:1-1:1 rule.fail a",
|
||||
"1:1-1:1 rule.enter b",
|
||||
"1:1-1:2 rule.match b",
|
||||
"1:1-1:2 rule.match start"
|
||||
];
|
||||
|
||||
if ( typeof console === "object" ) sinon.stub( console, "log" );
|
||||
|
||||
try {
|
||||
|
||||
parser.parse( "b" );
|
||||
|
||||
if ( typeof console === "object" ) {
|
||||
|
||||
expect( console.log.callCount ).to.equal( messages.length );
|
||||
messages.forEach( ( message, index ) => {
|
||||
|
||||
const call = console.log.getCall( index );
|
||||
expect( call.calledWithExactly( message ) ).to.equal( true );
|
||||
|
||||
} );
|
||||
|
||||
}
|
||||
|
||||
} finally {
|
||||
|
||||
if ( typeof console === "object" ) console.log.restore();
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "custom tracers", function () {
|
||||
|
||||
describe( "trace", function () {
|
||||
|
||||
it( "receives tracing events", function () {
|
||||
|
||||
const events = [
|
||||
{
|
||||
type: "rule.enter",
|
||||
rule: "start",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.enter",
|
||||
rule: "a",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.fail",
|
||||
rule: "a",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.enter",
|
||||
rule: "b",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 0, line: 1, column: 1 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.match",
|
||||
rule: "b",
|
||||
result: "b",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 1, line: 1, column: 2 }
|
||||
}
|
||||
},
|
||||
{
|
||||
type: "rule.match",
|
||||
rule: "start",
|
||||
result: "b",
|
||||
location: {
|
||||
start: { offset: 0, line: 1, column: 1 },
|
||||
end: { offset: 1, line: 1, column: 2 }
|
||||
}
|
||||
}
|
||||
];
|
||||
|
||||
const tracer = { trace: sinon.spy() };
|
||||
parser.parse( "b", { tracer: tracer } );
|
||||
|
||||
expect( tracer.trace.callCount ).to.equal( events.length );
|
||||
events.forEach( ( event, index ) => {
|
||||
|
||||
const call = tracer.trace.getCall( index );
|
||||
expect( call.calledWithExactly( event ) ).to.equal( true );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "accepts custom options", function () {
|
||||
|
||||
const parser = peg.generate( "start = 'a'" );
|
||||
parser.parse( "a", { foo: 42 } );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,206 +1,319 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let peg = require("../../../lib/peg");
|
||||
let sinon = require("sinon");
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("PEG.js API", function() {
|
||||
describe("generate", function() {
|
||||
it("generates a parser", function() {
|
||||
let parser = peg.generate("start = 'a'");
|
||||
|
||||
expect(parser).to.be.an("object");
|
||||
expect(parser.parse("a")).to.equal("a");
|
||||
});
|
||||
|
||||
it("throws an exception on syntax error", function() {
|
||||
expect(() => { peg.generate("start = @"); }).to.throw();
|
||||
});
|
||||
|
||||
it("throws an exception on semantic error", function() {
|
||||
expect(() => { peg.generate("start = undefined"); }).to.throw();
|
||||
});
|
||||
|
||||
describe("allowed start rules", function() {
|
||||
let grammar = [
|
||||
"a = 'x'",
|
||||
"b = 'x'",
|
||||
"c = 'x'"
|
||||
].join("\n");
|
||||
|
||||
it("throws an error on missing rule", function() {
|
||||
expect(() => peg.generate(grammar, {
|
||||
allowedStartRules: ["missing"]
|
||||
})).to.throw();
|
||||
});
|
||||
|
||||
// The |allowedStartRules| option is implemented separately for each
|
||||
// optimization mode, so we need to test it in both.
|
||||
|
||||
describe("when optimizing for parsing speed", function() {
|
||||
describe("when |allowedStartRules| is not set", function() {
|
||||
it("generated parser can start only from the first rule", function() {
|
||||
let parser = peg.generate(grammar, { optimize: "speed" });
|
||||
|
||||
expect(parser.parse("x", { startRule: "a" })).to.equal("x");
|
||||
expect(() => { parser.parse("x", { startRule: "b" }); }).to.throw();
|
||||
expect(() => { parser.parse("x", { startRule: "c" }); }).to.throw();
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |allowedStartRules| is set", function() {
|
||||
it("generated parser can start only from specified rules", function() {
|
||||
let parser = peg.generate(grammar, {
|
||||
optimize: "speed",
|
||||
allowedStartRules: ["b", "c"]
|
||||
});
|
||||
|
||||
expect(() => { parser.parse("x", { startRule: "a" }); }).to.throw();
|
||||
expect(parser.parse("x", { startRule: "b" })).to.equal("x");
|
||||
expect(parser.parse("x", { startRule: "c" })).to.equal("x");
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("when optimizing for code size", function() {
|
||||
describe("when |allowedStartRules| is not set", function() {
|
||||
it("generated parser can start only from the first rule", function() {
|
||||
let parser = peg.generate(grammar, { optimize: "size" });
|
||||
|
||||
expect(parser.parse("x", { startRule: "a" })).to.equal("x");
|
||||
expect(() => { parser.parse("x", { startRule: "b" }); }).to.throw();
|
||||
expect(() => { parser.parse("x", { startRule: "c" }); }).to.throw();
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |allowedStartRules| is set", function() {
|
||||
it("generated parser can start only from specified rules", function() {
|
||||
let parser = peg.generate(grammar, {
|
||||
optimize: "size",
|
||||
allowedStartRules: ["b", "c"]
|
||||
});
|
||||
|
||||
expect(() => { parser.parse("x", { startRule: "a" }); }).to.throw();
|
||||
expect(parser.parse("x", { startRule: "b" })).to.equal("x");
|
||||
expect(parser.parse("x", { startRule: "c" })).to.equal("x");
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("intermediate results caching", function() {
|
||||
let grammar = [
|
||||
"{ var n = 0; }",
|
||||
"start = (a 'b') / (a 'c') { return n; }",
|
||||
"a = 'a' { n++; }"
|
||||
].join("\n");
|
||||
|
||||
describe("when |cache| is not set", function() {
|
||||
it("generated parser doesn't cache intermediate parse results", function() {
|
||||
let parser = peg.generate(grammar);
|
||||
|
||||
expect(parser.parse("ac")).to.equal(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |cache| is set to |false|", function() {
|
||||
it("generated parser doesn't cache intermediate parse results", function() {
|
||||
let parser = peg.generate(grammar, { cache: false });
|
||||
|
||||
expect(parser.parse("ac")).to.equal(2);
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |cache| is set to |true|", function() {
|
||||
it("generated parser caches intermediate parse results", function() {
|
||||
let parser = peg.generate(grammar, { cache: true });
|
||||
|
||||
expect(parser.parse("ac")).to.equal(1);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
describe("tracing", function() {
|
||||
let grammar = "start = 'a'";
|
||||
|
||||
describe("when |trace| is not set", function() {
|
||||
it("generated parser doesn't trace", function() {
|
||||
let parser = peg.generate(grammar);
|
||||
let tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse("a", { tracer: tracer });
|
||||
|
||||
expect(tracer.trace.called).to.equal(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |trace| is set to |false|", function() {
|
||||
it("generated parser doesn't trace", function() {
|
||||
let parser = peg.generate(grammar, { trace: false });
|
||||
let tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse("a", { tracer: tracer });
|
||||
|
||||
expect(tracer.trace.called).to.equal(false);
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |trace| is set to |true|", function() {
|
||||
it("generated parser traces", function() {
|
||||
let parser = peg.generate(grammar, { trace: true });
|
||||
let tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse("a", { tracer: tracer });
|
||||
|
||||
expect(tracer.trace.called).to.equal(true);
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// The |optimize| option isn't tested because there is no meaningful way to
|
||||
// write the tests without turning this into a performance test.
|
||||
|
||||
describe("output", function() {
|
||||
let grammar = "start = 'a'";
|
||||
|
||||
describe("when |output| is not set", function() {
|
||||
it("returns generated parser object", function() {
|
||||
let parser = peg.generate(grammar);
|
||||
|
||||
expect(parser).to.be.an("object");
|
||||
expect(parser.parse("a")).to.equal("a");
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |output| is set to |\"parser\"|", function() {
|
||||
it("returns generated parser object", function() {
|
||||
let parser = peg.generate(grammar, { output: "parser" });
|
||||
|
||||
expect(parser).to.be.an("object");
|
||||
expect(parser.parse("a")).to.equal("a");
|
||||
});
|
||||
});
|
||||
|
||||
describe("when |output| is set to |\"source\"|", function() {
|
||||
it("returns generated parser source code", function() {
|
||||
let source = peg.generate(grammar, { output: "source" });
|
||||
|
||||
expect(source).to.be.a("string");
|
||||
expect(eval(source).parse("a")).to.equal("a");
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
// The |format|, |exportVars|, and |dependencies| options are not tested
|
||||
// becasue there is no meaningful way to thest their effects without turning
|
||||
// this into an integration test.
|
||||
const chai = require( "chai" );
|
||||
const peg = require( "../../../lib/peg" );
|
||||
const sinon = require( "sinon" );
|
||||
|
||||
// The |plugins| option is tested in plugin API tests.
|
||||
const expect = chai.expect;
|
||||
|
||||
it("accepts custom options", function() {
|
||||
peg.generate("start = 'a'", { foo: 42 });
|
||||
});
|
||||
});
|
||||
});
|
||||
describe( "PEG.js API", function () {
|
||||
|
||||
describe( "generate", function () {
|
||||
|
||||
it( "generates a parser", function () {
|
||||
|
||||
const parser = peg.generate( "start = 'a'" );
|
||||
|
||||
expect( parser ).to.be.an( "object" );
|
||||
expect( parser.parse( "a" ) ).to.equal( "a" );
|
||||
|
||||
} );
|
||||
|
||||
it( "throws an exception on syntax error", function () {
|
||||
|
||||
expect( () => {
|
||||
|
||||
peg.generate( "start = @" );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
it( "throws an exception on semantic error", function () {
|
||||
|
||||
expect( () => {
|
||||
|
||||
peg.generate( "start = undefined" );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
describe( "allowed start rules", function () {
|
||||
|
||||
const grammar = `
|
||||
|
||||
a = 'x'
|
||||
b = 'x'
|
||||
c = 'x'
|
||||
|
||||
`;
|
||||
|
||||
it( "throws an error on missing rule", function () {
|
||||
|
||||
expect( () => {
|
||||
|
||||
peg.generate( grammar, { allowedStartRules: [ "missing" ] } );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
// The |allowedStartRules| option is implemented separately for each
|
||||
// optimization mode, so we need to test it in both.
|
||||
|
||||
describe( "when optimizing for parsing speed", function () {
|
||||
|
||||
describe( "when |allowedStartRules| is not set", function () {
|
||||
|
||||
it( "generated parser can start only from the first rule", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { optimize: "speed" } );
|
||||
|
||||
expect( parser.parse( "x", { startRule: "a" } ) ).to.equal( "x" );
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "b" } );
|
||||
|
||||
} ).to.throw();
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "c" } );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |allowedStartRules| is set", function () {
|
||||
|
||||
it( "generated parser can start only from specified rules", function () {
|
||||
|
||||
const parser = peg.generate( grammar, {
|
||||
optimize: "speed",
|
||||
allowedStartRules: [ "b", "c" ]
|
||||
} );
|
||||
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "a" } );
|
||||
|
||||
} ).to.throw();
|
||||
expect( parser.parse( "x", { startRule: "b" } ) ).to.equal( "x" );
|
||||
expect( parser.parse( "x", { startRule: "c" } ) ).to.equal( "x" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when optimizing for code size", function () {
|
||||
|
||||
describe( "when |allowedStartRules| is not set", function () {
|
||||
|
||||
it( "generated parser can start only from the first rule", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { optimize: "size" } );
|
||||
|
||||
expect( parser.parse( "x", { startRule: "a" } ) ).to.equal( "x" );
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "b" } );
|
||||
|
||||
} ).to.throw();
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "c" } );
|
||||
|
||||
} ).to.throw();
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |allowedStartRules| is set", function () {
|
||||
|
||||
it( "generated parser can start only from specified rules", function () {
|
||||
|
||||
const parser = peg.generate( grammar, {
|
||||
optimize: "size",
|
||||
allowedStartRules: [ "b", "c" ]
|
||||
} );
|
||||
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "a" } );
|
||||
|
||||
} ).to.throw();
|
||||
expect( parser.parse( "x", { startRule: "b" } ) ).to.equal( "x" );
|
||||
expect( parser.parse( "x", { startRule: "c" } ) ).to.equal( "x" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "intermediate results caching", function () {
|
||||
|
||||
const grammar = `
|
||||
|
||||
{ var n = 0; }
|
||||
start = (a 'b') / (a 'c') { return n; }
|
||||
a = 'a' { n++; }
|
||||
|
||||
`;
|
||||
|
||||
describe( "when |cache| is not set", function () {
|
||||
|
||||
it( "generated parser doesn't cache intermediate parse results", function () {
|
||||
|
||||
const parser = peg.generate( grammar );
|
||||
expect( parser.parse( "ac" ) ).to.equal( 2 );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |cache| is set to |false|", function () {
|
||||
|
||||
it( "generated parser doesn't cache intermediate parse results", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { cache: false } );
|
||||
expect( parser.parse( "ac" ) ).to.equal( 2 );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |cache| is set to |true|", function () {
|
||||
|
||||
it( "generated parser caches intermediate parse results", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { cache: true } );
|
||||
expect( parser.parse( "ac" ) ).to.equal( 1 );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "tracing", function () {
|
||||
|
||||
const grammar = "start = 'a'";
|
||||
|
||||
describe( "when |trace| is not set", function () {
|
||||
|
||||
it( "generated parser doesn't trace", function () {
|
||||
|
||||
const parser = peg.generate( grammar );
|
||||
const tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse( "a", { tracer: tracer } );
|
||||
|
||||
expect( tracer.trace.called ).to.equal( false );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |trace| is set to |false|", function () {
|
||||
|
||||
it( "generated parser doesn't trace", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { trace: false } );
|
||||
const tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse( "a", { tracer: tracer } );
|
||||
|
||||
expect( tracer.trace.called ).to.equal( false );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |trace| is set to |true|", function () {
|
||||
|
||||
it( "generated parser traces", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { trace: true } );
|
||||
const tracer = { trace: sinon.spy() };
|
||||
|
||||
parser.parse( "a", { tracer: tracer } );
|
||||
|
||||
expect( tracer.trace.called ).to.equal( true );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
// The |optimize| option isn't tested because there is no meaningful way to
|
||||
// write the tests without turning this into a performance test.
|
||||
|
||||
describe( "output", function () {
|
||||
|
||||
const grammar = "start = 'a'";
|
||||
|
||||
describe( "when |output| is not set", function () {
|
||||
|
||||
it( "returns generated parser object", function () {
|
||||
|
||||
const parser = peg.generate( grammar );
|
||||
|
||||
expect( parser ).to.be.an( "object" );
|
||||
expect( parser.parse( "a" ) ).to.equal( "a" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |output| is set to |\"parser\"|", function () {
|
||||
|
||||
it( "returns generated parser object", function () {
|
||||
|
||||
const parser = peg.generate( grammar, { output: "parser" } );
|
||||
|
||||
expect( parser ).to.be.an( "object" );
|
||||
expect( parser.parse( "a" ) ).to.equal( "a" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when |output| is set to |\"source\"|", function () {
|
||||
|
||||
it( "returns generated parser source code", function () {
|
||||
|
||||
const source = peg.generate( grammar, { output: "source" } );
|
||||
|
||||
expect( source ).to.be.a( "string" );
|
||||
expect( eval( source ).parse( "a" ) ).to.equal( "a" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
// The |format|, |exportVars|, and |dependencies| options are not tested
|
||||
// becasue there is no meaningful way to thest their effects without turning
|
||||
// this into an integration test.
|
||||
|
||||
// The |plugins| option is tested in plugin API tests.
|
||||
|
||||
it( "accepts custom options", function () {
|
||||
|
||||
peg.generate( "start = 'a'", { foo: 42 } );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,128 +1,185 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let peg = require("../../../lib/peg");
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("plugin API", function() {
|
||||
describe("use", function() {
|
||||
let grammar = "start = 'a'";
|
||||
|
||||
it("is called for each plugin", function() {
|
||||
let pluginsUsed = [false, false, false];
|
||||
let plugins = [
|
||||
{ use() { pluginsUsed[0] = true; } },
|
||||
{ use() { pluginsUsed[1] = true; } },
|
||||
{ use() { pluginsUsed[2] = true; } }
|
||||
];
|
||||
|
||||
peg.generate(grammar, { plugins: plugins });
|
||||
|
||||
expect(pluginsUsed).to.deep.equal([true, true, true]);
|
||||
});
|
||||
|
||||
it("receives configuration", function() {
|
||||
let plugin = {
|
||||
use(config) {
|
||||
expect(config).to.be.an("object");
|
||||
|
||||
expect(config.parser).to.be.an("object");
|
||||
expect(config.parser.parse("start = 'a'")).to.be.an("object");
|
||||
|
||||
expect(config.passes).to.be.an("object");
|
||||
|
||||
expect(config.passes.check).to.be.an("array");
|
||||
config.passes.check.forEach(pass => {
|
||||
expect(pass).to.be.a("function");
|
||||
});
|
||||
|
||||
expect(config.passes.transform).to.be.an("array");
|
||||
config.passes.transform.forEach(pass => {
|
||||
expect(pass).to.be.a("function");
|
||||
});
|
||||
|
||||
expect(config.passes.generate).to.be.an("array");
|
||||
config.passes.generate.forEach(pass => {
|
||||
expect(pass).to.be.a("function");
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
peg.generate(grammar, { plugins: [plugin] });
|
||||
});
|
||||
|
||||
it("receives options", function() {
|
||||
let plugin = {
|
||||
use(config, options) {
|
||||
expect(options).to.equal(generateOptions);
|
||||
}
|
||||
};
|
||||
let generateOptions = { plugins: [plugin], foo: 42 };
|
||||
|
||||
peg.generate(grammar, generateOptions);
|
||||
});
|
||||
|
||||
it("can replace parser", function() {
|
||||
let plugin = {
|
||||
use(config) {
|
||||
let parser = peg.generate([
|
||||
"start = .* {",
|
||||
" return {",
|
||||
" type: 'grammar',",
|
||||
" rules: [",
|
||||
" {",
|
||||
" type: 'rule',",
|
||||
" name: 'start',",
|
||||
" expression: { type: 'literal', value: text(), ignoreCase: false }",
|
||||
" }",
|
||||
" ]",
|
||||
" };",
|
||||
"}"
|
||||
].join("\n"));
|
||||
|
||||
config.parser = parser;
|
||||
}
|
||||
};
|
||||
let parser = peg.generate("a", { plugins: [plugin] });
|
||||
|
||||
expect(parser.parse("a")).to.equal("a");
|
||||
});
|
||||
|
||||
it("can change compiler passes", function() {
|
||||
let plugin = {
|
||||
use(config) {
|
||||
function pass(ast) {
|
||||
ast.code = "({ parse: function() { return 42; } })";
|
||||
}
|
||||
|
||||
config.passes.generate = [pass];
|
||||
}
|
||||
};
|
||||
let parser = peg.generate(grammar, { plugins: [plugin] });
|
||||
|
||||
expect(parser.parse("a")).to.equal(42);
|
||||
});
|
||||
|
||||
it("can change options", function() {
|
||||
let grammar = [
|
||||
"a = 'x'",
|
||||
"b = 'x'",
|
||||
"c = 'x'"
|
||||
].join("\n");
|
||||
let plugin = {
|
||||
use(config, options) {
|
||||
options.allowedStartRules = ["b", "c"];
|
||||
}
|
||||
};
|
||||
let parser = peg.generate(grammar, {
|
||||
allowedStartRules: ["a"],
|
||||
plugins: [plugin]
|
||||
});
|
||||
|
||||
expect(() => { parser.parse("x", { startRule: "a" }); }).to.throw();
|
||||
expect(parser.parse("x", { startRule: "b" })).to.equal("x");
|
||||
expect(parser.parse("x", { startRule: "c" })).to.equal("x");
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const peg = require( "../../../lib/peg" );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "plugin API", function () {
|
||||
|
||||
describe( "use", function () {
|
||||
|
||||
const grammar = "start = 'a'";
|
||||
|
||||
it( "is called for each plugin", function () {
|
||||
|
||||
const pluginsUsed = [ false, false, false ];
|
||||
const plugins = [
|
||||
{ use() {
|
||||
|
||||
pluginsUsed[ 0 ] = true;
|
||||
|
||||
} },
|
||||
{ use() {
|
||||
|
||||
pluginsUsed[ 1 ] = true;
|
||||
|
||||
} },
|
||||
{ use() {
|
||||
|
||||
pluginsUsed[ 2 ] = true;
|
||||
|
||||
} }
|
||||
];
|
||||
|
||||
peg.generate( grammar, { plugins: plugins } );
|
||||
|
||||
expect( pluginsUsed ).to.deep.equal( [ true, true, true ] );
|
||||
|
||||
} );
|
||||
|
||||
it( "receives configuration", function () {
|
||||
|
||||
const plugin = {
|
||||
use( config ) {
|
||||
|
||||
expect( config ).to.be.an( "object" );
|
||||
|
||||
expect( config.parser ).to.be.an( "object" );
|
||||
expect( config.parser.parse( "start = 'a'" ) ).to.be.an( "object" );
|
||||
|
||||
expect( config.passes ).to.be.an( "object" );
|
||||
|
||||
expect( config.passes.check ).to.be.an( "array" );
|
||||
config.passes.check.forEach( pass => {
|
||||
|
||||
expect( pass ).to.be.a( "function" );
|
||||
|
||||
} );
|
||||
|
||||
expect( config.passes.transform ).to.be.an( "array" );
|
||||
config.passes.transform.forEach( pass => {
|
||||
|
||||
expect( pass ).to.be.a( "function" );
|
||||
|
||||
} );
|
||||
|
||||
expect( config.passes.generate ).to.be.an( "array" );
|
||||
config.passes.generate.forEach( pass => {
|
||||
|
||||
expect( pass ).to.be.a( "function" );
|
||||
|
||||
} );
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
peg.generate( grammar, { plugins: [ plugin ] } );
|
||||
|
||||
} );
|
||||
|
||||
it( "receives options", function () {
|
||||
|
||||
const generateOptions = {
|
||||
plugins: [ {
|
||||
use( config, options ) {
|
||||
|
||||
expect( options ).to.equal( generateOptions );
|
||||
|
||||
}
|
||||
} ],
|
||||
foo: 42
|
||||
};
|
||||
|
||||
peg.generate( grammar, generateOptions );
|
||||
|
||||
} );
|
||||
|
||||
it( "can replace parser", function () {
|
||||
|
||||
const plugin = {
|
||||
use( config ) {
|
||||
|
||||
config.parser = peg.generate( `
|
||||
|
||||
start = .* {
|
||||
return {
|
||||
type: 'grammar',
|
||||
rules: [{
|
||||
type: 'rule',
|
||||
name: 'start',
|
||||
expression: {
|
||||
type: 'literal',
|
||||
value: text(),
|
||||
ignoreCase: false
|
||||
}
|
||||
}]
|
||||
};
|
||||
}
|
||||
|
||||
` );
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
const parser = peg.generate( "a", { plugins: [ plugin ] } );
|
||||
expect( parser.parse( "a" ) ).to.equal( "a" );
|
||||
|
||||
} );
|
||||
|
||||
it( "can change compiler passes", function () {
|
||||
|
||||
const plugin = {
|
||||
use( config ) {
|
||||
|
||||
function pass( ast ) {
|
||||
|
||||
ast.code = "({ parse: function() { return 42; } })";
|
||||
|
||||
}
|
||||
|
||||
config.passes.generate = [ pass ];
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
const parser = peg.generate( grammar, { plugins: [ plugin ] } );
|
||||
expect( parser.parse( "a" ) ).to.equal( 42 );
|
||||
|
||||
} );
|
||||
|
||||
it( "can change options", function () {
|
||||
|
||||
const grammar = `
|
||||
|
||||
a = 'x'
|
||||
b = 'x'
|
||||
c = 'x'
|
||||
|
||||
`;
|
||||
const plugin = {
|
||||
use( config, options ) {
|
||||
|
||||
options.allowedStartRules = [ "b", "c" ];
|
||||
|
||||
}
|
||||
};
|
||||
|
||||
const parser = peg.generate( grammar, {
|
||||
allowedStartRules: [ "a" ],
|
||||
plugins: [ plugin ]
|
||||
} );
|
||||
|
||||
expect( () => {
|
||||
|
||||
parser.parse( "x", { startRule: "a" } );
|
||||
|
||||
} ).to.throw();
|
||||
expect( parser.parse( "x", { startRule: "b" } ) ).to.equal( "x" );
|
||||
expect( parser.parse( "x", { startRule: "c" } ) ).to.equal( "x" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -1,90 +1,112 @@
|
||||
"use strict";
|
||||
|
||||
let parser = require("../../../../../lib/parser");
|
||||
const parser = require( "../../../../../lib/parser" );
|
||||
|
||||
module.exports = function(chai, utils) {
|
||||
let Assertion = chai.Assertion;
|
||||
module.exports = function ( chai, utils ) {
|
||||
|
||||
Assertion.addMethod("changeAST", function(grammar, props, options) {
|
||||
options = options !== undefined ? options : {};
|
||||
const Assertion = chai.Assertion;
|
||||
|
||||
function matchProps(value, props) {
|
||||
function isArray(value) {
|
||||
return Object.prototype.toString.apply(value) === "[object Array]";
|
||||
}
|
||||
Assertion.addMethod( "changeAST", function ( grammar, props, options ) {
|
||||
|
||||
function isObject(value) {
|
||||
return value !== null && typeof value === "object";
|
||||
}
|
||||
options = typeof options !== "undefined" ? options : {};
|
||||
|
||||
if (isArray(props)) {
|
||||
if (!isArray(value)) { return false; }
|
||||
function matchProps( value, props ) {
|
||||
|
||||
function isObject( value ) {
|
||||
|
||||
return value !== null && typeof value === "object";
|
||||
|
||||
}
|
||||
|
||||
if ( Array.isArray( props ) ) {
|
||||
|
||||
if ( ! Array.isArray( value ) ) return false;
|
||||
if ( value.length !== props.length ) return false;
|
||||
|
||||
for ( let i = 0; i < props.length; i++ ) {
|
||||
|
||||
if ( ! matchProps( value[ i ], props[ i ] ) ) return false;
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
} else if ( isObject( props ) ) {
|
||||
|
||||
if ( ! isObject( value ) ) return false;
|
||||
|
||||
const keys = Object.keys( props );
|
||||
for ( let i = 0; i < keys.length; i++ ) {
|
||||
|
||||
const key = keys[ i ];
|
||||
|
||||
if ( ! ( key in value ) ) return false;
|
||||
if ( ! matchProps( value[ key ], props[ key ] ) ) return false;
|
||||
|
||||
}
|
||||
|
||||
return true;
|
||||
|
||||
}
|
||||
|
||||
return value === props;
|
||||
|
||||
if (value.length !== props.length) { return false; }
|
||||
for (let i = 0; i < props.length; i++) {
|
||||
if (!matchProps(value[i], props[i])) { return false; }
|
||||
}
|
||||
|
||||
return true;
|
||||
} else if (isObject(props)) {
|
||||
if (!isObject(value)) { return false; }
|
||||
const ast = parser.parse( grammar );
|
||||
|
||||
let keys = Object.keys(props);
|
||||
for (let i = 0; i < keys.length; i++) {
|
||||
let key = keys[i];
|
||||
utils.flag( this, "object" )( ast, options );
|
||||
|
||||
if (!(key in value)) { return false; }
|
||||
this.assert(
|
||||
matchProps( ast, props ),
|
||||
"expected #{this} to change the AST to match #{exp}",
|
||||
"expected #{this} to not change the AST to match #{exp}",
|
||||
props,
|
||||
ast
|
||||
);
|
||||
|
||||
} );
|
||||
|
||||
Assertion.addMethod( "reportError", function ( grammar, props, options ) {
|
||||
|
||||
options = typeof options !== "undefined" ? options : {};
|
||||
|
||||
const ast = parser.parse( grammar );
|
||||
|
||||
let passed, result;
|
||||
|
||||
try {
|
||||
|
||||
utils.flag( this, "object" )( ast, options );
|
||||
passed = true;
|
||||
|
||||
} catch ( e ) {
|
||||
|
||||
result = e;
|
||||
passed = false;
|
||||
|
||||
if (!matchProps(value[key], props[key])) { return false; }
|
||||
}
|
||||
|
||||
return true;
|
||||
} else {
|
||||
return value === props;
|
||||
}
|
||||
}
|
||||
|
||||
let ast = parser.parse(grammar);
|
||||
|
||||
utils.flag(this, "object")(ast, options);
|
||||
|
||||
this.assert(
|
||||
matchProps(ast, props),
|
||||
"expected #{this} to change the AST to match #{exp}",
|
||||
"expected #{this} to not change the AST to match #{exp}",
|
||||
props,
|
||||
ast
|
||||
);
|
||||
});
|
||||
|
||||
Assertion.addMethod("reportError", function(grammar, props, options) {
|
||||
options = options !== undefined ? options : {};
|
||||
|
||||
let ast = parser.parse(grammar);
|
||||
|
||||
let passed, result;
|
||||
|
||||
try {
|
||||
utils.flag(this, "object")(ast, options);
|
||||
passed = true;
|
||||
} catch (e) {
|
||||
result = e;
|
||||
passed = false;
|
||||
}
|
||||
|
||||
this.assert(
|
||||
!passed,
|
||||
"expected #{this} to report an error but it didn't",
|
||||
"expected #{this} to not report an error but #{act} was reported",
|
||||
null,
|
||||
result
|
||||
);
|
||||
|
||||
if (!passed && props !== undefined) {
|
||||
Object.keys(props).forEach(key => {
|
||||
new Assertion(result).to.have.property(key)
|
||||
.that.is.deep.equal(props[key]);
|
||||
});
|
||||
}
|
||||
});
|
||||
this.assert(
|
||||
! passed,
|
||||
"expected #{this} to report an error but it didn't",
|
||||
"expected #{this} to not report an error but #{act} was reported",
|
||||
null,
|
||||
result
|
||||
);
|
||||
|
||||
if ( ! passed && typeof props !== "undefined" ) {
|
||||
|
||||
Object.keys( props ).forEach( key => {
|
||||
|
||||
new Assertion( result )
|
||||
.to.have.property( key )
|
||||
.that.is.deep.equal( props[ key ] );
|
||||
|
||||
} );
|
||||
|
||||
}
|
||||
|
||||
} );
|
||||
|
||||
};
|
||||
|
||||
@ -1,59 +1,69 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let helpers = require("./helpers");
|
||||
let pass = require("../../../../../lib/compiler/passes/remove-proxy-rules");
|
||||
|
||||
chai.use(helpers);
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("compiler pass |removeProxyRules|", function() {
|
||||
describe("when a proxy rule isn't listed in |allowedStartRules|", function() {
|
||||
it("updates references and removes it", function() {
|
||||
expect(pass).to.changeAST(
|
||||
[
|
||||
"start = proxy",
|
||||
"proxy = proxied",
|
||||
"proxied = 'a'"
|
||||
].join("\n"),
|
||||
{
|
||||
rules: [
|
||||
{
|
||||
name: "start",
|
||||
expression: { type: "rule_ref", name: "proxied" }
|
||||
},
|
||||
{ name: "proxied" }
|
||||
]
|
||||
},
|
||||
{ allowedStartRules: ["start"] }
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe("when a proxy rule is listed in |allowedStartRules|", function() {
|
||||
it("updates references but doesn't remove it", function() {
|
||||
expect(pass).to.changeAST(
|
||||
[
|
||||
"start = proxy",
|
||||
"proxy = proxied",
|
||||
"proxied = 'a'"
|
||||
].join("\n"),
|
||||
{
|
||||
rules: [
|
||||
{
|
||||
name: "start",
|
||||
expression: { type: "rule_ref", name: "proxied" }
|
||||
},
|
||||
{
|
||||
name: "proxy",
|
||||
expression: { type: "rule_ref", name: "proxied" }
|
||||
},
|
||||
{ name: "proxied" }
|
||||
]
|
||||
},
|
||||
{ allowedStartRules: ["start", "proxy"] }
|
||||
);
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const helpers = require( "./helpers" );
|
||||
const pass = require( "../../../../../lib/compiler/passes/remove-proxy-rules" );
|
||||
|
||||
chai.use( helpers );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "compiler pass |removeProxyRules|", function () {
|
||||
|
||||
describe( "when a proxy rule isn't listed in |allowedStartRules|", function () {
|
||||
|
||||
it( "updates references and removes it", function () {
|
||||
|
||||
expect( pass ).to.changeAST(
|
||||
[
|
||||
"start = proxy",
|
||||
"proxy = proxied",
|
||||
"proxied = 'a'"
|
||||
].join( "\n" ),
|
||||
{
|
||||
rules: [
|
||||
{
|
||||
name: "start",
|
||||
expression: { type: "rule_ref", name: "proxied" }
|
||||
},
|
||||
{ name: "proxied" }
|
||||
]
|
||||
},
|
||||
{ allowedStartRules: [ "start" ] }
|
||||
);
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "when a proxy rule is listed in |allowedStartRules|", function () {
|
||||
|
||||
it( "updates references but doesn't remove it", function () {
|
||||
|
||||
expect( pass ).to.changeAST(
|
||||
[
|
||||
"start = proxy",
|
||||
"proxy = proxied",
|
||||
"proxied = 'a'"
|
||||
].join( "\n" ),
|
||||
{
|
||||
rules: [
|
||||
{
|
||||
name: "start",
|
||||
expression: { type: "rule_ref", name: "proxied" }
|
||||
},
|
||||
{
|
||||
name: "proxy",
|
||||
expression: { type: "rule_ref", name: "proxied" }
|
||||
},
|
||||
{ name: "proxied" }
|
||||
]
|
||||
},
|
||||
{ allowedStartRules: [ "start", "proxy" ] }
|
||||
);
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,63 +1,83 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let helpers = require("./helpers");
|
||||
let pass = require("../../../../../lib/compiler/passes/report-duplicate-labels");
|
||||
|
||||
chai.use(helpers);
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("compiler pass |reportDuplicateLabels|", function() {
|
||||
describe("in a sequence", function() {
|
||||
it("reports labels duplicate with labels of preceding elements", function() {
|
||||
expect(pass).to.reportError("start = a:'a' a:'a'", {
|
||||
message: "Label \"a\" is already defined at line 1, column 9.",
|
||||
location: {
|
||||
start: { offset: 14, line: 1, column: 15 },
|
||||
end: { offset: 19, line: 1, column: 20 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("doesn't report labels duplicate with labels in subexpressions", function() {
|
||||
expect(pass).to.not.reportError("start = ('a' / a:'a' / 'a') a:'a'");
|
||||
expect(pass).to.not.reportError("start = (a:'a' { }) a:'a'");
|
||||
expect(pass).to.not.reportError("start = ('a' a:'a' 'a') a:'a'");
|
||||
expect(pass).to.not.reportError("start = b:(a:'a') a:'a'");
|
||||
expect(pass).to.not.reportError("start = $(a:'a') a:'a'");
|
||||
expect(pass).to.not.reportError("start = &(a:'a') a:'a'");
|
||||
expect(pass).to.not.reportError("start = !(a:'a') a:'a'");
|
||||
expect(pass).to.not.reportError("start = (a:'a')? a:'a'");
|
||||
expect(pass).to.not.reportError("start = (a:'a')* a:'a'");
|
||||
expect(pass).to.not.reportError("start = (a:'a')+ a:'a'");
|
||||
expect(pass).to.not.reportError("start = (a:'a') a:'a'");
|
||||
});
|
||||
});
|
||||
|
||||
describe("in a choice", function() {
|
||||
it("doesn't report labels duplicate with labels of preceding alternatives", function() {
|
||||
expect(pass).to.not.reportError("start = a:'a' / a:'a'");
|
||||
});
|
||||
});
|
||||
|
||||
describe("in outer sequence", function() {
|
||||
it("reports labels duplicate with labels of preceding elements", function() {
|
||||
expect(pass).to.reportError("start = a:'a' (a:'a')", {
|
||||
message: "Label \"a\" is already defined at line 1, column 9.",
|
||||
location: {
|
||||
start: { offset: 15, line: 1, column: 16 },
|
||||
end: { offset: 20, line: 1, column: 21 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("doesn't report labels duplicate with the label of the current element", function() {
|
||||
expect(pass).to.not.reportError("start = a:(a:'a')");
|
||||
});
|
||||
|
||||
it("doesn't report labels duplicate with labels of following elements", function() {
|
||||
expect(pass).to.not.reportError("start = (a:'a') a:'a'");
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const helpers = require( "./helpers" );
|
||||
const pass = require( "../../../../../lib/compiler/passes/report-duplicate-labels" );
|
||||
|
||||
chai.use( helpers );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "compiler pass |reportDuplicateLabels|", function () {
|
||||
|
||||
describe( "in a sequence", function () {
|
||||
|
||||
it( "reports labels duplicate with labels of preceding elements", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = a:'a' a:'a'", {
|
||||
message: "Label \"a\" is already defined at line 1, column 9.",
|
||||
location: {
|
||||
start: { offset: 14, line: 1, column: 15 },
|
||||
end: { offset: 19, line: 1, column: 20 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "doesn't report labels duplicate with labels in subexpressions", function () {
|
||||
|
||||
expect( pass ).to.not.reportError( "start = ('a' / a:'a' / 'a') a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = (a:'a' { }) a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' a:'a' 'a') a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = b:(a:'a') a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = $(a:'a') a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = &(a:'a') a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = !(a:'a') a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = (a:'a')? a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = (a:'a')* a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = (a:'a')+ a:'a'" );
|
||||
expect( pass ).to.not.reportError( "start = (a:'a') a:'a'" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "in a choice", function () {
|
||||
|
||||
it( "doesn't report labels duplicate with labels of preceding alternatives", function () {
|
||||
|
||||
expect( pass ).to.not.reportError( "start = a:'a' / a:'a'" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "in outer sequence", function () {
|
||||
|
||||
it( "reports labels duplicate with labels of preceding elements", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = a:'a' (a:'a')", {
|
||||
message: "Label \"a\" is already defined at line 1, column 9.",
|
||||
location: {
|
||||
start: { offset: 15, line: 1, column: 16 },
|
||||
end: { offset: 20, line: 1, column: 21 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "doesn't report labels duplicate with the label of the current element", function () {
|
||||
|
||||
expect( pass ).to.not.reportError( "start = a:(a:'a')" );
|
||||
|
||||
} );
|
||||
|
||||
it( "doesn't report labels duplicate with labels of following elements", function () {
|
||||
|
||||
expect( pass ).to.not.reportError( "start = (a:'a') a:'a'" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,24 +1,28 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let helpers = require("./helpers");
|
||||
let pass = require("../../../../../lib/compiler/passes/report-duplicate-rules");
|
||||
|
||||
chai.use(helpers);
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("compiler pass |reportDuplicateRules|", function() {
|
||||
it("reports duplicate rules", function() {
|
||||
expect(pass).to.reportError([
|
||||
"start = 'a'",
|
||||
"start = 'b'"
|
||||
].join("\n"), {
|
||||
message: "Rule \"start\" is already defined at line 1, column 1.",
|
||||
location: {
|
||||
start: { offset: 12, line: 2, column: 1 },
|
||||
end: { offset: 23, line: 2, column: 12 }
|
||||
}
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const helpers = require( "./helpers" );
|
||||
const pass = require( "../../../../../lib/compiler/passes/report-duplicate-rules" );
|
||||
|
||||
chai.use( helpers );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "compiler pass |reportDuplicateRules|", function () {
|
||||
|
||||
it( "reports duplicate rules", function () {
|
||||
|
||||
expect( pass ).to.reportError( [
|
||||
"start = 'a'",
|
||||
"start = 'b'"
|
||||
].join( "\n" ), {
|
||||
message: "Rule \"start\" is already defined at line 1, column 1.",
|
||||
location: {
|
||||
start: { offset: 12, line: 2, column: 1 },
|
||||
end: { offset: 23, line: 2, column: 12 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,119 +1,135 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let helpers = require("./helpers");
|
||||
let pass = require("../../../../../lib/compiler/passes/report-infinite-recursion");
|
||||
|
||||
chai.use(helpers);
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("compiler pass |reportInfiniteRecursion|", function() {
|
||||
it("reports direct left recursion", function() {
|
||||
expect(pass).to.reportError("start = start", {
|
||||
message: "Possible infinite loop when parsing (left recursion: start -> start).",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 13, line: 1, column: 14 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("reports indirect left recursion", function() {
|
||||
expect(pass).to.reportError([
|
||||
"start = stop",
|
||||
"stop = start"
|
||||
].join("\n"), {
|
||||
message: "Possible infinite loop when parsing (left recursion: start -> stop -> start).",
|
||||
location: {
|
||||
start: { offset: 20, line: 2, column: 8 },
|
||||
end: { offset: 25, line: 2, column: 13 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
describe("in sequences", function() {
|
||||
it("reports left recursion if all preceding elements match empty string", function() {
|
||||
expect(pass).to.reportError("start = '' '' '' start");
|
||||
});
|
||||
|
||||
it("doesn't report left recursion if some preceding element doesn't match empty string", function() {
|
||||
expect(pass).to.not.reportError("start = 'a' '' '' start");
|
||||
expect(pass).to.not.reportError("start = '' 'a' '' start");
|
||||
expect(pass).to.not.reportError("start = '' '' 'a' start");
|
||||
});
|
||||
|
||||
// Regression test for #359.
|
||||
it("reports left recursion when rule reference is wrapped in an expression", function() {
|
||||
expect(pass).to.reportError("start = '' start?");
|
||||
});
|
||||
|
||||
it("computes expressions that always consume input on success correctly", function() {
|
||||
expect(pass).to.reportError([
|
||||
"start = a start",
|
||||
"a 'a' = ''"
|
||||
].join("\n"));
|
||||
expect(pass).to.not.reportError([
|
||||
"start = a start",
|
||||
"a 'a' = 'a'"
|
||||
].join("\n"));
|
||||
|
||||
expect(pass).to.reportError("start = ('' / 'a' / 'b') start");
|
||||
expect(pass).to.reportError("start = ('a' / '' / 'b') start");
|
||||
expect(pass).to.reportError("start = ('a' / 'b' / '') start");
|
||||
expect(pass).to.not.reportError("start = ('a' / 'b' / 'c') start");
|
||||
|
||||
expect(pass).to.reportError("start = ('' { }) start");
|
||||
expect(pass).to.not.reportError("start = ('a' { }) start");
|
||||
|
||||
expect(pass).to.reportError("start = ('' '' '') start");
|
||||
expect(pass).to.not.reportError("start = ('a' '' '') start");
|
||||
expect(pass).to.not.reportError("start = ('' 'a' '') start");
|
||||
expect(pass).to.not.reportError("start = ('' '' 'a') start");
|
||||
|
||||
expect(pass).to.reportError("start = a:'' start");
|
||||
expect(pass).to.not.reportError("start = a:'a' start");
|
||||
|
||||
expect(pass).to.reportError("start = $'' start");
|
||||
expect(pass).to.not.reportError("start = $'a' start");
|
||||
|
||||
expect(pass).to.reportError("start = &'' start");
|
||||
expect(pass).to.reportError("start = &'a' start");
|
||||
|
||||
expect(pass).to.reportError("start = !'' start");
|
||||
expect(pass).to.reportError("start = !'a' start");
|
||||
|
||||
expect(pass).to.reportError("start = ''? start");
|
||||
expect(pass).to.reportError("start = 'a'? start");
|
||||
|
||||
expect(pass).to.reportError("start = ''* start");
|
||||
expect(pass).to.reportError("start = 'a'* start");
|
||||
|
||||
expect(pass).to.reportError("start = ''+ start");
|
||||
expect(pass).to.not.reportError("start = 'a'+ start");
|
||||
|
||||
expect(pass).to.reportError("start = ('') start");
|
||||
expect(pass).to.not.reportError("start = ('a') start");
|
||||
|
||||
expect(pass).to.reportError("start = &{ } start");
|
||||
|
||||
expect(pass).to.reportError("start = !{ } start");
|
||||
|
||||
expect(pass).to.reportError([
|
||||
"start = a start",
|
||||
"a = ''"
|
||||
].join("\n"));
|
||||
expect(pass).to.not.reportError([
|
||||
"start = a start",
|
||||
"a = 'a'"
|
||||
].join("\n"));
|
||||
|
||||
expect(pass).to.reportError("start = '' start");
|
||||
expect(pass).to.not.reportError("start = 'a' start");
|
||||
|
||||
expect(pass).to.not.reportError("start = [a-d] start");
|
||||
|
||||
expect(pass).to.not.reportError("start = . start");
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const helpers = require( "./helpers" );
|
||||
const pass = require( "../../../../../lib/compiler/passes/report-infinite-recursion" );
|
||||
|
||||
chai.use( helpers );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "compiler pass |reportInfiniteRecursion|", function () {
|
||||
|
||||
it( "reports direct left recursion", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = start", {
|
||||
message: "Possible infinite loop when parsing (left recursion: start -> start).",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 13, line: 1, column: 14 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "reports indirect left recursion", function () {
|
||||
|
||||
expect( pass ).to.reportError( [
|
||||
"start = stop",
|
||||
"stop = start"
|
||||
].join( "\n" ), {
|
||||
message: "Possible infinite loop when parsing (left recursion: start -> stop -> start).",
|
||||
location: {
|
||||
start: { offset: 20, line: 2, column: 8 },
|
||||
end: { offset: 25, line: 2, column: 13 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
describe( "in sequences", function () {
|
||||
|
||||
it( "reports left recursion if all preceding elements match empty string", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = '' '' '' start" );
|
||||
|
||||
} );
|
||||
|
||||
it( "doesn't report left recursion if some preceding element doesn't match empty string", function () {
|
||||
|
||||
expect( pass ).to.not.reportError( "start = 'a' '' '' start" );
|
||||
expect( pass ).to.not.reportError( "start = '' 'a' '' start" );
|
||||
expect( pass ).to.not.reportError( "start = '' '' 'a' start" );
|
||||
|
||||
} );
|
||||
|
||||
// Regression test for #359.
|
||||
it( "reports left recursion when rule reference is wrapped in an expression", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = '' start?" );
|
||||
|
||||
} );
|
||||
|
||||
it( "computes expressions that always consume input on success correctly", function () {
|
||||
|
||||
expect( pass ).to.reportError( [
|
||||
"start = a start",
|
||||
"a 'a' = ''"
|
||||
].join( "\n" ) );
|
||||
expect( pass ).to.not.reportError( [
|
||||
"start = a start",
|
||||
"a 'a' = 'a'"
|
||||
].join( "\n" ) );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('' / 'a' / 'b') start" );
|
||||
expect( pass ).to.reportError( "start = ('a' / '' / 'b') start" );
|
||||
expect( pass ).to.reportError( "start = ('a' / 'b' / '') start" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' / 'b' / 'c') start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('' { }) start" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' { }) start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('' '' '') start" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' '' '') start" );
|
||||
expect( pass ).to.not.reportError( "start = ('' 'a' '') start" );
|
||||
expect( pass ).to.not.reportError( "start = ('' '' 'a') start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = a:'' start" );
|
||||
expect( pass ).to.not.reportError( "start = a:'a' start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = $'' start" );
|
||||
expect( pass ).to.not.reportError( "start = $'a' start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = &'' start" );
|
||||
expect( pass ).to.reportError( "start = &'a' start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = !'' start" );
|
||||
expect( pass ).to.reportError( "start = !'a' start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ''? start" );
|
||||
expect( pass ).to.reportError( "start = 'a'? start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ''* start" );
|
||||
expect( pass ).to.reportError( "start = 'a'* start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ''+ start" );
|
||||
expect( pass ).to.not.reportError( "start = 'a'+ start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('') start" );
|
||||
expect( pass ).to.not.reportError( "start = ('a') start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = &{ } start" );
|
||||
|
||||
expect( pass ).to.reportError( "start = !{ } start" );
|
||||
|
||||
expect( pass ).to.reportError( [
|
||||
"start = a start",
|
||||
"a = ''"
|
||||
].join( "\n" ) );
|
||||
expect( pass ).to.not.reportError( [
|
||||
"start = a start",
|
||||
"a = 'a'"
|
||||
].join( "\n" ) );
|
||||
|
||||
expect( pass ).to.reportError( "start = '' start" );
|
||||
expect( pass ).to.not.reportError( "start = 'a' start" );
|
||||
|
||||
expect( pass ).to.not.reportError( "start = [a-d] start" );
|
||||
|
||||
expect( pass ).to.not.reportError( "start = . start" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,99 +1,107 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let helpers = require("./helpers");
|
||||
let pass = require("../../../../../lib/compiler/passes/report-infinite-repetition");
|
||||
|
||||
chai.use(helpers);
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("compiler pass |reportInfiniteRepetition|", function() {
|
||||
it("reports infinite loops for zero_or_more", function() {
|
||||
expect(pass).to.reportError("start = ('')*", {
|
||||
message: "Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 13, line: 1, column: 14 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("reports infinite loops for one_or_more", function() {
|
||||
expect(pass).to.reportError("start = ('')+", {
|
||||
message: "Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 13, line: 1, column: 14 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("computes expressions that always consume input on success correctly", function() {
|
||||
expect(pass).to.reportError([
|
||||
"start = a*",
|
||||
"a 'a' = ''"
|
||||
].join("\n"));
|
||||
expect(pass).to.not.reportError([
|
||||
"start = a*",
|
||||
"a 'a' = 'a'"
|
||||
].join("\n"));
|
||||
|
||||
expect(pass).to.reportError("start = ('' / 'a' / 'b')*");
|
||||
expect(pass).to.reportError("start = ('a' / '' / 'b')*");
|
||||
expect(pass).to.reportError("start = ('a' / 'b' / '')*");
|
||||
expect(pass).to.not.reportError("start = ('a' / 'b' / 'c')*");
|
||||
|
||||
expect(pass).to.reportError("start = ('' { })*");
|
||||
expect(pass).to.not.reportError("start = ('a' { })*");
|
||||
|
||||
expect(pass).to.reportError("start = ('' '' '')*");
|
||||
expect(pass).to.not.reportError("start = ('a' '' '')*");
|
||||
expect(pass).to.not.reportError("start = ('' 'a' '')*");
|
||||
expect(pass).to.not.reportError("start = ('' '' 'a')*");
|
||||
|
||||
expect(pass).to.reportError("start = (a:'')*");
|
||||
expect(pass).to.not.reportError("start = (a:'a')*");
|
||||
|
||||
expect(pass).to.reportError("start = ($'')*");
|
||||
expect(pass).to.not.reportError("start = ($'a')*");
|
||||
|
||||
expect(pass).to.reportError("start = (&'')*");
|
||||
expect(pass).to.reportError("start = (&'a')*");
|
||||
|
||||
expect(pass).to.reportError("start = (!'')*");
|
||||
expect(pass).to.reportError("start = (!'a')*");
|
||||
|
||||
expect(pass).to.reportError("start = (''?)*");
|
||||
expect(pass).to.reportError("start = ('a'?)*");
|
||||
|
||||
expect(pass).to.reportError("start = (''*)*");
|
||||
expect(pass).to.reportError("start = ('a'*)*");
|
||||
|
||||
expect(pass).to.reportError("start = (''+)*");
|
||||
expect(pass).to.not.reportError("start = ('a'+)*");
|
||||
|
||||
expect(pass).to.reportError("start = ('')*");
|
||||
expect(pass).to.not.reportError("start = ('a')*");
|
||||
|
||||
expect(pass).to.reportError("start = (&{ })*");
|
||||
|
||||
expect(pass).to.reportError("start = (!{ })*");
|
||||
|
||||
expect(pass).to.reportError([
|
||||
"start = a*",
|
||||
"a = ''"
|
||||
].join("\n"));
|
||||
expect(pass).to.not.reportError([
|
||||
"start = a*",
|
||||
"a = 'a'"
|
||||
].join("\n"));
|
||||
|
||||
expect(pass).to.reportError("start = ''*");
|
||||
expect(pass).to.not.reportError("start = 'a'*");
|
||||
|
||||
expect(pass).to.not.reportError("start = [a-d]*");
|
||||
|
||||
expect(pass).to.not.reportError("start = .*");
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const helpers = require( "./helpers" );
|
||||
const pass = require( "../../../../../lib/compiler/passes/report-infinite-repetition" );
|
||||
|
||||
chai.use( helpers );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "compiler pass |reportInfiniteRepetition|", function () {
|
||||
|
||||
it( "reports infinite loops for zero_or_more", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = ('')*", {
|
||||
message: "Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 13, line: 1, column: 14 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "reports infinite loops for one_or_more", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = ('')+", {
|
||||
message: "Possible infinite loop when parsing (repetition used with an expression that may not consume any input).",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 13, line: 1, column: 14 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "computes expressions that always consume input on success correctly", function () {
|
||||
|
||||
expect( pass ).to.reportError( [
|
||||
"start = a*",
|
||||
"a 'a' = ''"
|
||||
].join( "\n" ) );
|
||||
expect( pass ).to.not.reportError( [
|
||||
"start = a*",
|
||||
"a 'a' = 'a'"
|
||||
].join( "\n" ) );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('' / 'a' / 'b')*" );
|
||||
expect( pass ).to.reportError( "start = ('a' / '' / 'b')*" );
|
||||
expect( pass ).to.reportError( "start = ('a' / 'b' / '')*" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' / 'b' / 'c')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('' { })*" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' { })*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('' '' '')*" );
|
||||
expect( pass ).to.not.reportError( "start = ('a' '' '')*" );
|
||||
expect( pass ).to.not.reportError( "start = ('' 'a' '')*" );
|
||||
expect( pass ).to.not.reportError( "start = ('' '' 'a')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (a:'')*" );
|
||||
expect( pass ).to.not.reportError( "start = (a:'a')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ($'')*" );
|
||||
expect( pass ).to.not.reportError( "start = ($'a')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (&'')*" );
|
||||
expect( pass ).to.reportError( "start = (&'a')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (!'')*" );
|
||||
expect( pass ).to.reportError( "start = (!'a')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (''?)*" );
|
||||
expect( pass ).to.reportError( "start = ('a'?)*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (''*)*" );
|
||||
expect( pass ).to.reportError( "start = ('a'*)*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (''+)*" );
|
||||
expect( pass ).to.not.reportError( "start = ('a'+)*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = ('')*" );
|
||||
expect( pass ).to.not.reportError( "start = ('a')*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (&{ })*" );
|
||||
|
||||
expect( pass ).to.reportError( "start = (!{ })*" );
|
||||
|
||||
expect( pass ).to.reportError( [
|
||||
"start = a*",
|
||||
"a = ''"
|
||||
].join( "\n" ) );
|
||||
expect( pass ).to.not.reportError( [
|
||||
"start = a*",
|
||||
"a = 'a'"
|
||||
].join( "\n" ) );
|
||||
|
||||
expect( pass ).to.reportError( "start = ''*" );
|
||||
expect( pass ).to.not.reportError( "start = 'a'*" );
|
||||
|
||||
expect( pass ).to.not.reportError( "start = [a-d]*" );
|
||||
|
||||
expect( pass ).to.not.reportError( "start = .*" );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
@ -1,29 +1,35 @@
|
||||
"use strict";
|
||||
|
||||
let chai = require("chai");
|
||||
let helpers = require("./helpers");
|
||||
let pass = require("../../../../../lib/compiler/passes/report-undefined-rules");
|
||||
|
||||
chai.use(helpers);
|
||||
|
||||
let expect = chai.expect;
|
||||
|
||||
describe("compiler pass |reportUndefinedRules|", function() {
|
||||
it("reports undefined rules", function() {
|
||||
expect(pass).to.reportError("start = undefined", {
|
||||
message: "Rule \"undefined\" is not defined.",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 17, line: 1, column: 18 }
|
||||
}
|
||||
});
|
||||
});
|
||||
|
||||
it("checks allowedStartRules", function() {
|
||||
expect(pass).to.reportError("start = 'a'", {
|
||||
message: "Start rule \"missing\" is not defined."
|
||||
}, {
|
||||
allowedStartRules: ["missing"]
|
||||
});
|
||||
});
|
||||
});
|
||||
const chai = require( "chai" );
|
||||
const helpers = require( "./helpers" );
|
||||
const pass = require( "../../../../../lib/compiler/passes/report-undefined-rules" );
|
||||
|
||||
chai.use( helpers );
|
||||
|
||||
const expect = chai.expect;
|
||||
|
||||
describe( "compiler pass |reportUndefinedRules|", function () {
|
||||
|
||||
it( "reports undefined rules", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = undefined", {
|
||||
message: "Rule \"undefined\" is not defined.",
|
||||
location: {
|
||||
start: { offset: 8, line: 1, column: 9 },
|
||||
end: { offset: 17, line: 1, column: 18 }
|
||||
}
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
it( "checks allowedStartRules", function () {
|
||||
|
||||
expect( pass ).to.reportError( "start = 'a'", {
|
||||
message: "Start rule \"missing\" is not defined."
|
||||
}, {
|
||||
allowedStartRules: [ "missing" ]
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
} );
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue