62531 db-keen /* Author:: Daniel Brumbaugh Keeney (http://rubyforge.org/users/db-keen) Copyright:: 2008 Daniel Brumbaugh Keeney License:: GPLv3+ This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program. If not, see <http://www.gnu.org/licenses/>. */ /* include DylanInterchangeFormat */ define parser script () rule seq(opt(seq(lidfile, empty-line)), opt(body)) => tokens; end parser; define parser body () rule seq(constituent, opt-many(seq(opt(space), ";", opt(space), constituent)), opt(space), opt(seq(";", opt(space)))) => tokens; end parser; define parser constituent () rule choice(definition, local-declaration, expression) => tokens; end parser; define parser macro () rule choice(definition-macro-call, statement, function-macro-call) => tokens; end parser; define parser comma-property-list () rule seq(",", opt(space), property-list) => tokens; end parser; define parser property-list () rule seq(property, opt-many(seq(opt(space), ",", opt(space), property))) => tokens; end parser; define parser property () rule seq(symbol, opt(space), value) => tokens; end parser; define parser value () rule basic-fragment => tokens; end parser; define parser body-fragment () rule choice(non-statement-body-fragment, seq(statement, opt(non-statement-body-fragment))) => tokens; end parser; define parser list-fragment () rule choice(non-statement-list-fragment, seq(statement, opt(non-statement-list-fragment))) => tokens; end parser; define parser basic-fragment () rule choice(non-statement-basic-fragment, seq(statement, opt(non-statement-basic-fragment))) => tokens; end parser; define parser non-statement-body-fragment () rule choice(seq(definition, opt(seq(opt(space), semicolon-fragment))), seq(local-declaration, opt(seq(opt(space), semicolon-fragment))), seq(simple-fragment, opt(seq(opt(space), body-fragment))), seq(",", opt(seq(opt(space), body-fragment))), semicolon-fragment) => tokens; end parser; define parser semicolon-fragment () rule seq(";", opt(seq(opt(space), body-fragment))) => tokens; end parser; define parser non-statement-list-fragment () rule choice(seq(simple-fragment, opt(seq(opt(space), list-fragment))), seq(",", opt(seq(opt(space), list-fragment)))) => tokens; end parser; define parser non-statement-basic-fragment () rule seq(simple-fragment, opt(seq(opt(space), basic-fragment))) => tokens; end parser; define parser simple-fragment () rule choice(function-macro-call, constant-fragment, variable-name, binary-operator, unary-operator, bracketed-fragment, pound-word, ".", "::", "=>", "??", "?=", "?", "...", "##", "otherwise") => tokens; end parser; define parser bracketed-fragment () rule choice(seq("(", opt(space), opt(seq(body-fragment, opt(space))), ")"), seq("[", opt(space), opt(seq(body-fragment, opt(space))), "]"), seq("{", opt(space), opt(seq(body-fragment, opt(space))), "}")) => tokens; end parser; define parser constant-fragment () rule choice(number, character-literal, string, symbol, seq("#(", opt(space), constants, opt(space), ".", opt(space), constant, opt(space), ")"), seq("#(", opt(space), opt(seq(constants, opt(space))), ")"), seq("#[", opt(space), opt(seq(constants, opt(space))), "]")) => tokens; end parser; define parser definition () rule choice(definition-macro-call, seq("define", space, "macro", space, macro-definition)) => tokens; end parser; define parser definition-macro-call () rule seq("define", space, opt-many(seq(modifier, space)), choice(seq(define-body-word, token-separator, opt(body-fragment), opt(space), definition-tail), seq(define-list-word, token-separator, opt(list-fragment)))) => tokens; end parser; define parser modifier () rule unreserved-name => tokens; end parser; define parser definition-tail () rule choice(seq("end", space, define-body-word, space, macro-name), seq("end", opt(seq(space, macro-name)))) => tokens; end parser; define parser local-declaration () rule choice(seq("let", token-separator, bindings), seq("let", space, "handler", space, condition, space, "=", space, handler), seq("local", space, local-methods)) => tokens; end parser; define parser condition () rule choice(type, seq("(", type, comma-property-list, ")")) => tokens; end parser; define parser handler () rule expression => tokens; end parser; define parser local-methods () rule seq(opt(seq("method", space)), method-definition, opt-many(seq(opt(space), ",", opt(space), method-definition))) => tokens; end parser; define parser bindings () rule choice(seq(variable, space, "=", space, expression), seq("(", opt(space), variable-list, opt(space), ")", opt(space), "=", space, expression)) => tokens; end parser; define parser variable-list () rule choice(seq(variables, opt(seq(",", opt(space), "#rest", variable-name))), seq("#rest", variable-name)) => tokens; end parser; define parser variables () rule seq(variable, opt-many(seq(",", opt(space), variable))) => tokens; end parser; define parser variable () rule seq(variable-name, opt(seq(opt(space), "::", opt(space), type))) => tokens; end parser; define parser variable-name () rule ordinary-name => tokens; end parser; define parser type () rule operand => tokens; end parser; define parser expressions () rule seq(expression, opt-many(seq(",", opt(space), expression))) => tokens; end parser; define parser expression () rule seq(binary-operand, opt-many(seq(space, binary-operator, space, binary-operand))) => tokens; end parser; define parser expression-no-symbol () rule seq(binary-operand-no-symbol, opt(seq(space, binary-operator, space, expression))) => tokens; end parser; define parser binary-operand-no-symbol () rule seq(opt(unary-operator), operand) => tokens; end parser; define parser binary-operand () rule choice(symbol, seq(opt(unary-operator), operand)) => tokens; end parser; define parser operand () rule seq(leaf, opt-many(choice(seq("(", opt(space), opt(arguments), opt(space), ")"), seq("[", opt(space), opt(arguments), opt(space), "]"), seq(".", variable-name)))) => tokens; end parser; define parser function-macro-call () rule seq(function-word, opt(space), "(", opt(space), opt(body-fragment), ")") => tokens; end parser; define parser leaf () rule choice(literal, function-macro-call, variable-name, seq("(", expression, ")"), statement) => tokens; end parser; define parser arguments () rule seq(argument, opt-many(seq(opt(space), ",", opt(space), argument))) => tokens; end parser; define parser argument () rule choice(seq(symbol, expression), expression-no-symbol, symbol) => tokens; end parser; define parser literal () rule choice("#()", number, character-literal, string-literal, "#t", "#f", seq("#(", opt(space), constants, ".", constant, opt(space), ")"), seq("#(", opt(space), opt(seq(constants, opt(space))), ")"), seq("#[", opt(space), opt(seq(constants, opt(space))), "]")) => tokens; end parser; define parser string-literal () rule string => tokens; end parser; define parser constants () rule seq(constant, opt-many(seq(opt(space), ",", opt(space), constant))) => tokens; end parser; define parser constant () rule choice(literal, symbol) => tokens; end parser; define parser statement () rule seq(begin-word, token-separator, opt(body-fragment), opt(space), end-clause) => tokens; end parser; define parser end-clause () rule seq("end", opt(begin-word)) => tokens; end parser; define parser case-body () rule seq(cases, opt(space), opt(";")) => tokens; end parser; define parser cases () rule seq(case-label, opt(constituents), opt-many(seq(opt(space), ";", opt(space), case-label, opt(constituents)))) => tokens; end parser; define parser case-label () rule seq(expressions, "=>", opt(space), "(", opt(space), expression, opt(space), ",", opt(space), expressions, opt(space), ")", opt(space), "=>", "otherwise", opt(space), opt("=>")) => tokens; end parser; define parser method-definition () rule seq(variable-name, opt(space), parameter-list, opt(space), opt(body), opt(space), "end", opt(seq(space, "method")), opt(seq(space, variable-name))) => tokens; end parser; define parser parameter-list () rule seq("(", opt(parameters), ")", opt(space), choice(seq("=>", opt(space), choice(seq("(", opt(space), opt(values-list), opt(space), ")", opt(space), opt(";")), seq(variable, opt(space), ";"))), opt(";"))) => tokens; end parser; define parser parameters () rule choice(next-rest-key-parameter-list, seq(required-parameters, opt(seq(opt(space), ",", opt(space), next-rest-key-parameter-list)))) => tokens; end parser; define parser next-rest-key-parameter-list () rule choice(seq("#next", space, variable-name, opt(seq(opt(space), ",", opt(space), rest-key-parameter-list))), rest-key-parameter-list) => tokens; end parser; define parser rest-key-parameter-list () rule choice(seq("#rest", space, variable-name, opt(seq(opt(space), ",", opt(space), key-parameter-list))), key-parameter-list) => tokens; end parser; define parser key-parameter-list () rule seq("#key", space, opt(keyword-parameters), opt(space), ",", opt(space), opt("#all-keys")) => tokens; end parser; define parser required-parameters () rule seq(required-parameter, opt-many(seq(opt(space), ",", opt(space), required-parameter))) => tokens; end parser; define parser required-parameter () rule choice(seq(variable-name, space, "==", token-separator, expression), variable) => tokens; end parser; define parser keyword-parameters () rule seq(keyword-parameter, opt-many(seq(opt(space), ",", opt(space), keyword-parameter))) => tokens; end parser; define parser keyword-parameter () rule seq(opt(symbol), variable, opt(default)) => tokens; end parser; define parser default () rule seq("=", token-separator, expression) => tokens; end parser; define parser values-list () rule choice(seq(variables, opt(seq(opt(space), ",", opt(space), "#rest", space, variable))), seq("#rest", space, variable)) => tokens; end parser; define parser macro-definition () rule seq(macro-name, opt(space), main-rule-set, opt(space), opt(seq(aux-rule-sets, opt(space))), "end", opt(seq(space, "macro")), opt(seq(space, macro-name))) => tokens; end parser; define parser main-rule-set () rule choice(seq(body-style-definition-rule, opt-many(seq(opt(space), body-style-definition-rule))), seq(list-style-definition-rule, opt-many(seq(opt(space), list-style-definition-rule))), seq(statement-rule, opt-many(seq(opt(space), statement-rule))), seq(function-rule, opt-many(seq(opt(space), function-rule)))) => tokens; end parser; define parser body-style-definition-rule () rule choice(seq("{", opt(space), "define", token-separator, macro-name, token-separator, opt(pattern), opt(space), opt(seq(";", space)), "end", opt(space), "}", opt(space), "=>", token-separator, rhs), seq("{", opt(space), "define", token-separator, definition-head, space, macro-name, token-separator, opt(pattern), opt(space), opt(seq(";", space)), "end", opt(space), "}", opt(space), "=>", token-separator, rhs)) => tokens; end parser; define parser list-style-definition-rule () rule seq("{", opt(space), "define", token-separator, opt(seq(definition-head, space)), macro-name, token-separator, opt(pattern), opt(space), "}", opt(space), "=>", token-separator, rhs) => tokens; end parser; define parser rhs () rule seq("{", opt(space), opt(seq(template, opt(space))), "}", opt(seq(opt(space), ";"))) => tokens; end parser; define parser definition-head () rule many(modifier-pattern) => tokens; end parser; define parser modifier-pattern () rule choice(modifier, pattern-variable) => tokens; end parser; define parser statement-rule () rule seq("{", opt(space), macro-name, token-separator, opt(pattern), opt(space), opt(seq(";", opt(space))), "end", opt(space), "}", opt(space), "=>", token-separator, rhs) => tokens; end parser; define parser function-rule () rule seq("{", opt(space), macro-name, opt(space), "(", opt(space), opt(pattern), opt(space), ")", opt(space), "}", opt(space), "=>", token-separator, rhs) => tokens; end parser; define parser pattern () rule seq(pattern-list, opt-many(seq(opt(space), ";", opt(space), pattern-list))) => tokens; end parser; define parser pattern-list () rule choice(property-list-pattern, seq(pattern-sequence, opt(seq(opt(space), ",", opt(space), pattern-list)))) => tokens; end parser; define parser pattern-sequence () rule seq(simple-pattern, opt-many(seq(opt(space), simple-pattern))) => tokens; end parser; define parser simple-pattern () rule choice(binding-pattern, pattern-variable, name-not-end, "=>", bracketed-pattern) => tokens; end parser; define parser bracketed-pattern () rule choice(seq("(", opt(space), opt(seq(pattern, opt(space))), ")"), seq("[", opt(space), opt(seq(pattern, opt(space))), "]"), seq("{", opt(space), opt(seq(pattern, opt(space))), "}")) => tokens; end parser; define parser binding-pattern () rule choice(seq(pattern-variable, opt(space), "::", opt(space), pattern-variable), seq(pattern-variable, opt(space), "=", opt(space), pattern-variable), seq(pattern-variable, opt(space), "::", opt(space), pattern-variable, opt(space), "=", opt(space), pattern-variable)) => tokens; end parser; define parser pattern-variable () rule choice(seq("?", constrained-name), seq("?", name), "...") => tokens; end parser; define parser property-list-pattern () rule choice(seq("#rest", space, pattern-variable, opt(seq(opt(space), ",", opt(space), "#key", token-separator, opt(pattern-keywords)))), seq("#key", token-separator, opt(pattern-keywords))) => tokens; end parser; define parser pattern-keywords () rule choice("#all-keys", seq(pattern-keyword, opt(seq(opt(space), ",", opt(space), pattern-keywords)))) => tokens; end parser; define parser pattern-keyword () rule choice(seq("?", constrained-name, opt(seq(opt(space), default))), seq("?", name, opt(seq(opt(space), default))), seq("??", constrained-name, opt(seq(opt(space), default))), seq("??", name, opt(seq(opt(space), default)))) => tokens; end parser; define parser template () rule seq(template-element, opt-many(seq(opt(space), template-element))) => tokens; end parser; define parser template-element () rule choice(substitution, ".", "::", "=>", symbol, name, number, character-literal, string, separator, unary-operator, pound-word, seq("(", opt(space), opt(seq(template, opt(space))), ")"), seq("[", opt(space), opt(seq(template, opt(space))), "]"), seq("{", opt(space), opt(seq(template, opt(space))), "}"), seq("#(", opt(space), opt(seq(template, opt(space))), ")"), seq("#[", opt(space), opt(seq(template, opt(space))), "]")) => tokens; end parser; define parser separator () rule choice(/*;,*/choice(';', ','), binary-operator) => tokens; end parser; define parser substitution () rule choice(seq(opt(seq(name-prefix, opt(space))), "?", name-string-or-symbol, opt(seq(opt(space), name-suffix))), seq("??", name, opt(separator), "..."), "...", seq("?=", name)) => tokens; end parser; define parser name-prefix () rule seq(string, opt(space), "##") => tokens; end parser; define parser name-suffix () rule seq("##", opt(space), string) => tokens; end parser; define parser name-string-or-symbol () rule choice(name, string, symbol) => tokens; end parser; define parser aux-rule-sets () rule seq(aux-rule-set, opt-many(seq(opt(space), aux-rule-set))) => tokens; end parser; define parser aux-rule-set () rule seq(symbol, opt(space), aux-rules) => tokens; end parser; define parser aux-rules () rule seq(aux-rule, opt-many(seq(opt(space), aux-rule))) => tokens; end parser; define parser aux-rule () rule seq("{", opt(space), opt(seq(pattern, opt(space))), "}", opt(space), "=>", token-separator, rhs) => tokens; end parser; define parser comment () rule choice(single-line-comment, multiline-comment) => tokens; end parser; define parser multiline-comment () rule seq("/*", opt-many(seq(not-next("*/"), char)), "*/") => tokens; end parser; define parser single-line-comment () rule seq("//", opt-many(seq(not-next(eol), char)), eol) => tokens; end parser; define parser eol () rule "\n" => tokens; end parser; define parser token () rule choice(name, symbol, number, character-literal, string, unary-operator, binary-operator, punctuation, pound-word) => tokens; end parser; define parser punctuation () rule choice("(", ")", ",", ".", ";", "[", "]", "{", "}", "::", "-", "==", "=>", "=", "#(", "#[", "##", "??", "?=", "?", "...") => tokens; end parser; define parser pound-word () rule choice("#t", "#f", "#next", "#rest", "#key", "#all-keys", "#include") => tokens; end parser; define parser reserved-word () rule choice(core-word, begin-word, define-body-word, define-list-word) => tokens; end parser; define parser core-word () rule seq(choice("define", "end", "handler", "let", "local", "macro", "otherwise"), req-next(token-separator)) => tokens; end parser; define parser begin-word () rule seq(choice("begin", "block", "case", "for", "if", "method", "select", "unless", "until", "while"), req-next(token-separator)) => tokens; end parser; define parser function-word () rule seq(not-next(reserved-word), word) => tokens; end parser; define parser define-body-word () rule seq(choice("class", "library", "method", "module"), req-next(token-separator)) => tokens; end parser; define parser define-list-word () rule seq(choice("constant", "variable", "domain"), req-next(token-separator)) => tokens; end parser; define parser name () rule choice(word, seq("\' word ", operator-name)) => tokens; end parser; define parser unreserved-name () rule choice(seq(not-next(reserved-word), word), seq("\\", word), operator-name) => tokens; end parser; define parser ordinary-name () rule choice(unreserved-name, define-body-word, define-list-word) => tokens; end parser; define parser constrained-name () rule choice(seq(name, ":", word), seq(name, ":", binary-operator), seq(":", word)) => tokens; end parser; define parser operator-name () rule choice(seq("\\", unary-operator), seq("\\", binary-operator)) => tokens; end parser; define parser macro-name () rule choice(ordinary-name, begin-word, function-word) => tokens; end parser; define parser name-not-end () rule seq(choice(macro-name, "define", "handler", "let", "local", "macro", "otherwise"), req-next(token-separator)) => tokens; end parser; define parser symbol () rule choice(seq(word, ":"), seq("#", string)) => tokens; end parser; define parser word () rule choice(leading-alphabetic, seq(leading-numeric, alphabetic-character, leading-alphabetic), seq(leading-graphic, leading-alphabetic)) => tokens; end parser; define parser leading-alphabetic () rule seq(alphabetic-character, opt-many(any-character)) => tokens; end parser; define parser leading-numeric () rule seq(numeric-character, opt-many(word-character-not-double-alphabetic)) => tokens; end parser; define parser leading-graphic () rule seq(graphic-character, opt-many(word-character-not-alphabetic)) => tokens; end parser; define parser word-character-not-alphabetic () rule choice(numeric-character, graphic-character, special-character) => tokens; end parser; define parser word-character-not-double-alphabetic () rule choice(seq(alphabetic-character, word-character-not-alphabetic), numeric-character, graphic-character, special-character) => tokens; end parser; define parser any-character () rule choice(alphabetic-character, numeric-character, graphic-character, special-character) => tokens; end parser; define parser alphabetic-character () rule /*abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ*/choice('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z') => tokens; end parser; define parser numeric-character () rule /*0123456789*/choice('0', '1', '2', '3', '4', '5', '6', '7', '8', '9') => tokens; end parser; define parser graphic-character () rule /*!&*<>|^$%@_*/choice('!', '&', '*', '<', '>', '|', '^', '$', '%', '@', '_') => tokens; end parser; define parser special-character () rule /*-+~?/=*/choice('-', '+', '~', '?', '/', '=') => tokens; end parser; define parser unary-operator () rule /*-~*/choice('-', '~') => tokens; end parser; define parser binary-operator () rule choice("==", "~==", "~=", "<=", ">=", ":=", /*\+\-\*\/\^\=\<\>\&\|*/choice('+', '-', '*', '/', '^', '=', '<', '>', '&', '|')) => tokens; end parser; define parser character-literal () rule seq("'", character, "'") => tokens; end parser; define parser character () rule choice(seq(not-next("'"), not-next("\\"), printing-character), seq("\\", escape-character)) => tokens; end parser; define parser string () rule seq(""", opt-many(string-character), """) => tokens; end parser; define parser string-character () rule choice(seq(not-next("""), not-next("\\"), printing-character), seq("\\", escape-character)) => tokens; end parser; define parser escape-character () rule choice(/*\\'"abefnrt0*/choice('\', ''', '"', 'a', 'b', 'e', 'f', 'n', 'r', 't', '0'), seq("<", many(hex-digit), ">")) => tokens; end parser; define parser number () rule choice(integer, ratio, floating-point) => tokens; end parser; define parser integer () rule choice(binary-integer, octal-integer, seq(opt(sign), decimal-integer), hex-integer) => tokens; end parser; define parser binary-integer () rule seq("#", /*bB*/choice('b', 'B'), many(/*01*/choice('0', '1'))) => tokens; end parser; define parser octal-integer () rule seq("#", /*oO*/choice('o', 'O'), many(/*01234567*/choice('0', '1', '2', '3', '4', '5', '6', '7'))) => tokens; end parser; define parser decimal-integer () rule many(/*0123456789*/choice('0', '1', '2', '3', '4', '5', '6', '7', '8', '9')) => tokens; end parser; define parser hex-integer () rule seq("#", /*xX*/choice('x', 'X'), many(hex-digit)) => tokens; end parser; define parser hex-digit () rule /*0123456789ABCDEFabcdef*/choice('0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', 'a', 'b', 'c', 'd', 'e', 'f') => tokens; end parser; define parser ratio () rule seq(opt(sign), decimal-integer, "/", decimal-integer) => tokens; end parser; define parser floating-point () rule seq(opt(sign), choice(seq(opt(decimal-integer), ".", decimal-integer, opt(exponent)), seq(decimal-integer, ".", opt(decimal-integer), opt(exponent)), seq(decimal-integer, exponent))) => tokens; end parser; define parser exponent () rule seq(/*eE*/choice('e', 'E'), opt(sign), decimal-integer) => tokens; end parser; define parser sign () rule /*+-*/choice('+', '-') => tokens; end parser; define parser printing-character () rule char => tokens; end parser; define parser keyword () rule seq(name, ":") => tokens; end parser; define parser token-separator () rule choice(space, req-next(/*(),;\[\]{}*/choice('(', ')', ',', ';', '[', ']', '{', '}')), not-next(char)) => tokens; end parser; define parser space () rule many(choice(many(/* \t\v\r\n*/choice(' ', 't', 'v', 'r', 'n')), comment)) => tokens; end parser; 3422915420 #dylan TRUE