/*
  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, opt(seq(token-separator, 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", token-separator, condition, space, '=', token-separator, handler), seq("local", token-separator, 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, '=', token-separator, expression), seq('(', opt(space), variable-list, opt(space), ')', opt(space), '=', token-separator, 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(seq(body-fragment, opt(space))), end-clause) => tokens;
end parser;

define parser end-clause ()
  rule seq("end", opt(seq(space, begin-word))) => tokens;
end parser;

define parser case-body ()
  rule seq(cases, opt(seq(opt(space), ';'))) => 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), ')', choice(seq(opt(space), "=>", opt(space), choice(seq('(', opt(space), opt(values-list), opt(space), ')', opt(space), opt(';')), seq(variable, opt(space), ';'))), opt(seq(opt(space), ';')))) => 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, opt(seq(token-separator, 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(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", opt(seq(space, pattern-keywords))))), seq("#key", opt(seq(space, 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('[', ']', "::", '-', "==", "=>", "#(", "#[", "##", "??", "?=", /*(),.;{}=?*/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 choice("define", "end", "handler", "let", "local", "macro", "otherwise") => tokens;
end parser;

define parser begin-word ()
  rule choice("begin", "block", "case", "for", "if", "method", "select", "unless", "until", "while") => tokens;
end parser;

define parser function-word ()
  rule seq(not-next(reserved-word), word) => tokens;
end parser;

define parser define-body-word ()
  rule choice("class", "library", "method", "module") => tokens;
end parser;

define parser define-list-word ()
  rule choice("constant", "variable", "domain") => 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(seq(reserved-word, req-next(token-separator))), 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 choice(macro-name, "define", "handler", "let", "local", "macro", "otherwise") => 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 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;