haml-more 0.4.0.a

data/vendor/coffee-script/vendor/jison/examples/classy_ast.json

@@ -0,0 +1,126 @@
+{
+    "comment": "ClassyLang grammar with AST-building actions. Very classy.",
+    "author": "Zach Carter",
+    "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 */"],
+            [".",          "throw 'Illegal character: '+yytext;"],
+            ["$",          "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",
+                    "$$ = ['PROGRAM',{},$1,$4,$5]; return $$;"]],
+
+        "cdl": [["c cdl",
+                    "$$ = prependChild($2, $1);"],
+                ["",
+                    "$$ = ['CLASS_DECL_LIST',{}];"]],
+
+        "c": [["CLASS id EXTENDS id LBRACE vdl mdl RBRACE",
+                "$$ = ['CLASS_DECL',{},$2,$4,$6,$7];"]],
+
+        "vdl": [["VAR t id SEMICOLON vdl",
+                    "$$ = prependChild($5, ['VAR_DECL',{},$2,$3]);"],
+                ["",
+                    "$$ = ['VAR_DECL_LIST',{}];"]],
+
+        "mdl": [["t id LPAREN t id RPAREN LBRACE vdl el RBRACE mdl",
+                    "$$ = prependChild($11, ['METHOD_DECL',{},$1,$2,$4,$5,$8,$9]);"],
+                ["",
+                    "$$ = ['METHOD_DECL_LIST',{}];"]],
+
+        "t": [["NATTYPE",
+                "$$ = ['NAT_TYPE',{}];"],
+              ["id",
+                "$$ = $1"]],
+
+        "id": [["ID",
+                    "$$ = ['AST_ID',{val:yytext}]"]],
+        "el": [["e SEMICOLON el",
+                    "$$ = prependChild($3, $1);"],
+               ["e SEMICOLON",
+                    "$$ = ['EXPR_LIST',{},$1];"]],
+
+        "e": [["NATLITERAL",   "$$ = ['NAT_LITERAL_EXPR',{val:parseInt(yytext)}];"],
+              ["NUL",          "$$ = ['NULL_EXPR',{}];"],
+              ["id",           "$$ = ['ID_EXPR',{},$1];"],
+              ["NEW id",       "$$ = ['NEW_EXPR',{},$2];"],
+              ["THIS",         "$$ = ['THIS_EXPR',{}];"],
+              ["IF LPAREN e RPAREN LBRACE el RBRACE ELSE LBRACE el RBRACE",
+                               "$$ = ['IF_THEN_ELSE_EXPR',{},$3,$6,$10];"],
+              ["FOR LPAREN e SEMICOLON e SEMICOLON e RPAREN LBRACE el RBRACE",
+                               "$$ = ['FOR_EXPR',{},$3,$5,$7,$10];"],
+              ["READNAT LPAREN RPAREN",
+                               "$$ = ['READ_EXPR',{}];"],
+              ["PRINTNAT LPAREN e RPAREN",
+                               "$$ = ['PRINT_EXPR',{},$3];"],
+              ["e PLUS e",     "$$ = ['PLUS_EXPR',{},$1,$3];"],
+              ["e MINUS e",    "$$ = ['MINUS_EXPR',{},$1,$3];"],
+              ["e TIMES e",    "$$ = ['TIMES_EXPR',{},$1,$3];"],
+              ["e EQUALITY e", "$$ = ['EQUALITY_EXPR',{},$1,$3];"],
+              ["e GREATER e",  "$$ = ['GREATER_THAN_EXPR',{},$1,$3];"],
+              ["NOT e",        "$$ = ['NOT_EXPR',{},$2];"],
+              ["e OR e",       "$$ = ['OR_EXPR',{},$1,$3];"],
+              ["e DOT id",     "$$ = ['DOT_ID_EXPR',{},$1,$3];"],
+              ["id ASSIGN e",  "$$ = ['ASSIGN_EXPR',{},$1,$3];"],
+              ["e DOT id ASSIGN e",
+                               "$$ = ['DOT_ASSIGN_EXPR',{},$1,$3,$5];"],
+              ["id LPAREN e RPAREN",
+                               "$$ = ['METHOD_CALL_EXPR',{},$1,$3];"],
+              ["e DOT id LPAREN e RPAREN",
+                               "$$ = ['DOT_METHOD_CALL_EXPR',{},$1,$3,$5];"],
+              ["LPAREN e RPAREN",
+                               "$$ = $2;"]]
+    },
+
+    "actionInclude": "function prependChild(node, child){ node.splice(2,0,child); return node; }"
+}
+

