View source for cpp/regex/ecmascript

===Quantifiers===
* Each ''Term'' is either an ''Assertion'' (see below), or an ''Atom'' (see below), or an ''Atom'' immediately followed by a ''Quantifier''

''Term'' ::
: ''Assertion''
: ''Atom''
: ''Atom'' ''Quantifier''

Each ''Quantifier'' is either a ''greedy'' quantifier (which consists of just one ''QuantifierPrefix'') or a ''non-greedy'' quantifier (which consists of one ''QuantifierPrefix'' followed by the question mark {{ttb|?}}).

''Quantifier'' ::
: ''QuantifierPrefix''
: ''QuantifierPrefix'' {{ttb|?}}

Each ''QuantifierPrefix'' determines two numbers: the minimum number of repetitions and the maximum number of repetitions, as follows:
{|table class=wikitable
|-
!QuantifierPrefix||Minimum||Maximum
|-
| {{ttb|*}}
| zero
| infinity
|-
| {{ttb|+}}
| one
| infinity
|-
| {{ttb|?}}
| zero
| one
|-
| {{ttb|{ }} ''DecimalDigits'' {{ttb|} }}
| value of DecimalDigits
| value of DecimalDigits
|-
| {{ttb|{}} ''DecimalDigits'' {{ttb|,}} {{ttb|} }}
| value of DecimalDigits
| infinity
|-
| {{ttb|{}} ''DecimalDigits'' {{ttb|,}} ''DecimalDigits'' {{ttb|} }}
| value of DecimalDigits before the comma
| value of DecimalDigits after the comma
|}

The values of the individual ''DecimalDigits'' are obtained by calling {{lc|std::regex_traits::value}}{{mark|C++ only}} on each of the digits.

An ''Atom'' followed by a ''Quantifier'' is repeated the number of times specified by the ''Quantifier''. A ''Quantifier'' can be ''non-greedy'', in which case the ''Atom'' pattern is repeated as few times as possible while still matching the remainder of the regular expression, or it can be ''greedy'', in which case the ''Atom'' pattern is repeated as many times as possible while still matching the remainder of the regular expression.

The ''Atom'' pattern is what is repeated, not the input that it matches, so different repetitions of the ''Atom'' can match different input substrings.

If the ''Atom'' and the remainder of the regular expression all have choice points, the ''Atom'' is first matched as many (or as few, if ''non-greedy'') times as possible. All choices in the remainder of the regular expression are tried before moving on to the next choice in the last repetition of ''Atom''. All choices in the last (nth) repetition of ''Atom'' are tried before moving on to the next choice in the next-to-last (n–1)st repetition of ''Atom''; at which point it may turn out that more or fewer repetitions of ''Atom'' are now possible; these are exhausted (again, starting with either as few or as many as possible) before moving on to the next choice in the (n-1)st repetition of ''Atom'' and so on.

The ''Atom'''s captures are cleared each time it is repeated (see the {{c|"(z)((a+)?(b+)?(c))*"}} example below)

{{example
|code=
{{cpp/regex/example common}}

int main()
{
    // greedy match, repeats [a-z] 4 times
    show_matches("abcdefghi", "a[a-z]{2,4}");
    // non-greedy match, repeats [a-z] 2 times
    show_matches("abcdefghi", "a[a-z]{2,4}?");

    // Choice point ordering for quantifiers results in a match
    // with two repetitions, first matching the substring "aa",
    // second matching the substring "ba", leaving "ac" not matched
    // ("ba" appears in the capture clause m[1])
    show_matches("aabaac", "(aa{{!}}aabaac{{!}}ba{{!}}b{{!}}c)*");

    // Choice point ordering for quantifiers makes this regex 
    // calculate the greatest common divisor between 10 and 15
    // (the answer is 5, and it populates m[1] with "aaaaa")
    show_matches("aaaaaaaaaa,aaaaaaaaaaaaaaa", "^(a+)\\1*,\\1+$");

    // the substring "bbb" does not appear in the capture clause m[4]
    // because it is cleared when the second repetition of the atom
    // (a+)?(b+)?(c) is matching the substring "ac"
    // NOTE: gcc gets this wrong - it does not correctly clear the
    // matches[4] capture group as required by ECMA-262 21.2.2.5.1,
    // and thus incorrectly captures "bbb" for that group.
    show_matches("zaacbbbcac", "(z)((a+)?(b+)?(c))*");
}
|output=
input=[abcdefghi], regex=[a[a-z]{2,4}]
  prefix=[]
  smatch: m[0]=[abcde]
  suffix=[fghi]
input=[abcdefghi], regex=[a[a-z]{2,4}?]
  prefix=[]
  smatch: m[0]=[abc]
  suffix=[defghi]
input=[aabaac], regex=[(aa{{!}}aabaac{{!}}ba{{!}}b{{!}}c)*]
  prefix=[]
  smatch: m[0]=[aaba] m[1]=[ba]
  suffix=[ac]
input=[aaaaaaaaaa,aaaaaaaaaaaaaaa], regex=[^(a+)\1*,\1+$]
  prefix=[]
  smatch: m[0]=[aaaaaaaaaa,aaaaaaaaaaaaaaa] m[1]=[aaaaa]
  suffix=[]
input=[zaacbbbcac], regex=[(z)((a+)?(b+)?(c))*]
  prefix=[]
  smatch: m[0]=[zaacbbbcac] m[1]=[z] m[2]=[ac] m[3]=[a] m[4]=[] m[5]=[c] 
  suffix=[]
}}