Merge pull request #2181 from ehuss/named-range

Add support for named repeat ranges

Author: traviscross

dev-guide/src/grammar.md

@@ -52,25 +52,22 @@ Footnote -> `[^` ~[`]` LF]+ `]`
 Quantifier ->
       Optional
     | Repeat
-    | RepeatNonGreedy
     | RepeatPlus
-    | RepeatPlusNonGreedy
     | RepeatRange
     | RepeatRangeInclusive
+    | RepeatRangeNamed
 
 Optional -> `?`
 
 Repeat -> `*`
 
-RepeatNonGreedy -> `*?`
-
 RepeatPlus -> `+`
 
-RepeatPlusNonGreedy -> `+?`
+RepeatRange -> `{` ( Name `:` )? Range? `..` Range? `}`
 
-RepeatRange -> `{` Range? `..` Range? `}`
+RepeatRangeInclusive -> `{` ( Name `:` )? Range? `..=` Range `}`
 
-RepeatRangeInclusive -> `{` Range? `..=` Range `}`
+RepeatRangeNamed -> `{` Name `}`
 
 Range -> [0-9]+
 
@@ -145,11 +142,11 @@ The general format is a series of productions separated by blank lines. The expr
 | Optional | Expr? | The preceding expression is optional. |
 | NegativeLookahead | !Expr | Matches if Expr does not follow, without consuming any input. |
 | Repeat | Expr* | The preceding expression is repeated 0 or more times. |
-| RepeatNonGreedy | Expr*? | The preceding expression is repeated 0 or more times without being greedy. |
 | RepeatPlus | Expr+ | The preceding expression is repeated 1 or more times. |
-| RepeatPlusNonGreedy | Expr+? | The preceding expression is repeated 1 or more times without being greedy. |
 | RepeatRange | Expr{2..4} | The preceding expression is repeated between the range of times specified. Either bound can be excluded, which works just like Rust ranges. |
 | RepeatRangeInclusive | Expr{2..=4} | The preceding expression is repeated between the inclusive range of times specified. The lower bound can be omitted. |
+| RepeatRange (named) | Expr{name:2..4} | When a name precedes the range, the number of repetitions is bound to that name so that subsequent RepeatRangeNamed expressions can refer to it. The same applies to RepeatRangeInclusive. |
+| RepeatRangeNamed | Expr{name} | The preceding expression is repeated the number of times determined by a previously named RepeatRange or RepeatRangeInclusive. |
 
 ## Automatic linking
 

src/notation.md

@@ -18,6 +18,8 @@ The following notations are used by the *Lexer* and *Syntax* grammar snippets:
 | x<sup>+</sup>     |  _MacroMatch_<sup>+</sup>     | 1 or more of x                            |
 | x<sup>a..b</sup>  | HEX_DIGIT<sup>1..6</sup>      | a to b repetitions of x, exclusive of b   |
 | x<sup>a..=b</sup> | HEX_DIGIT<sup>1..=5</sup>     | a to b repetitions of x, inclusive of b   |
+| x<sup>n:a..=b</sup> | `#`<sup>n:1..=255</sup>      | a to b repetitions of x (inclusive of b), with the count bound to the name n |
+| x<sup>n</sup>     | `#`<sup>n</sup>               | x repeated the number of times bound to n by a previous labeled repetition |
 | Rule1 Rule2       | `fn` _Name_ _Parameters_      | Sequence of rules in order                |
 | \|                | `u8` \| `u16`, Block \| Item  | Either one or another                     |
 | !                 | !COMMENT                      | Matches if the expression does not follow, without consuming any input |

src/tokens.md

@@ -214,11 +214,13 @@ r[lex.token.literal.str-raw]
 
 r[lex.token.literal.str-raw.syntax]
 ```grammar,lexer
-RAW_STRING_LITERAL -> `r` RAW_STRING_CONTENT SUFFIX?
+RAW_STRING_LITERAL ->
+      `r` `"` ^ RAW_STRING_CONTENT `"` SUFFIX?
+    | `r` `#`{n:1..=255} ^ `"` RAW_STRING_CONTENT_HASHED `"` `#`{n} SUFFIX?
 