data/vendor/coffee-script/vendor/jison/examples/dism.json

@@ -0,0 +1,25 @@
+{
+   "author": "Jay Ligatti",
+
+   "tokens": "ADD SUB MUL MOV LOD STR JMP BEQ BLT RDN PTN HLT INT LABEL COLON",
+   "bnf": {
+       "pgm" :[ "instlist" ],
+       "instlist" :[ "label COLON inst instlist",
+                     "inst instlist",
+                     "" ],
+       "inst" :[ "ADD intt intt intt",
+                 "SUB intt intt intt",
+                 "MUL intt intt intt",
+                 "MOV intt intt",
+                 "LOD intt intt intt",
+                 "STR intt intt intt",
+                 "JMP intt intt intt",
+                 "BEQ intt intt intt",
+                 "BLT intt intt intt",
+                 "RDN intt",
+                 "PTN intt",
+                 "HLT intt"],
+       "label" :[ "LABEL" ],
+       "intt" :[ "INT", "label" ]
+   }
+}

data/vendor/coffee-script/vendor/jison/examples/dism_lr0.json

@@ -0,0 +1,26 @@
+{
+   "author": "Jay Ligatti",
+
+   "tokens": "ADD SUB MUL MOV LOD STR JMP BEQ BLT RDN PTN HLT INT LABEL COLON",
+   "bnf": {
+       "instlist" :[ "instlist label COLON inst",
+                     "instlist inst",
+                     "inst" ],
+
+       "inst" :[ "ADD intt intt intt",
+                 "SUB intt intt intt",
+                 "MUL intt intt intt",
+                 "MOV intt intt",
+                 "LOD intt intt intt",
+                 "STR intt intt intt",
+                 "JMP intt intt intt",
+                 "BEQ intt intt intt",
+                 "BLT intt intt intt",
+                 "RDN intt",
+                 "PTN intt",
+                 "HLT intt"],
+       "label" :[ "LABEL" ],
+       "intt" :[ "INT", "label" ]
+   }
+}
+

data/vendor/coffee-script/vendor/jison/examples/json.js

@@ -0,0 +1,80 @@
+var Generator = require("jison").Generator;
+var system = require("system");
+var fs = require("file");
+
+exports.grammar = {
+    "comment": "ECMA-262 5th Edition, 15.12.1 The JSON Grammar.",
+    "author": "Zach Carter",
+
+    "lex": {
+        "macros": {
+            "digit": "[0-9]",
+            "esc": "\\\\",
+            "int": "-?(?:[0-9]|[1-9][0-9]+)",
+            "exp": "(?:[eE][-+]?[0-9]+)",
+            "frac": "(?:\\.[0-9]+)"
+        },
+        "rules": [
+            ["\\s+", "/* skip whitespace */"],
+            ["{int}{frac}?{exp}?\\b", "return 'NUMBER';"],
+            ["\"(?:{esc}[\"bfnrt/{esc}]|{esc}u[a-fA-F0-9]{4}|[^\"{esc}])*\"", "yytext = yytext.substr(1,yyleng-2); return 'STRING';"],
+            ["\\{", "return '{'"],
+            ["\\}", "return '}'"],
+            ["\\[", "return '['"],
+            ["\\]", "return ']'"],
+            [",", "return ','"],
+            [":", "return ':'"],
+            ["true\\b", "return 'TRUE'"],
+            ["false\\b", "return 'FALSE'"],
+            ["null\\b", "return 'NULL'"]
+        ]
+    },
+
+    "tokens": "STRING NUMBER { } [ ] , : TRUE FALSE NULL",
+    "start": "JSONText",
+
+    "bnf": {
+        "JSONString": [ "STRING" ],
+
+        "JSONNumber": [ "NUMBER" ],
+
+        "JSONBooleanLiteral": [ "TRUE", "FALSE" ],
+
+
+        "JSONText": [ "JSONValue" ],
+
+        "JSONValue": [ "JSONNullLiteral",
+                       "JSONBooleanLiteral",
+                       "JSONString",
+                       "JSONNumber",
+                       "JSONObject",
+                       "JSONArray" ],
+
+        "JSONObject": [ "{ }",
+                        "{ JSONMemberList }" ],
+
+        "JSONMember": [ "JSONString : JSONValue" ],
+
+        "JSONMemberList": [ "JSONMember",
+                              "JSONMemberList , JSONMember" ],
+
+        "JSONArray": [ "[ ]",
+                       "[ JSONElementList ]" ],
+
+        "JSONElementList": [ "JSONValue",
+                             "JSONElementList , JSONValue" ]
+    }
+};
+
+var options = {type: "slr", moduleType: "commonjs", moduleName: "jsoncheck"};
+
+exports.main = function main (args) {
+    var cwd = fs.path(fs.cwd()),
+        code = new Generator(exports.grammar, options).generate(),
+        stream = cwd.join(options.moduleName+".js").open("w");
+    stream.print(code).close();
+};
+
+if (require.main === module)
+    exports.main(system.args);
+

