OLD | NEW |
(Empty) | |
| 1 // Copyright (c) 2014, the Dart project authors. Please see the AUTHORS file |
| 2 // for details. All rights reserved. Use of this source code is governed by a |
| 3 // BSD-style license that can be found in the LICENSE file. |
| 4 |
| 5 library glob.single_component; |
| 6 |
| 7 import 'package:path/path.dart' as p; |
| 8 import 'package:string_scanner/string_scanner.dart'; |
| 9 |
| 10 import 'ast.dart'; |
| 11 import 'utils.dart'; |
| 12 |
| 13 const _HYPHEN = 0x2D; |
| 14 const _SLASH = 0x2F; |
| 15 |
| 16 /// A parser for globs. |
| 17 class Parser { |
| 18 /// The scanner used to scan the source. |
| 19 final StringScanner _scanner; |
| 20 |
| 21 /// The path context for the glob. |
| 22 final p.Context _context; |
| 23 |
| 24 Parser(String component, this._context) |
| 25 : _scanner = new StringScanner(component); |
| 26 |
| 27 /// Parses an entire glob. |
| 28 SequenceNode parse() => _parseSequence(); |
| 29 |
| 30 /// Parses a [SequenceNode]. |
| 31 /// |
| 32 /// If [inOptions] is true, this is parsing within an [OptionsNode]. |
| 33 SequenceNode _parseSequence({bool inOptions: false}) { |
| 34 var nodes = []; |
| 35 |
| 36 if (_scanner.isDone) { |
| 37 _scanner.error('expected a glob.', position: 0, length: 0); |
| 38 } |
| 39 |
| 40 while (!_scanner.isDone) { |
| 41 if (inOptions && (_scanner.matches(',') || _scanner.matches('}'))) break; |
| 42 nodes.add(_parseNode(inOptions: inOptions)); |
| 43 } |
| 44 |
| 45 return new SequenceNode(nodes); |
| 46 } |
| 47 |
| 48 /// Parses an [AstNode]. |
| 49 /// |
| 50 /// If [inOptions] is true, this is parsing within an [OptionsNode]. |
| 51 AstNode _parseNode({bool inOptions: false}) { |
| 52 var star = _parseStar(); |
| 53 if (star != null) return star; |
| 54 |
| 55 var anyChar = _parseAnyChar(); |
| 56 if (anyChar != null) return anyChar; |
| 57 |
| 58 var range = _parseRange(); |
| 59 if (range != null) return range; |
| 60 |
| 61 var options = _parseOptions(); |
| 62 if (options != null) return options; |
| 63 |
| 64 return _parseLiteral(inOptions: inOptions); |
| 65 } |
| 66 |
| 67 /// Tries to parse a [StarNode] or a [DoubleStarNode]. |
| 68 /// |
| 69 /// Returns `null` if there's not one to parse. |
| 70 AstNode _parseStar() { |
| 71 if (!_scanner.scan('*')) return null; |
| 72 return _scanner.scan('*') ? new DoubleStarNode(_context) : new StarNode(); |
| 73 } |
| 74 |
| 75 /// Tries to parse an [AnyCharNode]. |
| 76 /// |
| 77 /// Returns `null` if there's not one to parse. |
| 78 AstNode _parseAnyChar() { |
| 79 if (!_scanner.scan('?')) return null; |
| 80 return new AnyCharNode(); |
| 81 } |
| 82 |
| 83 /// Tries to parse an [RangeNode]. |
| 84 /// |
| 85 /// Returns `null` if there's not one to parse. |
| 86 AstNode _parseRange() { |
| 87 if (!_scanner.scan('[')) return null; |
| 88 if (_scanner.matches(']')) _scanner.error('unexpected "]".'); |
| 89 var negated = _scanner.scan('!') || _scanner.scan('^'); |
| 90 |
| 91 readRangeChar() { |
| 92 var char = _scanner.readChar(); |
| 93 if (negated || char != _SLASH) return char; |
| 94 _scanner.error('"/" may not be used in a range.', |
| 95 position: _scanner.position - 1); |
| 96 } |
| 97 |
| 98 var ranges = []; |
| 99 while (!_scanner.scan(']')) { |
| 100 var start = _scanner.position; |
| 101 // Allow a backslash to escape a character. |
| 102 _scanner.scan('\\'); |
| 103 var char = readRangeChar(); |
| 104 |
| 105 if (_scanner.scan('-')) { |
| 106 if (_scanner.matches(']')) { |
| 107 ranges.add(new Range.singleton(char)); |
| 108 ranges.add(new Range.singleton(_HYPHEN)); |
| 109 continue; |
| 110 } |
| 111 |
| 112 // Allow a backslash to escape a character. |
| 113 _scanner.scan('\\'); |
| 114 |
| 115 var end = readRangeChar(); |
| 116 |
| 117 if (end < char) { |
| 118 _scanner.error("Range out of order.", |
| 119 position: start, |
| 120 length: _scanner.position - start); |
| 121 } |
| 122 ranges.add(new Range(char, end)); |
| 123 } else { |
| 124 ranges.add(new Range.singleton(char)); |
| 125 } |
| 126 } |
| 127 |
| 128 return new RangeNode(ranges, negated: negated); |
| 129 } |
| 130 |
| 131 /// Tries to parse an [OptionsNode]. |
| 132 /// |
| 133 /// Returns `null` if there's not one to parse. |
| 134 AstNode _parseOptions() { |
| 135 if (!_scanner.scan('{')) return null; |
| 136 if (_scanner.matches('}')) _scanner.error('unexpected "}".'); |
| 137 |
| 138 var options = []; |
| 139 do { |
| 140 options.add(_parseSequence(inOptions: true)); |
| 141 } while (_scanner.scan(',')); |
| 142 |
| 143 // Don't allow single-option blocks. |
| 144 if (options.length == 1) _scanner.expect(','); |
| 145 _scanner.expect('}'); |
| 146 |
| 147 return new OptionsNode(options); |
| 148 } |
| 149 |
| 150 /// Parses a [LiteralNode]. |
| 151 AstNode _parseLiteral({bool inOptions: false}) { |
| 152 // If we're in an options block, we want to stop parsing as soon as we hit a |
| 153 // comma. Otherwise, commas are fair game for literals. |
| 154 var regExp = new RegExp( |
| 155 inOptions ? r'[^*{[?\\}\],()]*' : r'[^*{[?\\}\]()]*'); |
| 156 |
| 157 _scanner.scan(regExp); |
| 158 var buffer = new StringBuffer()..write(_scanner.lastMatch[0]); |
| 159 |
| 160 while (_scanner.scan('\\')) { |
| 161 buffer.writeCharCode(_scanner.readChar()); |
| 162 _scanner.scan(regExp); |
| 163 buffer.write(_scanner.lastMatch[0]); |
| 164 } |
| 165 |
| 166 for (var char in const [']', '(', ')']) { |
| 167 if (_scanner.matches(char)) _scanner.error('unexpected "$char"'); |
| 168 } |
| 169 if (!inOptions && _scanner.matches('}')) _scanner.error('unexpected "}"'); |
| 170 |
| 171 return new LiteralNode(buffer.toString(), _context); |
| 172 } |
| 173 } |
OLD | NEW |