| // Copyright (c) 2011, the Dart project authors. Please see the AUTHORS file |
| // for details. All rights reserved. Use of this source code is governed by a |
| // BSD-style license that can be found in the LICENSE file. |
| |
| library Peg Parser; |
| |
| /* |
| * The following functions are combinators for building Rules. |
| * |
| * A rule is one of the following |
| * - A String which matches the string literally. |
| * - A Symbol which matches the symbol's definition. |
| * - A list of rules with an optional reducing function, which matches a sequence. |
| * - The result of calling one of the combinators. |
| * |
| * Some rules are 'value-generating' rules, they return an 'abstract syntax |
| * tree' with the match. If a rule is not value-generating [:null:] is the |
| * value. |
| * |
| * A Symbol is always a value-generating rule. If the value is not required, use |
| * [:SKIP(aSymbol):] in place of [:aSymbol:]. |
| * |
| * A String is not a value-generating rule but can be converted into one by |
| * using [:TEXT('string'):] in place of [:'string':]. |
| * |
| * A list or sequence is value-generating depending on the subrules. The |
| * sequence is value-generating if any of the subrules are value-generating or |
| * if there is a reducing function. If no reducing function is given, the value |
| * returned depends on the number of value-generating subrules. If there is |
| * only one value generating subrule, that provideds the value for the sequence. |
| * If there are more, then the value is a list of the values of the |
| * value-generating subrules. |
| */ |
| |
| /** |
| * Matches one character by a predicate on the character code. |
| * If [spec] is an int, that character is matched. |
| * If [spec] is a function it is used |
| * |
| * Example [: CHARCODE((code) => 48 <= code && code <= 57) :] recognizes an |
| * ASCII digit. |
| * |
| * CHARCODE does not generate a value. |
| */ |
| _Rule CHARCODE(spec, [name]) { |
| if (spec is int) |
| return new _CharCodeRule((code) => code == spec, name); |
| else |
| return new _CharCodeRule(spec, name); |
| } |
| |
| /** |
| * Matches one of the [characters]. |
| * |
| * CHAR does not generate a value. |
| */ |
| _Rule CHAR([characters]) { |
| if (characters == null) |
| return const _AnyCharRule(); |
| if (characters is int) |
| return CHARCODE(characters); |
| |
| // Find the range of character codes and construct an array of flags for codes |
| // within the range. |
| List<int> codes = characters.codeUnits; |
| codes.sort((a, b) => a < b ? -1 : a > b ? 1 : 0); |
| int lo = codes[0]; |
| int hi = codes[codes.length - 1]; |
| if (lo == hi) |
| return CHARCODE(lo); |
| int len = hi - lo + 1; |
| var flags = new List<bool>(len); |
| for (int i = 0; i < len; ++i) |
| flags[i] = false; |
| for (int code in codes) |
| flags[code - lo] = true; |
| |
| return CHARCODE((code) => code >= lo && code <= hi && flags[code - lo]); |
| } |
| |
| /** |
| * Matches the end of the input. |
| * |
| * END does not generate a value. |
| */ |
| _Rule get END => new _EndOfInputRule(); |
| |
| /** |
| * Throws an exception. |
| */ |
| _Rule ERROR(String message) => new _ErrorRule(message); |
| |
| /** |
| * Matches [rule] but does not consume the input. Useful for matching a right |
| * context. |
| * |
| * AT does not generate a value. |
| */ |
| _Rule AT(rule) => new _ContextRule(_compile(rule)); |
| |
| /** |
| * Matches when [rule] does not match. No input is consumed. |
| * |
| * NOT does not generate a value. |
| */ |
| _Rule NOT(rule) => new _NegativeContextRule(_compile(rule)); |
| |
| /** |
| * Matches [rule] but generates no value even if [rule] generates a value. |
| * |
| * SKIP never generates a value. |
| */ |
| _Rule SKIP(rule) => new _SkipRule(_compile(rule)); |
| |
| /** |
| * Matches [rule] in a lexical context where whitespace is not automatically |
| * skipped. Useful for matching what would normally be considered to be tokens. |
| * [name] is a user-friendly description of what is being matched and is used in |
| * error messages. |
| * |
| * LEX(rule) |
| * LEX(name, rule) |
| * |
| * LEX does not generate a value. If a value is required, wrap LEX with TEXT. |
| */ |
| _Rule LEX(arg1, [arg2]) { |
| if (arg2 == null) |
| return new _LexicalRule(arg1 is String ? arg1 : null, _compile(arg1)); |
| else |
| return new _LexicalRule(arg1, _compile(arg2)); |
| } |
| |
| /** |
| * Matches [rule] and generates a value from the matched text. If the [rule] |
| * matches, then TEXT(rule) matches and has a value derived from the string |
| * fragment that was matched. The default derived value is the string fragment. |
| * |
| * TEXT always generates a value. |
| */ |
| _Rule TEXT(rule, [extractor]) => |
| new _TextValueRule(_compile(rule), |
| extractor == null |
| ? (string, start, end) => string.substring(start, end) |
| : extractor); |
| |
| /** |
| * Matches an optional rule. |
| * |
| * MAYBE is a value generating matcher. |
| * |
| * If [rule] is value generating then the value is the value generated by [rule] |
| * if it matches, and [:null:] if it does not. |
| * |
| * If [rule] is not value generatinge then the value is [:true:] if [rule] |
| * matches and [:false:] if it does not. |
| */ |
| _Rule MAYBE(rule) => new _OptionalRule(_compile(rule)); |
| |
| /** |
| * MANY(rule) matches [rule] [min] or more times. |
| * [min] must be 0 or 1. |
| * If [separator] is provided it is used to match a separator between matches of |
| * [rule]. |
| * |
| * MANY is a value generating matcher. The value is a list of the matches of |
| * [rule]. The list may be empty if [:min == 0:]. |
| */ |
| _Rule MANY(rule, [separator = null, int min = 1]) { |
| assert(0 <= min && min <= 1); |
| return new _RepeatRule(_compile(rule), _compileOptional(separator), min); |
| } |
| |
| /** |
| * Matches [rule] zero or more times. Shorthand for [:MANY(rule, min:0):] |
| * TODO: retire min: parameter? |
| * |
| * MANY0 is a value generating matcher. |
| */ |
| _Rule MANY0(rule, [separator = null]) { |
| return new _RepeatRule(_compile(rule), _compileOptional(separator), 0); |
| } |
| |
| /** |
| * Matches [rules] in order until one succeeds. |
| * |
| * OR is value-generating. |
| */ |
| _Rule OR([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]) => |
| _compileMultiRule( |
| (a is List && b == null) // Backward compat. OR([a, b]) => OR(a, b). |
| ? a |
| : _unspread(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), |
| false, |
| (compiledRules, valueCount, reducer) => |
| new _ChoiceRule(compiledRules)); |
| |
| |
| |
| _Rule SEQ([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]) => |
| _compile(_unspread(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)); |
| |
| /** |
| * Matches [rule] |
| */ |
| _Rule MEMO(rule) => new _MemoRule(_compile(rule)); |
| |
| _Rule TAG(tag, rule) => _compile([rule, (ast) => [tag, ast]]); |
| |
| |
| class ParseError implements Exception { |
| const ParseError(String this._message); |
| String toString() => _message; |
| final String _message; |
| } |
| |
| /** |
| * A grammar is a collection of symbols and rules that may be used to parse an |
| * input. |
| */ |
| class Grammar { |
| Map<String, Symbol> _symbols; |
| |
| /** This rule may be set by the user to define whitespace. */ |
| _Rule _whitespace; |
| |
| _Rule get whitespace => _whitespace; |
| void set whitespace(rule) { _whitespace = _compile(rule); } |
| |
| Grammar() { |
| _symbols = new Map<String, Symbol>(); |
| whitespace = CHAR(' \t\r\n'); |
| } |
| |
| /** |
| * operator [] is used to find or create symbols. Symbols may appear in rules |
| * to define recursive rules. |
| */ |
| Symbol operator [](String name) { |
| if (_symbols.containsKey(name)) |
| return _symbols[name]; |
| Symbol s = new Symbol(name, this); |
| _symbols[name] = s; |
| return s; |
| } |
| |
| /** |
| * Parses the input string and returns the parsed AST, or throws an exception |
| * if the input can't be parsed. |
| */ |
| parse(root, String text) { |
| for (var symbol in _symbols.values) |
| if (symbol._rule == null) |
| print('${symbol.name} is undefined'); |
| |
| var state = new _ParserState(text, whitespace: whitespace); |
| var match = _compile(root).match(state, 0); |
| if (match == null) |
| return diagnose(state); |
| var pos = match[0]; |
| pos = _skip_whitespace(state, pos); |
| if (pos == state._end) |
| return match[1]; |
| // TODO: Make this complain about expecting end of file. |
| return diagnose(state); |
| } |
| |
| diagnose(state) { |
| var message = 'unexpected error'; |
| if (!state.max_rule.isEmpty) { |
| var s = new Set(); |
| for (var rule in state.max_rule) |
| s.add(rule.description()); |
| var tokens = new List<String>.from(s); |
| tokens.sort((a, b) => |
| a.startsWith("'") == b.startsWith("'") |
| ? a.compareTo(b) |
| : a.startsWith("'") ? +1 : -1); |
| var expected = tokens.join(' or '); |
| var found = state.max_pos == state._end ? 'end of file' |
| : "'${state._text[state.max_pos]}'"; |
| message = 'Expected $expected but found $found'; |
| } |
| int start = state.max_pos; |
| int end = start; |
| while (start >= 1 && state._text[start - 1] != '\n') --start; |
| while (end < state._text.length && state._text[end] != '\n') ++end; |
| var line = state._text.substring(start, end); |
| var indicator = ''; |
| for (var i = 0; i < line.length && start + i < state.max_pos; i++) |
| indicator = ' $indicator'; |
| indicator = '$indicator^'; |
| // TODO: Convert to an exception. |
| print(message); |
| print(line); |
| print(indicator); |
| return null; |
| } |
| } |
| |
| class Symbol { |
| final String name; |
| final Grammar grammar; |
| _Rule _rule; |
| |
| Symbol(this.name, this.grammar); |
| |
| void set def(rule) { |
| assert(_rule == null); // Assign once. |
| _rule = _compile(rule); |
| } |
| |
| toString() => _rule == null ? '<$name>' : '<$name = $_rule>'; |
| } |
| |
| |
| class _ParserState { |
| _ParserState(this._text, [_Rule whitespace = null]) { |
| _end = this._text.length; |
| whitespaceRule = whitespace; |
| max_rule = []; |
| } |
| |
| String _text; |
| int _end; |
| |
| // |
| bool inWhitespaceMode = false; |
| _Rule whitespaceRule = null; |
| |
| // Used for constructing an error message. |
| int inhibitExpectedTrackingDepth = 0; |
| int max_pos = 0; |
| var max_rule; |
| } |
| |
| /** |
| * An interface tag for rules. If this tag is on a rule, then the description() |
| * of the rule is something sensible to put in a message. |
| */ |
| abstract class _Expectable { |
| String description(); |
| } |
| |
| class _Rule { |
| const _Rule(); |
| // Returns null for a match failure or [pos, ast] for success. |
| match(_ParserState state, int pos) { |
| if (! state.inWhitespaceMode) { |
| pos = _skip_whitespace(state, pos); |
| } |
| return matchAfterWS(state, pos); |
| } |
| |
| // Faster entry point for matching a sub-rule that is matched to the start |
| // position of the super-rule. Whitespace has already been skipped so no need |
| // to try to skip it again. |
| matchAfterWS(_ParserState state, int pos) { |
| if (state.inhibitExpectedTrackingDepth == 0) { |
| // Track position for possible error messaging |
| if (pos > state.max_pos) { |
| // Store position and the rule. |
| state.max_pos = pos; |
| if (this is _Expectable) { |
| state.max_rule = [this]; |
| } else { |
| state.max_rule = []; |
| } |
| } else if (pos == state.max_pos) { |
| if (this is _Expectable) { |
| state.max_rule.add(this); |
| } |
| } |
| } |
| // Delegate the matching logic to the the specialized function. |
| return _match(state, pos); |
| } |
| |
| // Overridden in subclasses to match the rule. |
| _match(_ParserState state, int pos) => null; |
| |
| // Does the rule generate a value (AST) with the match? |
| bool get generatesValue => false; |
| |
| get defaultValue => null; |
| } |
| |
| int _skip_whitespace(state, pos) { |
| // Returns the next non-whitespace position. |
| // This is done by matching the optional whitespaceRule with the current text. |
| if (state.whitespaceRule == null) |
| return pos; |
| state.inWhitespaceMode = true; |
| state.inhibitExpectedTrackingDepth++; |
| while (true) { |
| var match = state.whitespaceRule.match(state, pos); |
| if (match == null) |
| break; |
| pos = match[0]; |
| } |
| state.inWhitespaceMode = false; |
| state.inhibitExpectedTrackingDepth--; |
| return pos; |
| } |
| |
| |
| _Rule _compileOptional(rule) { |
| return rule == null ? null : _compile(rule); |
| } |
| |
| _Rule _compile(rule) { |
| if (rule is _Rule) |
| return rule; |
| if (rule is String) |
| return new _StringRule(rule); |
| if (rule is Symbol) |
| return new _SymbolRule(rule); |
| if (rule is RegExp) |
| return new _RegExpRule(rule); |
| if (rule is List) { |
| return _compileMultiRule( |
| rule, true, |
| (compiledRules, valueCount, reducer) => |
| new _SequenceRule(compiledRules, valueCount, reducer)); |
| } |
| throw new Exception('Cannot compile rule: $rule'); |
| } |
| |
| class _EndOfInputRule extends _Rule { |
| _match(_ParserState state, int pos) { |
| if (pos == state._end) |
| return [pos, null]; |
| return null; |
| } |
| |
| toString() => 'END'; |
| } |
| |
| class _ErrorRule extends _Rule { |
| String message; |
| _ErrorRule(String this.message); |
| _match(_ParserState state, int pos) { |
| throw new ParseError(message); |
| } |
| |
| toString() => 'ERROR($message)'; |
| } |
| |
| class _CharCodeRule extends _Rule { |
| Function _predicate; |
| var _name; |
| _CharCodeRule(this._predicate, this._name); |
| _match(_ParserState state, int pos) { |
| if (pos == state._end) |
| return null; |
| int code = state._text.codeUnitAt(pos); |
| if (_predicate(code)) |
| return [pos + 1, null]; |
| return null; |
| } |
| |
| toString() => _name == null ? 'CHARCODE($_predicate)' : 'CHARCODE($_name)'; |
| } |
| |
| class _AnyCharRule extends _Rule { |
| const _AnyCharRule(); |
| _match(_ParserState state, int pos) { |
| if (pos == state._end) |
| return null; |
| return [pos + 1, null]; |
| } |
| |
| toString() => 'CHAR()'; |
| } |
| |
| class _SymbolRule extends _Rule { |
| final Symbol _symbol; |
| _SymbolRule(Symbol this._symbol); |
| _match(_ParserState state, int pos) { |
| if (_symbol._rule == null) |
| throw new Exception("Symbol '${_symbol.name}' is undefined"); |
| return _symbol._rule.match(state, pos); |
| } |
| |
| bool get generatesValue => true; |
| |
| toString() => '<${_symbol.name}>'; |
| } |
| |
| class _SkipRule extends _Rule { |
| // A rule that has no value. |
| _Rule _rule; |
| _SkipRule(_Rule this._rule); |
| _match(_ParserState state, int pos) { |
| var match = _rule.matchAfterWS(state, pos); |
| if (match == null) |
| return null; |
| return [match[0], null]; |
| } |
| |
| toString() => 'TOKEN($_rule)'; |
| } |
| |
| class _StringRule extends _Rule implements _Expectable { |
| final String _string; |
| int _len; |
| _StringRule(this._string) { |
| _len = _string.length; |
| } |
| |
| _match(_ParserState state, int pos) { |
| if (pos + _len > state._end) |
| return null; |
| for (int i = 0; i < _len; i++) { |
| if (state._text.codeUnitAt(pos + i) != _string.codeUnitAt(i)) |
| return null; |
| } |
| return [pos + _len, null]; |
| } |
| |
| //get defaultValue => _string; |
| |
| toString() => '"$_string"'; |
| |
| description() => "'$_string'"; |
| } |
| |
| class _RegExpRule extends _Rule { |
| RegExp _re; |
| _RegExpRule(this._re) { |
| // There is no convenient way to match an anchored substring. |
| throw new Exception('RegExp matching not supported'); |
| } |
| |
| toString() => '"$_re"'; |
| } |
| |
| class _LexicalRule extends _Rule implements _Expectable { |
| final String _name; |
| final _Rule _rule; |
| |
| _LexicalRule(String this._name, _Rule this._rule); |
| |
| _match(_ParserState state, int pos) { |
| state.inWhitespaceMode = true; |
| state.inhibitExpectedTrackingDepth++; |
| var match = _rule.matchAfterWS(state, pos); |
| state.inhibitExpectedTrackingDepth--; |
| state.inWhitespaceMode = false; |
| return match; |
| } |
| |
| toString() => _name; |
| |
| description() => _name == null ? '?' : _name; |
| } |
| |
| class _TextValueRule extends _Rule { |
| final _Rule _rule; |
| final _extract; // Function |
| |
| _TextValueRule(_Rule this._rule, Function this._extract); |
| |
| _match(_ParserState state, int pos) { |
| var match = _rule.matchAfterWS(state, pos); |
| if (match == null) { |
| return null; |
| } |
| var endPos = match[0]; |
| return [endPos, _extract(state._text, pos, endPos)]; |
| } |
| |
| bool get generatesValue => true; |
| |
| toString() => 'TEXT($_rule)'; |
| } |
| |
| _Rule _compileMultiRule(List rules, |
| bool allowReducer, |
| finish(compiledRules, valueCount, reducer)) { |
| int valueCount = 0; |
| List compiledRules = new List<_Rule>(); |
| Function reducer; |
| for (var rule in rules) { |
| if (reducer != null) |
| throw new Exception('Reducer must be last in sequence: $rule'); |
| if (rule is Function) { |
| if (allowReducer) |
| reducer = rule; |
| else |
| throw new Exception('Bad rule: "$rule"'); |
| } else { |
| _Rule compiledRule = _compile(rule); |
| if (compiledRule.generatesValue) |
| ++valueCount; |
| compiledRules.add(compiledRule); |
| } |
| } |
| return finish(compiledRules, valueCount, reducer); |
| } |
| |
| String _formatMultiRule(String functor, List rules) { |
| var sb = new StringBuffer(functor); |
| sb.write('('); |
| var separator = ''; |
| for (var rule in rules) { |
| sb.write(separator); |
| sb.write(rule); |
| separator = ','; |
| } |
| sb.write(')'); |
| return sb.toString(); |
| } |
| |
| class _SequenceRule extends _Rule { |
| // This rule matches the component rules in order. |
| final List<_Rule> _rules; |
| final int _generatingSubRules; |
| final Function _reducer; |
| bool _generatesValue; |
| _SequenceRule(List<_Rule> this._rules, |
| int this._generatingSubRules, |
| Function this._reducer) { |
| _generatesValue = _generatingSubRules > 0 || _reducer != null; |
| } |
| |
| _match(state, pos) { |
| var sequence = []; |
| for (var rule in _rules) { |
| var match = rule.match(state, pos); |
| if (match == null) |
| return null; |
| if (rule.generatesValue) { |
| var ast = match[1]; |
| sequence.add(ast); |
| } |
| pos = match[0]; |
| } |
| if (_reducer == null) { |
| if (_generatingSubRules == 0) |
| return [pos, null]; |
| if (_generatingSubRules == 1) |
| return [pos, sequence[0]]; |
| return [pos, sequence]; |
| } else { |
| return [pos, _apply(_reducer, sequence)]; |
| } |
| } |
| |
| bool get generatesValue => _generatesValue; |
| |
| toString() => _formatMultiRule('SEQ', _rules); |
| } |
| |
| class _ChoiceRule extends _Rule { |
| // This rule matches the first component rule that matches. |
| List<_Rule> _rules; |
| _ChoiceRule(List<_Rule> this._rules); |
| |
| _match(state, pos) { |
| for (var rule in _rules) { |
| var match = rule.match(state, pos); |
| if (match != null) { |
| /* |
| if (!rule.generatesValue) { |
| var value = rule.defaultValue; |
| if (value != null) |
| return [match[0], value]; |
| } |
| */ |
| return match; |
| } |
| } |
| return null; |
| } |
| |
| bool get generatesValue => true; |
| |
| toString() => _formatMultiRule('OR', _rules); |
| } |
| |
| class _OptionalRule extends _Rule { |
| _Rule _rule; |
| _OptionalRule(_Rule this._rule); |
| _match(_ParserState state, int pos) { |
| var match = _rule.match(state, pos); |
| if (_rule.generatesValue) |
| return match == null |
| ? [pos, null] |
| : match; |
| return match == null |
| ? [pos, false] |
| : [match[0], true]; |
| } |
| |
| bool get generatesValue => true; |
| |
| toString() => 'MAYBE($_rule)'; |
| } |
| |
| class _ContextRule extends _Rule { |
| _Rule _rule; |
| _ContextRule(_Rule this._rule); |
| _match(_ParserState state, int pos) { |
| // TODO: protect error state. |
| var match = _rule._match(state, pos); |
| if (match == null) |
| return null; |
| return [pos, null]; |
| } |
| |
| toString() => 'AT($_rule)'; |
| } |
| |
| class _NegativeContextRule extends _Rule { |
| _Rule _rule; |
| _NegativeContextRule(_Rule this._rule); |
| _match(_ParserState state, int pos) { |
| // TODO: protect error state. |
| var match = _rule._match(state, pos); |
| if (match == null) |
| return [pos, null]; |
| return null; |
| } |
| |
| toString() => 'NOT($_rule)'; |
| } |
| |
| class _RepeatRule extends _Rule { |
| // Matches zero, one or more items. |
| _Rule _rule; |
| _Rule _separator; |
| int _min; |
| |
| _RepeatRule(this._rule, this._separator, this._min); |
| |
| _match(state, pos) { |
| // First match. |
| var match = _rule.match(state, pos); |
| if (match == null) |
| if (_min == 0) |
| return [pos, []]; |
| else |
| return null; |
| pos = match[0]; |
| var result = [match[1]]; |
| |
| // Subsequent matches: |
| while (true) { |
| var newPos = pos; |
| if (_separator != null) { |
| match = _separator.match(state, pos); |
| if (match == null) |
| return [pos, result]; |
| newPos = match[0]; |
| } |
| match = _rule.match(state, newPos); |
| if (match == null) |
| return [pos, result]; |
| pos = match[0]; |
| result.add(match[1]); |
| } |
| } |
| |
| bool get generatesValue => true; |
| |
| toString() => 'MANY(min:$_min, $_rule${_separator==null?'':", sep: $_separator"})'; |
| } |
| |
| class _MemoRule extends _Rule { |
| final _Rule _rule; |
| |
| var parseInstance; |
| |
| // A map from position to result. Can this be replaced with something |
| // smaller? |
| // TODO: figure out how to discard the map and parseInstance after parsing. |
| Map<int,Object> map; |
| |
| _MemoRule(this._rule); |
| |
| _match(state, pos) { |
| // See if we are still parsing the same input. Relies on the fact that the |
| // input is a string and strings are immutable. |
| if (!identical(parseInstance, state._text)) { |
| map = new Map<int,Object>(); |
| parseInstance = state._text; |
| } |
| // TODO: does this have to check or preserve parse state (like |
| // inWhitespaceMode, error position info etc?) |
| // Stored result can be null (memoized failure). |
| if (map.containsKey(pos)) { |
| return map[pos]; |
| } |
| var match = _rule.match(state, pos); |
| map[pos] = match; |
| return match; |
| } |
| |
| bool get generatesValue => _rule.generatesValue; |
| |
| toString() => 'MEMO($_rule)'; |
| } |
| |
| _apply(fn, List args) { |
| switch (args.length) { |
| case 0: return fn(); |
| case 1: return fn(args[0]); |
| case 2: return fn(args[0], args[1]); |
| case 3: return fn(args[0], args[1], args[2]); |
| case 4: return fn(args[0], args[1], args[2], args[3]); |
| case 5: return fn(args[0], args[1], args[2], args[3], args[4]); |
| case 6: return fn(args[0], args[1], args[2], args[3], args[4], |
| args[5]); |
| case 7: return fn(args[0], args[1], args[2], args[3], args[4], |
| args[5], args[6]); |
| case 8: return fn(args[0], args[1], args[2], args[3], args[4], |
| args[5], args[6], args[7]); |
| case 9: return fn(args[0], args[1], args[2], args[3], args[4], |
| args[5], args[6], args[7], args[8]); |
| case 10: return fn(args[0], args[1], args[2], args[3], args[4], |
| args[5], args[6], args[7], args[8], args[9]); |
| |
| default: |
| throw new Exception('Too many arguments in _apply: $args'); |
| } |
| } |
| |
| List _unspread(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) { |
| List list = new List(); |
| add(element) { if (element != null) list.add(element); } |
| add(a); |
| add(b); |
| add(c); |
| add(d); |
| add(e); |
| add(f); |
| add(g); |
| add(h); |
| add(i); |
| add(j); |
| add(k); |
| add(l); |
| add(m); |
| add(n); |
| add(o); |
| add(p); |
| add(q); |
| add(r); |
| add(s); |
| add(t); |
| add(u); |
| add(v); |
| add(w); |
| add(x); |
| add(y); |
| add(z); |
| return list; |
| } |