data/vendor/coffee-script/vendor/jison/examples/json_ast.js

@@ -0,0 +1,83 @@
+var Generator = require("jison").Generator;
+var system = require("system");
+var fs = require("file");
+
+exports.grammar = {
+    "comment": "ECMA-262 5th Edition, 15.12.1 The JSON Grammar. Parses JSON strings into objects.",
+    "author": "Zach Carter",
+
+    "lex": {
+        "macros": {
+            "digit": "[0-9]",
+            "esc": "\\\\",
+            "int": "-?(?:[0-9]|[1-9][0-9]+)",
+            "exp": "(?:[eE][-+]?[0-9]+)",
+            "frac": "(?:\\.[0-9]+)"
+        },
+        "rules": [
+            ["\\s+", "/* skip whitespace */"],
+            ["{int}{frac}?{exp}?\\b", "return 'NUMBER';"],
+            ["\"(?:{esc}[\"bfnrt/{esc}]|{esc}u[a-fA-F0-9]{4}|[^\"{esc}])*\"", "yytext = yytext.substr(1,yyleng-2); return 'STRING';"],
+            ["\\{", "return '{'"],
+            ["\\}", "return '}'"],
+            ["\\[", "return '['"],
+            ["\\]", "return ']'"],
+            [",", "return ','"],
+            [":", "return ':'"],
+            ["true\\b", "return 'TRUE'"],
+            ["false\\b", "return 'FALSE'"],
+            ["null\\b", "return 'NULL'"]
+        ]
+    },
+
+    "tokens": "STRING NUMBER { } [ ] , : TRUE FALSE NULL",
+    "start": "JSONText",
+
+    "bnf": {
+        "JSONString": [[ "STRING", "$$ = yytext;" ]],
+
+        "JSONNumber": [[ "NUMBER", "$$ = Number(yytext);" ]],
+
+        "JSONNullLiteral": [[ "NULL", "$$ = null;" ]],
+
+        "JSONBooleanLiteral": [[ "TRUE", "$$ = true;" ],
+                               [ "FALSE", "$$ = false;" ]],
+
+
+        "JSONText": [[ "JSONValue", "return $$ = $1;" ]],
+
+        "JSONValue": [[ "JSONNullLiteral",    "$$ = $1;" ],
+                      [ "JSONBooleanLiteral", "$$ = $1;" ],
+                      [ "JSONString",         "$$ = $1;" ],
+                      [ "JSONNumber",         "$$ = $1;" ],
+                      [ "JSONObject",         "$$ = $1;" ],
+                      [ "JSONArray",          "$$ = $1;" ]],
+
+        "JSONObject": [[ "{ }", "$$ = {};" ],
+                       [ "{ JSONMemberList }", "$$ = $2;" ]],
+
+        "JSONMember": [[ "JSONString : JSONValue", "$$ = [$1, $3];" ]],
+
+        "JSONMemberList": [[ "JSONMember", "$$ = {}; $$[$1[0]] = $1[1];" ],
+                           [ "JSONMemberList , JSONMember", "$$ = $1; $1[$3[0]] = $3[1];" ]],
+
+        "JSONArray": [[ "[ ]", "$$ = [];" ],
+                      [ "[ JSONElementList ]", "$$ = $2;" ]],
+
+        "JSONElementList": [[ "JSONValue", "$$ = [$1];" ],
+                            [ "JSONElementList , JSONValue", "$$ = $1; $1.push($3);" ]]
+    }
+};
+
+var options = {type: "slr", moduleType: "commonjs", moduleName: "jsonparse"};
+
+exports.main = function main (args) {
+    var cwd = fs.path(fs.cwd()),
+        code = new Generator(exports.grammar, options).generate(),
+        stream = cwd.join(options.moduleName+".js").open("w");
+    stream.print(code).close();
+};
+
+if (require.main === module)
+    exports.main(system.args);
+