-RAW_STRING_CONTENT ->
-      `"` ^ ( ~CR )*? `"`
-    | `#` RAW_STRING_CONTENT `#`
+RAW_STRING_CONTENT -> (!`"` ~CR )*
+
+RAW_STRING_CONTENT_HASHED -> (!(`"` `#`{n}) ~CR )*
 ```
 
 r[lex.token.literal.str-raw.intro]
@@ -301,11 +303,12 @@ r[lex.token.str-byte-raw]
 r[lex.token.str-byte-raw.syntax]
 ```grammar,lexer
 RAW_BYTE_STRING_LITERAL ->
-    `br` RAW_BYTE_STRING_CONTENT SUFFIX?
+      `br` `"` ^ RAW_BYTE_STRING_CONTENT `"` SUFFIX?
+    | `br` `#`{n:1..=255} ^ `"` RAW_BYTE_STRING_CONTENT_HASHED `"` `#`{n} SUFFIX?
+
+RAW_BYTE_STRING_CONTENT -> (!`"` ASCII_FOR_RAW )*
 
-RAW_BYTE_STRING_CONTENT ->
-      `"` ^ ASCII_FOR_RAW*? `"`
-    | `#` RAW_BYTE_STRING_CONTENT `#`
+RAW_BYTE_STRING_CONTENT_HASHED -> (!(`"` `#`{n}) ASCII_FOR_RAW )*
 
 ASCII_FOR_RAW -> !CR ASCII
 ```
@@ -395,11 +398,12 @@ r[lex.token.str-c-raw]
 r[lex.token.str-c-raw.syntax]
 ```grammar,lexer
 RAW_C_STRING_LITERAL ->
-    `cr` RAW_C_STRING_CONTENT SUFFIX?
+      `cr` `"` ^ RAW_C_STRING_CONTENT `"` SUFFIX?
+    | `cr` `#`{n:1..=255} ^ `"` RAW_C_STRING_CONTENT_HASHED `"` `#`{n} SUFFIX?
+
+RAW_C_STRING_CONTENT -> (!`"` ~[CR NUL] )*
 
-RAW_C_STRING_CONTENT ->
-      `"` ^ ( ~[CR NUL] )*? `"`
-    | `#` RAW_C_STRING_CONTENT `#`
+RAW_C_STRING_CONTENT_HASHED -> (!(`"` `#`{n}) ~[CR NUL] )*
 ```
 
 r[lex.token.str-c-raw.intro]

tools/grammar/src/lib.rs

@@ -55,19 +55,18 @@ pub enum ExpressionKind {
     NegativeLookahead(Box<Expression>),
     /// `A*`
     Repeat(Box<Expression>),
-    /// `A*?`
-    RepeatNonGreedy(Box<Expression>),
     /// `A+`
     RepeatPlus(Box<Expression>),
-    /// `A+?`
-    RepeatPlusNonGreedy(Box<Expression>),
-    /// `A{2..4}` or `A{2..=4}`
+    /// `A{2..4}` or `A{2..=4}` or `A{name:2..=4}`
     RepeatRange {
         expr: Box<Expression>,
+        name: Option<String>,
         min: Option<u32>,
         max: Option<u32>,
         limit: RangeLimit,
     },
+    /// `A{name}`
+    RepeatRangeNamed(Box<Expression>, String),
     /// `NonTerminal`
     Nt(String),
     /// `` `string` ``
@@ -168,10 +167,9 @@ impl Expression {
             | ExpressionKind::Optional(e)
             | ExpressionKind::NegativeLookahead(e)
             | ExpressionKind::Repeat(e)
-            | ExpressionKind::RepeatNonGreedy(e)
             | ExpressionKind::RepeatPlus(e)
-            | ExpressionKind::RepeatPlusNonGreedy(e)
             | ExpressionKind::RepeatRange { expr: e, .. }
+            | ExpressionKind::RepeatRangeNamed(e, _)
             | ExpressionKind::NegExpression(e)
             | ExpressionKind::Cut(e) => {
                 e.visit_nt(callback);