haml-more 0.4.0.a

data/vendor/coffee-script/vendor/jison/tests/parser/precedence.js

@@ -0,0 +1,237 @@
+var Jison = require("../setup").Jison,
+    RegExpLexer = require("../setup").RegExpLexer,
+    assert = require("assert");
+
+var lexData = {
+    rules: [
+       ["x", "return 'x';"],
+       ["\\+", "return '+';"],
+       ["$", "return 'EOF';"]
+    ]
+};
+
+exports["test Left associative rule"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["\\+", "return '+';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: [ "x", "+", "EOF" ],
+        startSymbol: "S",
+        operators: [
+            ["left", "+"]
+        ],
+        bnf: {
+            "S" :[ [ 'E EOF',   "return $1;" ] ],
+            "E" :[ [ "E + E",   "$$ = ['+', $1, $3];" ],
+                   [ "x",       "$$ = ['x'];"] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    var expectedAST = ["+", ["+", ["x"], ["x"]], ["x"]];
+
+    var r = parser.parse("x+x+x");
+    assert.deepEqual(r, expectedAST);
+};
+
+exports["test Right associative rule"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["\\+", "return '+';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: [ "x", "+", "EOF" ],
+        startSymbol: "S",
+        operators: [
+            ["right", "+"]
+        ],
+        bnf: {
+            "S" :[ [ "E EOF",   "return $1;"          ] ],
+            "E" :[ [ "E + E",   "$$ = ['+', $1, $3];" ],
+                   [ "x",       "$$ = ['x'];"         ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    var expectedAST = ["+", ["x"], ["+", ["x"], ["x"]]];
+
+    var r = parser.parse("x+x+x");
+    assert.deepEqual(r, expectedAST);
+};
+
+exports["test Multiple precedence operators"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["\\+", "return '+';"],
+           ["\\*", "return '*';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: [ "x", "+", "*", "EOF" ],
+        startSymbol: "S",
+        operators: [
+            ["left", "+"],
+            ["left", "*"]
+        ],
+        bnf: {
+            "S" :[ [ "E EOF",   "return $1;"          ] ],
+            "E" :[ [ "E + E",   "$$ = ['+', $1, $3];" ],
+                   [ "E * E",   "$$ = ['*', $1, $3];" ],
+                   [ "x",       "$$ = ['x'];"         ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    var expectedAST = ["+", ["*", ["x"], ["x"]], ["x"]];
+
+    var r = parser.parse("x*x+x");
+    assert.deepEqual(r, expectedAST);
+};
+
+exports["test Multiple precedence operators"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["\\+", "return '+';"],
+           ["\\*", "return '*';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: [ "x", "+", "*", "EOF" ],
+        startSymbol: "S",
+        operators: [
+            ["left", "+"],
+            ["left", "*"]
+        ],
+        bnf: {
+            "S" :[ [ "E EOF",   "return $1;"          ] ],
+            "E" :[ [ "E + E",   "$$ = [$1,'+', $3];" ],
+                   [ "E * E",   "$$ = [$1, '*', $3];" ],
+                   [ "x",       "$$ = ['x'];"         ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar);
+    parser.lexer = new RegExpLexer(lexData);
+
+    var expectedAST = [["x"], "+", [["x"], "*", ["x"]]];
+
+    var r = parser.parse("x+x*x");
+    assert.deepEqual(r, expectedAST);
+};
+
+exports["test Non-associative operator"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["=", "return '=';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: [ "x", "=", "EOF" ],
+        startSymbol: "S",
+        operators: [
+            ["nonassoc", "="]
+        ],
+        bnf: {
+            "S" :[ "E EOF" ],
+            "E" :[ "E = E",
+                   "x" ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar, {type: "lalr"});
+    parser.lexer = new RegExpLexer(lexData);
+
+    assert["throws"](function () {parser.parse("x=x=x");}, "throws parse error when operator used twice.");
+    assert.ok(parser.parse("x=x"), "normal use is okay.");
+};
+
+exports["test Context-dependent precedence"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'x';"],
+           ["-", "return '-';"],
+           ["\\+", "return '+';"],
+           ["\\*", "return '*';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: [ "x", "-", "+", "*", "EOF" ],
+        startSymbol: "S",
+        operators: [
+            ["left", "-", "+"],
+            ["left", "*"],
+            ["left", "UMINUS"]
+        ],
+        bnf: {
+            "S" :[ [ "E EOF",   "return $1;"       ] ],
+            "E" :[ [ "E - E",   "$$ = [$1,'-', $3];" ],
+                   [ "E + E",   "$$ = [$1,'+', $3];" ],
+                   [ "E * E",   "$$ = [$1,'*', $3];" ],
+                   [ "- E",     "$$ = ['#', $2];", {prec: "UMINUS"} ],
+                   [ "x",       "$$ = ['x'];"         ] ]
+        }
+    };
+
+    var parser = new Jison.Parser(grammar, {type: "slr"});
+    parser.lexer = new RegExpLexer(lexData);
+
+    var expectedAST = [[[["#", ["x"]], "*", ["#", ["x"]]], "*", ["x"]], "-", ["x"]];
+
+    var r = parser.parse("-x*-x*x-x");
+    assert.deepEqual(r, expectedAST);
+};
+
+exports["test multi-operator rules"] = function () {
+    var lexData = {
+        rules: [
+           ["x", "return 'ID';"],
+           ["\\.", "return 'DOT';"],
+           ["=", "return 'ASSIGN';"],
+           ["\\(", "return 'LPAREN';"],
+           ["\\)", "return 'RPAREN';"],
+           ["$", "return 'EOF';"]
+        ]
+    };
+    var grammar = {
+        tokens: "ID DOT ASSIGN LPAREN RPAREN EOF",
+        startSymbol: "S",
+        operators: [
+            ["right", "ASSIGN"],
+            ["left", "DOT"]
+        ],
+        bnf: {
+            "S" :[ [ "e EOF",   "return $1;"       ] ],
+            "id":[ [ "ID", "$$ = ['ID'];"] ],
+            "e" :[ [ "e DOT id",   "$$ = [$1,'-', $3];" ],
+                   [ "e DOT id ASSIGN e",   "$$ = [$1,'=', $3];" ],
+                   [ "e DOT id LPAREN e RPAREN",   "$$ = [$1,'+', $3];" ],
+                   [ "id ASSIGN e",   "$$ = [$1,'+', $3];" ],
+                   [ "id LPAREN e RPAREN",   "$$ = [$1,'+', $3];" ],
+                   [ "id",       "$$ = $1;"         ] ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: 'slr'});
+
+    assert.equal(gen.conflicts, 0);
+};

data/vendor/coffee-script/vendor/jison/tests/parser/slr.js

@@ -0,0 +1,52 @@
+var Jison = require("../setup").Jison,
+    Lexer = require("../setup").Lexer,
+    assert = require("assert");
+
+var lexData = {
+    rules: [
+       ["x", "return 'x';"],
+       ["y", "return 'y';"]
+    ]
+};
+
+exports["test left-recursive nullable grammar"] = function () {
+
+    var grammar = {
+        tokens: [ 'x' ],
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'A x',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "slr"});
+    var parser = gen.createParser();
+    parser.lexer = new Lexer(lexData);
+
+    assert.ok(parser.parse('xxx'), "parse 3 x's");
+    assert.ok(parser.parse("x"), "parse single x");
+    assert["throws"](function(){parser.parse("y")}, "throws parse error on invalid token");
+    assert.ok(gen.conflicts == 0, "no conflicts");
+};
+
+exports["test right-recursive nullable grammar"] = function () {
+
+    var grammar = {
+        tokens: [ 'x' ],
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'x A',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "slr"});
+    var parser = gen.createParser();
+    parser.lexer = new Lexer(lexData);
+
+    assert.ok(parser.parse('xxx'), "parse 3 x's");
+    assert.ok(gen.table.length == 4, "table has 4 states");
+    assert.ok(gen.conflicts == 0, "no conflicts");
+    assert.equal(gen.nullable('A'), true, "A is nullable");
+};

data/vendor/coffee-script/vendor/jison/tests/parser/tables.js

@@ -0,0 +1,126 @@
+var Jison = require("../setup").Jison,
+    assert = require("assert");
+
+exports["test right-recursive nullable grammar"] = function () {
+
+    var grammar = {
+        tokens: [ 'x' ],
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'x A',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "slr"});
+    var gen2 = new Jison.Generator(grammar, {type: "lalr"});
+
+    assert.equal(gen.table.length, 4, "table has 4 states");
+    assert.equal(gen.nullable('A'), true, "A is nullable");
+    assert.equal(gen.conflicts, 0, "should have no conflict");
+    assert.deepEqual(gen.table, gen2.table, "should have identical tables");
+};
+
+exports["test slr lalr lr tables are equal"] = function () {
+    var grammar = {
+        tokens: [ "ZERO", "PLUS"],
+        startSymbol: "E",
+        bnf: {
+            "E" :[ "E PLUS T",
+                   "T"      ],
+            "T" :[ "ZERO" ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "slr"});
+    var gen2 = new Jison.Generator(grammar, {type: "lalr"});
+    var gen3 = new Jison.Generator(grammar, {type: "lr"});
+
+    assert.deepEqual(gen.table, gen2.table, "slr lalr should have identical tables");
+    assert.deepEqual(gen2.table, gen3.table, "lalr lr should have identical tables");
+};
+
+exports["test LL parse table"] = function () {
+
+    var grammar = {
+        tokens: [ 'x' ],
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'x A',
+                   ''      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "ll"});
+
+    assert.deepEqual(gen.table, {$accept:{x:[0], $end:[0]}, A:{x:[1], $end:[2]}}, "ll table has 2 states");
+};
+
+exports["test LL parse table with conflict"] = function () {
+
+    var grammar = {
+        tokens: [ 'x' ],
+        startSymbol: "L",
+        bnf: {
+            "L" :[ 'T L T',
+                   ''      ],
+            "T" :[ "x" ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "ll"});
+    assert.equal(gen.conflicts, 1, "should have 1 conflict");
+};
+
+exports["test Ambigous grammar"] = function () {
+
+    var grammar = {
+        tokens: [ 'x', 'y' ],
+        startSymbol: "A",
+        bnf: {
+            "A" :[ 'A B A',
+                   'x'      ],
+            "B" :[ '',
+                   'y'      ]
+        }
+    };
+
+    var gen = new Jison.Generator(grammar, {type: "lr"});
+    assert.equal(gen.conflicts, 2, "should have 2 conflict");
+};
+
+// for Minimal LR testing. Not there yet.
+/*exports["test Spector grammar G1"] = function () {*/
+
+    //var grammar = {
+        //"tokens": "z d b c a",
+        //"startSymbol": "S",
+        //"bnf": {
+            //"S" :[ "a A c",
+                   //"a B d",
+                   //"b A d",
+                   //"b B c"],
+            //"A" :[ "z" ],
+            //"B" :[ "z" ]
+        //}
+    //};
+
+    //var gen = new Jison.Generator(grammar, {type: "mlr", debug:true});
+    //assert.strictEqual(gen.conflicts, 0, "should have no conflict");
+//};
+
+//exports["test De Remer G4"] = function () {
+
+    //var grammar = {
+        //"tokens": "z d b c a",
+        //"startSymbol": "S",
+        //"bnf": {
+            //"S" : "a A d | b A c | b B d",
+            //"A" : "e A | e",
+            //"B" : "e B | e" 
+        //}
+    //};
+
+    //var gen = new Jison.Generator(grammar, {type: "mlr", debug:true});
+    //assert.strictEqual(gen.conflicts, 0, "should have no conflict");
+/*};*/

data/vendor/coffee-script/vendor/jison/tests/performance.js

@@ -0,0 +1,110 @@
+#!/usr/bin/env narwhal
+
+// TODO: ...should probably have some real performance tests.
+
+var Jison = require("./setup").Jison;
+
+var grammar = {
+    "lex": {
+        "macros": {
+            "digit": "[0-9]",
+            "id": "[a-zA-Z][a-zA-Z0-9]*" 
+        },
+
+        "rules": [
+            ["//.*",       "/* ignore comment */"],
+            ["main\\b",     "return 'MAIN';"],
+            ["class\\b",    "return 'CLASS';"],
+            ["extends\\b",  "return 'EXTENDS';"],
+            ["nat\\b",      "return 'NATTYPE';"],
+            ["if\\b",       "return 'IF';"],
+            ["else\\b",     "return 'ELSE';"],
+            ["for\\b",      "return 'FOR';"],
+            ["printNat\\b", "return 'PRINTNAT';"],
+            ["readNat\\b",  "return 'READNAT';"],
+            ["this\\b",     "return 'THIS';"],
+            ["new\\b",      "return 'NEW';"],
+            ["var\\b",      "return 'VAR';"],
+            ["null\\b",     "return 'NUL';"],
+            ["{digit}+",   "return 'NATLITERAL';"],
+            ["{id}",       "return 'ID';"],
+            ["==",         "return 'EQUALITY';"],
+            ["=",          "return 'ASSIGN';"],
+            ["\\+",        "return 'PLUS';"],
+            ["-",          "return 'MINUS';"],
+            ["\\*",        "return 'TIMES';"],
+            [">",          "return 'GREATER';"],
+            ["\\|\\|",     "return 'OR';"],
+            ["!",          "return 'NOT';"],
+            ["\\.",        "return 'DOT';"],
+            ["\\{",        "return 'LBRACE';"],
+            ["\\}",        "return 'RBRACE';"],
+            ["\\(",        "return 'LPAREN';"],
+            ["\\)",        "return 'RPAREN';"],
+            [";",          "return 'SEMICOLON';"],
+            ["\\s+",       "/* skip whitespace */"],
+            [".",          "print('Illegal character');throw 'Illegal character';"],
+            ["$",          "return 'ENDOFFILE';"]
+        ]
+    },
+
+    "tokens": "MAIN CLASS EXTENDS NATTYPE IF ELSE FOR PRINTNAT READNAT THIS NEW VAR NUL NATLITERAL ID ASSIGN PLUS MINUS TIMES EQUALITY GREATER OR NOT DOT SEMICOLON LBRACE RBRACE LPAREN RPAREN ENDOFFILE",
+    "operators": [
+        ["right", "ASSIGN"],
+        ["left", "OR"],
+        ["nonassoc", "EQUALITY", "GREATER"],
+        ["left", "PLUS", "MINUS"],
+        ["left", "TIMES"],
+        ["right", "NOT"],
+        ["left", "DOT"]
+    ],
+
+    "bnf": {
+        "pgm": ["cdl MAIN LBRACE vdl el RBRACE ENDOFFILE"],
+
+        "cdl": ["c cdl",
+                ""],
+
+        "c": ["CLASS id EXTENDS id LBRACE vdl mdl RBRACE"],
+
+        "vdl": ["VAR t id SEMICOLON vdl",
+                ""],
+
+        "mdl": ["t id LPAREN t id RPAREN LBRACE vdl el RBRACE mdl",
+                ""],
+
+        "t": ["NATTYPE",
+              "id"],
+
+        "id": ["ID"],
+
+        "el": ["e SEMICOLON el",
+               "e SEMICOLON"],
+
+        "e": ["NATLITERAL",
+              "NUL",
+              "id",
+              "NEW id",
+              "THIS", 
+              "IF LPAREN e RPAREN LBRACE el RBRACE ELSE LBRACE el RBRACE ",
+              "FOR LPAREN e SEMICOLON e SEMICOLON e RPAREN LBRACE el RBRACE",
+              "READNAT LPAREN RPAREN",
+              "PRINTNAT LPAREN e RPAREN",
+              "e PLUS e",
+              "e MINUS e",
+              "e TIMES e",
+              "e EQUALITY e",
+              "e GREATER e",
+              "NOT e",
+              "e OR e",
+              "e DOT id",
+              "id ASSIGN e",
+              "e DOT id ASSIGN e",
+              "id LPAREN e RPAREN",
+              "e DOT id LPAREN e RPAREN",
+              "LPAREN e RPAREN"]
+    }
+};
+
+var parser = new Jison.Parser(grammar, {type: 'lalr'});
+

data/vendor/coffee-script/vendor/jison/tests/setup.js

@@ -0,0 +1,3 @@
+exports.Jison = require("../lib/jison").Jison;
+exports.Lexer = exports.RegExpLexer = require("../lib/jison/lexer").RegExpLexer;
+