data/vendor/coffee-script/vendor/jison/examples/precedence.json

@@ -0,0 +1,26 @@
+{
+    "comment": "Grammar showing precedence operators and semantic actions.",
+
+    "lex": {
+        "rules": [
+           ["\\s+", "/* skip whitespace */"],
+           ["[0-9]+", "return 'NAT';"],
+           ["\\+", "return '+';"],
+           ["\\*", "return '*';"],
+           ["$", "return 'EOF';"]
+        ]
+    },
+
+    "tokens": "NAT + * EOF",
+    "operators": [
+        ["left", "+"],
+        ["left", "*"]
+    ],
+    "bnf": {
+        "S" :[[ "e EOF",   "return $1;"  ]],
+        "e" :[[ "e + e",   "$$ = [$1,'+', $3];" ],
+              [ "e * e",   "$$ = [$1, '*', $3];" ],
+              [ "NAT",     "$$ = parseInt(yytext);" ]]
+    }
+}
+

data/vendor/coffee-script/vendor/jison/examples/reduce_conflict.json

@@ -0,0 +1,13 @@
+{
+    "comment": "Produces a reduce-reduce conflict unless using LR(1).",
+    "tokens": "z d b c a",
+    "start": "S",
+    "bnf": {
+        "S" :[ "a A c",
+               "a B d",
+               "b A d",
+               "b B c"],
+        "A" :[ "z" ],
+        "B" :[ "z" ]
+    }
+}

data/vendor/coffee-script/vendor/jison/lib/jison/bnf.js

