glob/lib/src/parser.dart - Issue 1400473008: Roll Observatory packages and add a roll script

Side by Side Diff: glob/lib/src/parser.dart

Issue 1400473008: Roll Observatory packages and add a roll script (Closed) Base URL: git@github.com:dart-lang/observatory_pub_packages.git@master

Patch Set: Created 5 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

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

« no previous file with comments | « glob/lib/src/list_tree.dart ('k') | glob/lib/src/stream_pool.dart » ('j') | no next file with comments »