@@ -0,0 +1,43 @@
+if (typeof require !== 'undefined') {
+    var bnf = require("./util/bnf-parser").parser;
+    exports.parse = function parse () { return bnf.parse.apply(bnf, arguments) };
+}
+
+// adds a declaration to the grammar
+bnf.yy.addDeclaration = function (grammar, decl) {
+    if (decl.start) {
+        grammar.start = decl.start
+    }
+    if (decl.operator) {
+        if (!grammar.operators) {
+            grammar.operators = [];
+        }
+        grammar.operators.push(decl.operator);
+    }
+
+};
+
+// helps tokenize comments
+bnf.yy.lexComment = function (lexer) {
+    var ch = lexer.input();
+    if (ch === '/') {
+        lexer.yytext = lexer.yytext.replace(/\*(.|\s)\/\*/, '*$1');
+        return;
+    } else {
+        lexer.unput('/*');
+        lexer.more();
+    }
+}
+
+// helps tokenize actions
+bnf.yy.lexAction = function (lexer) {
+    var ch = lexer.input();
+    if (ch === '}') {
+        lexer.yytext = lexer.yytext.substr(2, lexer.yyleng-4).replace(/\}(.|\s)\{\{/, '}$1');
+        return 'ACTION';
+    } else {
+        lexer.unput('{{');
+        lexer.more();
+    }
+}
+

data/vendor/coffee-script/vendor/jison/lib/jison/jisonlex.js

@@ -0,0 +1,18 @@
+if (typeof require !== 'undefined') {
+    var jisonlex = require("./util/lex-parser").parser;
+    exports.parse = function parse () {
+        jisonlex.yy.ruleSection = false;
+        return jisonlex.parse.apply(jisonlex, arguments);
+    };
+}
+
+function encodeRE (s) { return s.replace(/([.*+?^${}()|[\]\/\\])/g, '\\$1'); }
+
+jisonlex.yy = {
+    prepareString: function (s) {
+        // unescape slashes
+        s = s.replace(/\\\\/g, "\\");
+        s = encodeRE(s);
+        return s;
+    }
+};

data/vendor/coffee-script/vendor/jison/lib/jison/json2jison.js

@@ -0,0 +1,146 @@
+// converts json grammar format to Jison grammar format
+
+function json2jison (grammar) {
+    var s = "";
+
+    s += genDecls(grammar);
+    s += genBNF(grammar.bnf);
+
+    return s;
+}
+
+function genDecls (grammar) {
+    var s = "",
+        key;
+
+    for (key in grammar) if (grammar.hasOwnProperty(key)) {
+        if (key === 'start') {
+            s += "\n%start "+grammar.start+"\n\n";
+        }
+        if (key === 'author') {
+            s += "\n/* author: "+grammar.author+" */\n\n";
+        }
+        if (key === 'comment') {
+            s += "\n/* description: "+grammar.comment+" */\n\n";
+        }
+        if (key === 'operators') {
+            for (var i=0; i<grammar.operators.length; i++) {
+                s += "%"+grammar.operators[i][0]+' '+quoteSymbols(grammar.operators[i].slice(1).join(' '))+"\n";
+            }
+            s += "\n";
+        }
+    }
+
+    return s;
+}
+
+function genBNF (bnf) {
+    var s = "%%\n",
+        sym;
+
+    for (sym in bnf) if (bnf.hasOwnProperty(sym)) {
+        s += ["\n",sym,'\n    : ', genHandles(bnf[sym]),"\n    ;\n"].join("");
+    }
+
+    return s;
+}
+
+function genHandles (handle) {
+    if (typeof handle === 'string') {
+        return handle;
+    } else { //array
+        var s = "";
+        for (var i=0; i< handle.length;i++) {
+            if (typeof handle[i] === 'string' && handle[i]) {
+                s += quoteSymbols(handle[i]);
+            } else if (handle[i] instanceof Array) {
+                s += (handle[i][0] && quoteSymbols(handle[i][0]));
+                if (typeof handle[i][1] === 'string') {
+                    s += handle[i][1].match(/\}/) ? 
+                        "\n        {{"+handle[i][1]+(handle[i][1].match(/\}$/) ? ' ' : '')+"}}" :
+                        "\n        {"+handle[i][1]+"}";
+                    if (handle[i][2] && handle[i][2].prec) {
+                        s += " %prec "+handle[i][2].prec;
+                    }
+                } else if (handle[i][1].prec) {
+                    s += " %prec "+handle[i][1].prec;
+                }
+            }
+            if (typeof handle[i+1] !== 'undefined')
+                s += "\n    | ";
+        }
+        return s;
+    }
+}
+
+function quoteSymbols (rhs) {
+    rhs = rhs.split(' ');
+
+    for (var i=0; i<rhs.length; i++) {
+        rhs[i] = quoteSymbol(rhs[i]);
+    }
+    return rhs.join(' ');
+}
+
+function quoteSymbol (sym) {
+    if (!/[a-zA-Z][a-zA-Z0-9_-]*/.test(sym)) {
+        var quote = /'/.test(sym) ? '"' : "'";
+        sym = quote+sym+quote;
+    }
+    return sym;
+}
+
+
+// Generate lex format from lex JSON
+
+function genLex (lex) {
+    var s = [];
+
+    if (lex.macros) {
+        for (var macro;macro=lex.macros.shift();) {
+            s.push(macro[0], '\t\t', macros[1], '\n');
+        }
+    }
+    if (lex.actionInclude) {
+        s.push('\n%{\n', lex.actionInclude, '\n%}\n');
+    }
+    s.push('\n%%\n');
+    if (lex.rules) {
+        for (var rule;rule=lex.rules.shift();) {
+            s.push(rule[0], '    ', genLexRule(rule[1]), '\n');
+        }
+    }
+    s.push('\n%%\n');
+
+    return s.join('');
+}
+
+function genLexRule (rule) {
+    return rule.match(/\\}/) ? '%{'+rule+'}%' : '{'+rule+'}';
+}
+
+exports.json2jison = json2jison;
+exports.convert = json2jison;
+
+exports.main = function main (args) {
+    var fs = require("file");
+        gfile = fs.path(fs.cwd()).join(args[1]),
+        grammar = JSON.parse(gfile.read({charset: "utf-8"}));
+
+    if (grammar.bnf) {
+        var fname = fs.path(fs.cwd()).join(gfile.basename(".json") + ".jison"),
+            stream = fname.open("w");
+        stream.print(json2jison(grammar));
+        stream.close();
+    }
+
+    var lex = grammar.lex || grammar.rules && grammar;
+
+    if (lex) {
+        var fname = fs.path(fs.cwd()).join(gfile.basename(".json").replace(/[._]?lex$/,'') + ".jisonlex"),
+            stream = fname.open("w");
+        stream.print(genLex(lex));
+        stream.close();
+    }
+};
+